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 "du_app_mac_inf.h"
  26 #include "du_cfg.h"
  27 #include "du_app_rlc_inf.h"
  28 #include "du_mgr_main.h"
  29 #include "du_utils.h"
  30 #include "RAT-Type.h"
  31 #include "FeatureSetUplinkPerCC.h"
  32 #include "FeatureSetDownlinkPerCC.h"
  33 #include "FeatureSets.h"
  34 #include "UE-NR-Capability.h"
  35 #include "UE-CapabilityRAT-Container.h"
  36 #include "UE-CapabilityRAT-ContainerListRRC.h"
  37 #include "GNB-DU-System-Information.h"
  38 #include "CellGroupConfigRrc.h"
  39 #include "MAC-CellGroupConfig.h"
  40 #include "SchedulingRequestConfig.h"
  41 #include "SchedulingRequestToAddMod.h"
  42 #include "BSR-Config.h"
  43 #include "TAG-Config.h"
  44 #include "TAG.h"
  45 #include "PHR-Config.h"
  46 #include "RLC-Config.h"
  47 #include "UL-AM-RLC.h"
  48 #include "DL-AM-RLC.h"
  49 #include "LogicalChannelConfig.h"
  50 #include "RLC-BearerConfig.h"
  51 #include "PhysicalCellGroupConfig.h"
  52 #include "SpCellConfig.h"
  53 #include "TDD-UL-DL-ConfigDedicated.h"
  54 #include "ServingCellConfig.h"
  55 #include "ControlResourceSet.h"
  56 #include "SearchSpace.h"
  57 #include "PDCCH-Config.h"
  58 #include "PDSCH-TimeDomainResourceAllocation.h"
  59 #include "PDSCH-TimeDomainResourceAllocationList.h"
  60 #include "PDSCH-CodeBlockGroupTransmission.h"
  61 #include "PDSCH-ServingCellConfig.h"
  62 #include "DMRS-DownlinkConfig.h"
  63 #include "PDSCH-Config.h"
  64 #include "BWP-DownlinkDedicated.h"
  65 #include "PUSCH-TimeDomainResourceAllocation.h"
  66 #include "PUSCH-TimeDomainResourceAllocationList.h"
  67 #include "DMRS-UplinkConfig.h"
  68 #include "PUSCH-Config.h"
  69 #include "SRS-ResourceId.h"
  70 #include "SRS-Resource.h"
  71 #include "SRS-ResourceSet.h"
  72 #include "SRS-Config.h"
  73 #include "BWP-UplinkDedicated.h"
  74 #include "PUSCH-ServingCellConfig.h"
  75 #include "UplinkConfig.h"
  76 #include "DUtoCURRCContainer.h"
  77 #include "GBR-QoSFlowInformation.h"
  78 #include "QoSFlowLevelQoSParameters.h"
  79 #include "PUCCH-Config.h"
  80 #include "PUCCH-ResourceSet.h"
  81 #include "PUCCH-Resource.h"
  82 #include "PUCCH-PowerControl.h"
  83 #include "P0-PUCCH.h"
  84 #include "PUCCH-PathlossReferenceRS.h"
  85 #include "PUCCH-format0.h"
  86 #include "PUCCH-format1.h"
  87 #include "PUCCH-format2.h"
  88 #include "PUCCH-format3.h"
  89 #include "PUCCH-format4.h"
  90 #include "PUCCH-FormatConfig.h"
  91 #include "SchedulingRequestResourceConfig.h"
  92 #include<ProtocolIE-Field.h>
  93 #include "ProtocolExtensionField.h"
  94 #include "F1AP-PDU.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  * @brief Converts enum values into actual value of Poll retransmit timer
 114  *
 115  * @details
 116  *
 117  *    Function : getPollPdu
 118  *
 119  *    Functionality: Converts enum values into actual value of poll
 120  *    retransmit timer
 121  *
 122  * @params[in] Enum value of pollPdu
 123  * @return Actual value of pollPdu
 124  *
 125  * **********************************************************************/
 126
 127 uint16_t getPollRetxTmr(uint8_t pollRetxTmrCfg)
 128 {
 129    uint16_t pollRetxTmr;
 130
 131    /* All values of poll retx timer are at interval of 5ms.
 132     * This is valid upto 250ms
 133     * Hence converting the enum value to actual value by multiplying it to 5
 134     */
 135    if(pollRetxTmrCfg <= T_PollRetransmit_ms250)
 136       pollRetxTmr = (pollRetxTmrCfg + 1) * 5;
 137    else
 138    {
 139       switch(pollRetxTmrCfg)
 140       {
 141          case T_PollRetransmit_ms300:
 142             pollRetxTmr = 300;
 143             break;
 144          case T_PollRetransmit_ms350:
 145             pollRetxTmr = 350;
 146             break;
 147          case T_PollRetransmit_ms400:
 148             pollRetxTmr = 400;
 149             break;
 150          case T_PollRetransmit_ms450:
 151             pollRetxTmr = 450;
 152             break;
 153          case T_PollRetransmit_ms500:
 154             pollRetxTmr = 500;
 155             break;
 156          case T_PollRetransmit_ms800:
 157             pollRetxTmr = 800;
 158             break;
 159          default:
 160             DU_LOG("\nERROR  -->  F1AP: Invalid value of Poll Retransmit timer");
 161             pollRetxTmr = 0;
 162       }
 163    }
 164    return pollRetxTmr;
 165 }
 166
 167 /*******************************************************************
 168  *
 169  * @brief Converts enum values into actual value of PollPdu
 170  *
 171  * @details
 172  *
 173  *    Function : getPollPdu
 174  *
 175  *    Functionality: Converts enum values into actual value of PollPdu
 176  *
 177  * @params[in] Enum value of pollPdu
 178  * @return Actual value of pollPdu
 179  *
 180  * ****************************************************************/
 181 int32_t getPollPdu(uint8_t pollPduCfg)
 182 {
 183    int32_t pollPdu;
 184    switch(pollPduCfg)
 185    {
 186       case PollPDU_p4:
 187          pollPdu = 4;
 188          break;
 189       case PollPDU_p8:
 190          pollPdu = 8;
 191          break;
 192       case PollPDU_p16:
 193          pollPdu = 16;
 194          break;
 195       case PollPDU_p32:
 196          pollPdu = 32;
 197          break;
 198       case PollPDU_p64:
 199          pollPdu = 64;
 200          break;
 201       case PollPDU_p128:
 202          pollPdu = 128;
 203          break;
 204       case PollPDU_p256:
 205          pollPdu = 256;
 206          break;
 207       case PollPDU_p512:
 208          pollPdu = 512;
 209          break;
 210       case PollPDU_p1024:
 211          pollPdu = 1024;
 212          break;
 213       case PollPDU_p2048:
 214          pollPdu = 2048;
 215          break;
 216       case PollPDU_p4096:
 217          pollPdu = 4096;
 218          break;
 219       case PollPDU_p6144:
 220          pollPdu = 6144;
 221          break;
 222       case PollPDU_p8192:
 223          pollPdu = 8192;
 224          break;
 225       case PollPDU_p12288:
 226          pollPdu = 12288;
 227          break;
 228       case PollPDU_p16384:
 229          pollPdu = 16384;
 230          break;
 231       case PollPDU_p20480:
 232          pollPdu = 20480;
 233          break;
 234       case PollPDU_p24576:
 235          pollPdu = 24576;
 236          break;
 237       case PollPDU_p28672:
 238          pollPdu = 28672;
 239          break;
 240       case PollPDU_p32768:
 241          pollPdu = 32768;
 242          break;
 243       case PollPDU_p40960:
 244          pollPdu = 40960;
 245          break;
 246       case PollPDU_p49152:
 247          pollPdu = 49152;
 248          break;
 249       case PollPDU_p57344:
 250          pollPdu = 57344;
 251          break;
 252       case PollPDU_p65536:
 253          pollPdu = 65536;
 254          break;
 255       case PollPDU_infinity:
 256          pollPdu = -1;
 257          break;
 258       default:
 259          DU_LOG("\nERROR  -->  F1AP: Invalid value of poll pdu");
 260          pollPdu = 0;
 261          break;
 262    }
 263    return pollPdu;
 264 }
 265
 266 /*******************************************************************
 267  *
 268  * @brief Converts enum values into actual value of poll bytes
 269  *
 270  * @details
 271  *
 272  *    Function : getPollByte
 273  *
 274  *    Functionality: Converts enum values into actual value of pollBytes
 275  *
 276  * @params[in] Enum value
 277  * @return Actual value
 278  *
 279  * ****************************************************************/
 280 int32_t getPollByte(uint16_t pollBytesCfg)
 281 {
 282    int32_t pollBytes;
 283    switch(pollBytesCfg)
 284    {
 285       case PollByte_kB1:
 286          pollBytes = 1000;
 287          break;
 288       case PollByte_kB2:
 289          pollBytes = 2000;
 290          break;
 291       case PollByte_kB5:
 292          pollBytes = 5000;
 293          break;
 294       case PollByte_kB8:
 295          pollBytes = 8000;
 296          break;
 297       case PollByte_kB10:
 298          pollBytes = 10000;
 299          break;
 300       case PollByte_kB15:
 301          pollBytes = 15000;
 302          break;
 303       case PollByte_kB25:
 304          pollBytes = 25000;
 305          break;
 306       case PollByte_kB50:
 307          pollBytes = 50000;
 308          break;
 309       case PollByte_kB75:
 310          pollBytes = 75000;
 311          break;
 312       case PollByte_kB100:
 313          pollBytes = 100000;
 314          break;
 315       case PollByte_kB125:
 316          pollBytes = 125000;
 317          break;
 318       case PollByte_kB250:
 319          pollBytes = 250000;
 320          break;
 321       case PollByte_kB375:
 322          pollBytes = 375000;
 323          break;
 324       case PollByte_kB500:
 325          pollBytes = 500000;
 326          break;
 327       case PollByte_kB750:
 328          pollBytes = 750000;
 329          break;
 330       case PollByte_kB1000:
 331          pollBytes = 1000000;
 332          break;
 333       case PollByte_kB1250:
 334          pollBytes = 1250000;
 335          break;
 336       case PollByte_kB1500:
 337          pollBytes = 1500000;
 338          break;
 339       case PollByte_kB2000:
 340          pollBytes = 2000000;
 341          break;
 342       case PollByte_kB3000:
 343          pollBytes = 3000000;
 344          break;
 345       case PollByte_kB4000:
 346          pollBytes = 4000000;
 347          break;
 348       case PollByte_kB4500:
 349          pollBytes = 4500000;
 350          break;
 351       case PollByte_kB5000:
 352          pollBytes = 5000000;
 353          break;
 354       case PollByte_kB5500:
 355          pollBytes = 5500000;
 356          break;
 357       case PollByte_kB6000:
 358          pollBytes = 6000000;
 359          break;
 360       case PollByte_kB6500:
 361          pollBytes = 6500000;
 362          break;
 363       case PollByte_kB7000:
 364          pollBytes = 7000000;
 365          break;
 366       case PollByte_kB7500:
 367          pollBytes = 7500000;
 368          break;
 369       case PollByte_mB8:
 370          pollBytes = 8000000;
 371          break;
 372       case PollByte_mB9:
 373          pollBytes = 9000000;
 374          break;
 375       case PollByte_mB10:
 376          pollBytes = 10000000;
 377          break;
 378       case PollByte_mB11:
 379          pollBytes = 11000000;
 380          break;
 381       case PollByte_mB12:
 382          pollBytes = 12000000;
 383          break;
 384       case PollByte_mB13:
 385          pollBytes = 13000000;
 386          break;
 387       case PollByte_mB14:
 388          pollBytes = 14000000;
 389          break;
 390       case PollByte_mB15:
 391          pollBytes = 15000000;
 392          break;
 393       case PollByte_mB16:
 394          pollBytes = 16000000;
 395          break;
 396       case PollByte_mB17:
 397          pollBytes = 17000000;
 398          break;
 399       case PollByte_mB18:
 400          pollBytes = 18000000;
 401          break;
 402       case PollByte_mB20:
 403          pollBytes = 20000000;
 404          break;
 405       case PollByte_mB25:
 406          pollBytes = 25000000;
 407          break;
 408       case PollByte_mB30:
 409          pollBytes = 30000000;
 410          break;
 411       case PollByte_mB40:
 412          pollBytes = 40000000;
 413          break;
 414       case PollByte_infinity:
 415          pollBytes = -1;
 416          break;
 417       default:
 418          DU_LOG("\nERROR  -->  F1AP: Invalid value of poll bytes");
 419          pollBytes = 0;
 420    }
 421    return pollBytes;
 422 }
 423
 424 /*******************************************************************
 425  *
 426  * @brief Converts enum values into actual value of maxRetx
 427  *
 428  * @details
 429  *
 430  *    Function : getMaxRetx
 431  *
 432  *    Functionality: Converts enum values into actual value of maxRetx
 433  *
 434  * @params[in] Enum value
 435  * @return Actual value
 436  *
 437  * ****************************************************************/
 438 uint8_t getMaxRetx(uint8_t maxRetxCfg)
 439 {
 440    uint8_t maxRetx;
 441    switch(maxRetxCfg)
 442    {
 443       case UL_AM_RLC__maxRetxThreshold_t1:
 444          maxRetx = 1;
 445          break;
 446       case UL_AM_RLC__maxRetxThreshold_t2:
 447          maxRetx = 2;
 448          break;
 449       case UL_AM_RLC__maxRetxThreshold_t3:
 450          maxRetx = 3;
 451          break;
 452       case UL_AM_RLC__maxRetxThreshold_t4:
 453          maxRetx = 4;
 454          break;
 455       case UL_AM_RLC__maxRetxThreshold_t6:
 456          maxRetx = 6;
 457          break;
 458       case UL_AM_RLC__maxRetxThreshold_t8:
 459          maxRetx = 8;
 460          break;
 461       case UL_AM_RLC__maxRetxThreshold_t16:
 462          maxRetx = 16;
 463          break;
 464       case UL_AM_RLC__maxRetxThreshold_t32:
 465          maxRetx = 32;
 466          break;
 467       default:
 468          DU_LOG("\nERROR  -->  F1AP: Invalid configuration for Max retransmission threshold");
 469          maxRetx = 0;
 470    }
 471    return maxRetx;
 472 }
 473
 474 /*******************************************************************
 475  * @brief Converts enum values into actual value of reassembly timer
 476  *
 477  * @details
 478  *
 479  *    Function : getReAsmblTmr
 480  *
 481  *    Functionality: Converts enum values into actual value of reassembly
 482  *    timer
 483  *
 484  * @params[in] Enum value of reassembly timer
 485  * @return Actual value of reassembly timer
 486  *
 487  * **********************************************************************/
 488
 489 int8_t getReAsmblTmr(uint8_t reAsmblTmrCfg)
 490 {
 491    int8_t reAsmblTmr = 0;
 492
 493    if(reAsmblTmrCfg == T_Reassembly_ms0)
 494    {
 495       reAsmblTmr = 0;
 496    }
 497    else if(reAsmblTmrCfg >= T_Reassembly_ms5 || reAsmblTmrCfg <= T_Reassembly_ms100)
 498    {
 499      /* All values of re assembly timer are at interval of 5ms.
 500       * This is valid upto 100ms
 501       * Hence converting the enum value to actual value by multiplying it to 5
 502       */
 503       reAsmblTmr = reAsmblTmrCfg * 5;
 504    }
 505    else if(reAsmblTmrCfg >= T_Reassembly_ms110 || reAsmblTmrCfg <= T_Reassembly_ms200)
 506    {
 507      /* All values of re assembly timer are at interval of 10ms.
 508       * This is valid upto 200ms
 509       * since enum value starts from 20 for 100ms, subtracting 10 and
 510       * converting the enum value to actual value by multiplying it to 10
 511       */
 512       reAsmblTmr = ((reAsmblTmrCfg-10) * 10);
 513    }
 514    else
 515    {
 516       DU_LOG("\nERROR  -->  F1AP : Invalid value of Re Assembly timer %d", reAsmblTmrCfg);
 517       reAsmblTmr = -1;
 518    }
 519    return reAsmblTmr;
 520 }
 521
 522 /************************************************************************
 523  *
 524  * @brief Converts enum values into actual value of status prohibit timer
 525  *
 526  * @details
 527  *
 528  *    Function : getStatProhTmr
 529  *
 530  *    Functionality: Converts enum values into actual value of status prohibit
 531  *    timer
 532  *
 533  * @params[in] Enum value of status prohibit timer
 534  * @return Actual value of status prohibit timer
 535  *
 536  * **********************************************************************/
 537
 538 int16_t getStatProhTmr(uint8_t statProhTmrCfg)
 539 {
 540    int16_t statProhTmr =0;
 541
 542    if(statProhTmrCfg == T_StatusProhibit_ms0)
 543    {
 544       statProhTmr = 0;
 545    }
 546    else if(statProhTmrCfg >= T_StatusProhibit_ms5 || statProhTmrCfg <= T_StatusProhibit_ms250)
 547    {
 548       /* All values of re assembly timer are at interval of 5ms.
 549        * This is valid upto 250ms
 550        * Hence converting the enum value to actual value by multiplying it to 5
 551        */
 552       statProhTmr = statProhTmrCfg * 5;
 553    }
 554    else
 555    {
 556       switch(statProhTmrCfg)
 557       {
 558          case T_StatusProhibit_ms300:
 559             statProhTmr = 300;
 560             break;
 561          case T_StatusProhibit_ms350:
 562             statProhTmr = 350;
 563             break;
 564          case T_StatusProhibit_ms400:
 565             statProhTmr = 400;
 566             break;
 567          case T_StatusProhibit_ms450:
 568             statProhTmr = 450;
 569             break;
 570          case T_StatusProhibit_ms500:
 571             statProhTmr = 500;
 572             break;
 573          case T_StatusProhibit_ms800:
 574             statProhTmr = 800;
 575             break;
 576          case T_StatusProhibit_ms1000:
 577             statProhTmr = 1000;
 578             break;
 579          case T_StatusProhibit_ms1200:
 580             statProhTmr = 1200;
 581             break;
 582          case T_StatusProhibit_ms1600:
 583             statProhTmr = 1600;
 584             break;
 585          case T_StatusProhibit_ms2000:
 586             statProhTmr = 2000;
 587             break;
 588          case T_StatusProhibit_ms2400:
 589             statProhTmr = 2400;
 590             break;
 591          default:
 592             DU_LOG("\nInvalid value of Status Prohibit timer %d", statProhTmrCfg);
 593             statProhTmr = -1;
 594             break;
 595       }
 596    }
 597    return statProhTmr;
 598 }
 599
 600 /*******************************************************************
 601  *
 602  * @brief Builds Uplink Info for NR
 603  *
 604  * @details
 605  *
 606  *    Function : BuildULNRInfo
 607  *
 608  *    Functionality: Building NR Uplink Info
 609  *
 610  * @params[in] NRFreqInfo_t *ulnrfreq
 611  * @return ROK     - success
 612  *         RFAILED - failure
 613  *
 614  * ****************************************************************/
 615 uint8_t BuildULNRInfo(NRFreqInfo_t *ulnrfreq)
 616 {
 617    uint8_t idx=0;
 618    ulnrfreq->nRARFCN = duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.\
 619                        fdd.ulNrFreqInfo.nrArfcn;
 620    ulnrfreq->freqBandListNr.list.count = 1;
 621    ulnrfreq->freqBandListNr.list.size = sizeof(FreqBandNrItem_t *);
 622    DU_ALLOC(ulnrfreq->freqBandListNr.list.array,ulnrfreq->freqBandListNr.list.size);
 623    if(ulnrfreq->freqBandListNr.list.array == NULLP)
 624    {
 625       return RFAILED;
 626    }
 627    for(idx=0;idx<ulnrfreq->freqBandListNr.list.count;idx++)
 628    {
 629       DU_ALLOC(ulnrfreq->freqBandListNr.list.array[idx],sizeof(FreqBandNrItem_t));
 630       if(ulnrfreq->freqBandListNr.list.array[idx] == NULLP)
 631       {
 632          return RFAILED;
 633       }
 634    }
 635    ulnrfreq->freqBandListNr.list.array[0]->freqBandIndicatorNr = \
 636                                                                  duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.fdd.ulNrFreqInfo.\
 637                                                                  freqBand[0].nrFreqBand;
 638    ulnrfreq->freqBandListNr.list.array[0]->supportedSULBandList.list.count = SUL_BAND_COUNT;
 639    return ROK;
 640 }
 641 /*******************************************************************
 642  *
 643  * @brief Builds Downlink NR Info
 644  *
 645  * @details
 646  *
 647  *    Function : BuildDLNRInfo
 648  *
 649  *    Functionality: Building Downlink NR Info
 650  *
 651  * @params[in] NRFreqInfo_t *dlnrfreq
 652  * @return ROK     - success
 653  *         RFAILED - failure
 654  *
 655  * ****************************************************************/
 656 uint8_t BuildDLNRInfo(NRFreqInfo_t *dlnrfreq)
 657 {
 658    uint8_t idx=0;
 659    dlnrfreq->nRARFCN = duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.\
 660                        fdd.dlNrFreqInfo.nrArfcn;
 661    dlnrfreq->freqBandListNr.list.count = 1;
 662    dlnrfreq->freqBandListNr.list.size = sizeof(FreqBandNrItem_t *);
 663    DU_ALLOC(dlnrfreq->freqBandListNr.list.array,dlnrfreq->freqBandListNr.list.size);
 664    if(dlnrfreq->freqBandListNr.list.array == NULLP)
 665    {
 666       return RFAILED;
 667    }
 668    for(idx=0;idx< dlnrfreq->freqBandListNr.list.count;idx++)
 669    {
 670       DU_ALLOC(dlnrfreq->freqBandListNr.list.array[idx],sizeof(FreqBandNrItem_t));
 671       if(dlnrfreq->freqBandListNr.list.array[idx] == NULLP)
 672       {
 673          return RFAILED;
 674       }
 675    }
 676    dlnrfreq->freqBandListNr.list.array[0]->freqBandIndicatorNr = \
 677                                                                  duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.fdd.dlNrFreqInfo.\
 678                                                                  freqBand[0].nrFreqBand;
 679    dlnrfreq->freqBandListNr.list.array[0]->supportedSULBandList.list.count = SUL_BAND_COUNT;
 680
 681    return ROK;
 682 }
 683
 684 /*******************************************************************
 685  *
 686  * @brief Builds NRCell ID
 687  *
 688  * @details
 689  *
 690  *    Function : BuildNrCellId
 691  *
 692  *    Functionality: Building the NR Cell ID
 693  *
 694  * @params[in] BIT_STRING_t *nrcell
 695  * @return ROK     - success
 696  *         RFAILED - failure
 697  *
 698  * ****************************************************************/
 699
 700 S16 BuildNrCellId(BIT_STRING_t *nrcell)
 701 {
 702    memset(nrcell->buf, 0, nrcell->size);
 703    nrcell->buf[4]   = 16;
 704    nrcell->bits_unused = 4;
 705    return ROK;
 706 }
 707
 708 /*******************************************************************
 709  *
 710  * @brief Builds Nrcgi
 711  *
 712  * @details
 713  *
 714  *    Function : BuildNrcgi
 715  *
 716  *    Functionality: Building the PLMN ID and NR Cell id
 717  *
 718  * @params[in] NRCGI_t *nrcgi
 719  * @return ROK     - success
 720  *         RFAILED - failure
 721  *
 722  * ****************************************************************/
 723 uint8_t BuildNrcgi(NRCGI_t *nrcgi)
 724 {
 725    uint8_t ret;
 726    uint8_t byteSize = 5;
 727    /* Allocate Buffer Memory */
 728    nrcgi->pLMN_Identity.size = PLMN_SIZE * sizeof(uint8_t);
 729    DU_ALLOC(nrcgi->pLMN_Identity.buf, nrcgi->pLMN_Identity.size);
 730    if(nrcgi->pLMN_Identity.buf == NULLP)
 731    {
 732       return RFAILED;
 733    }
 734    ret = buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrCgi.plmn,\
 735          nrcgi->pLMN_Identity.buf); // Building PLMN function
 736    if(ret != ROK)
 737    {
 738       return RFAILED;
 739    }
 740    /*nrCellIdentity*/
 741    nrcgi->nRCellIdentity.size = byteSize * sizeof(uint8_t);
 742    DU_ALLOC(nrcgi->nRCellIdentity.buf, nrcgi->nRCellIdentity.size);
 743    if(nrcgi->nRCellIdentity.buf == NULLP)
 744    {
 745       return RFAILED;
 746    }
 747    BuildNrCellId(&nrcgi->nRCellIdentity);
 748
 749    return ROK;
 750 }
 751 /*******************************************************************
 752  *
 753  * @brief Builds FiveGStac
 754  *
 755  * @details
 756  *
 757  *    Function : BuildFiveGSTac
 758  *
 759  *    Functionality: Building the FiveGSTac
 760  *
 761  * @params[in] OCTET_STRING_t *fivegsTac
 762  * @return ROK     - success
 763  *         RFAILED - failure
 764  *
 765  * ****************************************************************/
 766 uint8_t BuildFiveGSTac(Served_Cell_Information_t *servcell)
 767 {
 768    DU_ALLOC(servcell->fiveGS_TAC,sizeof(FiveGS_TAC_t));
 769    if(servcell->fiveGS_TAC == NULLP)
 770    {
 771       return RFAILED;
 772    }
 773    servcell->fiveGS_TAC->size = 3 * sizeof(uint8_t);
 774    DU_ALLOC(servcell->fiveGS_TAC->buf,\
 775          sizeof(servcell->fiveGS_TAC->size));
 776    if(servcell->fiveGS_TAC->buf == NULLP)
 777    {
 778       return RFAILED;
 779    }
 780    servcell->fiveGS_TAC->buf[0] = 0;
 781    servcell->fiveGS_TAC->buf[1] = 0;
 782    servcell->fiveGS_TAC->buf[2] = duCfgParam.srvdCellLst[0].duCellInfo.tac;
 783    return ROK;
 784 }
 785 /*******************************************************************
 786  *
 787  * @brief Builds NR Mode
 788  *
 789  * @details
 790  *
 791  *    Function : BuildNrMode
 792  *
 793  *    Functionality: Building the NR Mode
 794  *
 795  * @params[in] NR_Mode_Info_t *fdd
 796  * @return ROK     - success
 797  *         RFAILED - failure
 798  *
 799  * ****************************************************************/
 800 uint8_t BuildNrMode(NR_Mode_Info_t *mode)
 801 {
 802    uint8_t BuildDLNRInforet=0;
 803    uint8_t BuildULNRInforet=0;
 804    /* FDD Mode */
 805    mode->present = NR_Mode_Info_PR_fDD;
 806    if(mode->present == NR_Mode_Info_PR_fDD)
 807    {
 808       DU_ALLOC(mode->choice.fDD,sizeof(FDD_Info_t));
 809       if(mode->choice.fDD == NULLP)
 810       {
 811          return RFAILED;
 812       }
 813       BuildULNRInforet = BuildULNRInfo(&mode->choice.fDD->uL_NRFreqInfo);
 814       if(BuildULNRInforet != ROK)
 815       {
 816          return RFAILED;
 817       }
 818       BuildDLNRInforet = BuildDLNRInfo(&mode->choice.fDD->dL_NRFreqInfo);
 819       if(BuildDLNRInforet != ROK)
 820       {
 821          return RFAILED;
 822       }
 823    }
 824    mode->choice.fDD->uL_Transmission_Bandwidth.nRSCS = \
 825                                                        duCfgParam.srvdCellLst[0].duCellInfo.\
 826                                                        f1Mode.mode.fdd.ulTxBw.nrScs;
 827    mode->choice.fDD->uL_Transmission_Bandwidth.nRNRB = \
 828                                                        duCfgParam.srvdCellLst[0].duCellInfo.\
 829                                                        f1Mode.mode.fdd.ulTxBw.nrb;
 830    mode->choice.fDD->dL_Transmission_Bandwidth.nRSCS = \
 831                                                        duCfgParam.srvdCellLst[0].duCellInfo.\
 832                                                        f1Mode.mode.fdd.dlTxBw.nrScs;
 833    mode->choice.fDD->dL_Transmission_Bandwidth.nRNRB = \
 834                                                        duCfgParam.srvdCellLst[0].duCellInfo.\
 835                                                        f1Mode.mode.fdd.dlTxBw.nrb;
 836    return ROK;
 837 }
 838 /*******************************************************************
 839  *
 840  * @brief Builds IE Extensions for Served PLMNs
 841  *
 842  * @details
 843  *
 844  *    Function : BuildExtensions
 845  *
 846  *    Functionality: Building the IE Extensions
 847  *
 848  * @params[in] struct ProtocolExtensionContainer_4624P3 *buildextend
 849  * @return ROK     - success
 850  *         RFAILED - failure
 851  *
 852  * ****************************************************************/
 853 uint8_t BuildExtensions(ProtocolExtensionContainer_4624P3_t **ieExtend)
 854 {
 855    uint8_t idx;
 856    uint8_t plmnidx;
 857    uint8_t extensionCnt=1;
 858    uint8_t sliceId=0;
 859    uint8_t sdId;
 860    DU_ALLOC(*ieExtend,sizeof(ProtocolExtensionContainer_4624P3_t));
 861    if((*ieExtend) == NULLP)
 862    {
 863       return RFAILED;
 864    }
 865    (*ieExtend)->list.count = extensionCnt;
 866    (*ieExtend)->list.size = \
 867                             extensionCnt * sizeof(ServedPLMNs_ItemExtIEs_t *);
 868    DU_ALLOC((*ieExtend)->list.array,(*ieExtend)->list.size);
 869    if((*ieExtend)->list.array == NULLP)
 870    {
 871       return RFAILED;
 872    }
 873    for(plmnidx=0;plmnidx<extensionCnt;plmnidx++)
 874    {
 875       DU_ALLOC((*ieExtend)->list.array[plmnidx],\
 876             sizeof(ServedPLMNs_ItemExtIEs_t));
 877       if((*ieExtend)->list.array[plmnidx] == NULLP)
 878       {
 879          return RFAILED;
 880       }
 881    }
 882    idx = 0;
 883    (*ieExtend)->list.array[idx]->id = ProtocolIE_ID_id_TAISliceSupportList;
 884    (*ieExtend)->list.array[idx]->criticality = Criticality_ignore;
 885    (*ieExtend)->list.array[idx]->extensionValue.present = \
 886                                                           ServedPLMNs_ItemExtIEs__extensionValue_PR_SliceSupportList;
 887    (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 888       list.count = 1;
 889    (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 890       list.size = sizeof(SliceSupportItem_t *);
 891    DU_ALLOC((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 892          list.array,sizeof(SliceSupportItem_t *));
 893    if((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 894          list.array == NULLP)
 895    {
 896       return RFAILED;
 897    }
 898    DU_ALLOC((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 899          list.array[sliceId],sizeof(SliceSupportItem_t));
 900    if((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 901          list.array[sliceId] == NULLP)
 902    {
 903       return RFAILED;
 904    }
 905    (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 906       list.array[sliceId]->sNSSAI.sST.size = sizeof(uint8_t);
 907    DU_ALLOC((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList\
 908          .list.array[sliceId]->sNSSAI.sST.buf,(*ieExtend)->list.array[idx]->\
 909          extensionValue.choice.SliceSupportList.\
 910          list.array[sliceId]->sNSSAI.sST.size);
 911    if((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList\
 912          .list.array[sliceId]->sNSSAI.sST.buf == NULLP)
 913    {
 914       return RFAILED;
 915    }
 916    (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 917       list.array[sliceId]->sNSSAI.sST.buf[0] = 3;
 918    DU_ALLOC((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 919          list.array[sliceId]->sNSSAI.sD,sizeof(OCTET_STRING_t));
 920    if((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 921          list.array[sliceId]->sNSSAI.sD == NULLP)
 922    {
 923       return RFAILED;
 924    }
 925    (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 926       list.array[sliceId]->sNSSAI.sD->size = 3*sizeof(uint8_t);
 927    DU_ALLOC((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 928          list.array[sliceId]->sNSSAI.sD->buf,(*ieExtend)->list.array[idx]->extensionValue.choice.\
 929          SliceSupportList.list.array[sliceId]->sNSSAI.sD->size);
 930    if((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 931          list.array[sliceId]->sNSSAI.sD->buf == NULLP)
 932    {
 933       return RFAILED;
 934    }
 935    sdId = 0;
 936    (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 937       list.array[sliceId]->sNSSAI.sD->buf[sdId] = 3;
 938    sdId++;
 939    (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 940       list.array[sliceId]->sNSSAI.sD->buf[sdId] = 6;
 941    sdId++;
 942    (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 943       list.array[sliceId]->sNSSAI.sD->buf[sdId] = 9;
 944    return ROK;
 945 }
 946 /*******************************************************************
 947  *
 948  * @brief Builds Served PLMN
 949  *
 950  * @details
 951  *
 952  *    Function : BuildServedPlmn
 953  *
 954  *    Functionality: Building the Served PLMN
 955  *
 956  * @params[in] GNB_DU_Served_Cells_Item_t *srvCellItem
 957  * @return ROK     - success
 958  *         RFAILED - failure
 959  *
 960  * ****************************************************************/
 961 uint8_t  BuildServedPlmn(ServedPLMNs_List_t *srvplmn)
 962 {
 963    uint8_t  plmnidx;
 964    uint8_t  servPlmnCnt=1;
 965    uint8_t buildPlmnIdret=0;
 966    uint8_t BuildExtensionsret=0;
 967    srvplmn->list.count = servPlmnCnt;
 968    srvplmn->list.size = \
 969                         servPlmnCnt*sizeof(ServedPLMNs_Item_t *);
 970    DU_ALLOC(srvplmn->list.array,srvplmn->list.size);
 971    if(srvplmn->list.array == NULLP)
 972    {
 973       return RFAILED;
 974    }
 975    for(plmnidx=0; plmnidx<servPlmnCnt; plmnidx++)
 976    {
 977       DU_ALLOC(srvplmn->list.array[plmnidx],\
 978             sizeof(ServedPLMNs_Item_t));
 979       if(srvplmn->list.array[plmnidx] == NULLP)
 980       {
 981          return RFAILED;
 982       }
 983    }
 984    srvplmn->list.array[0]->pLMN_Identity.size = PLMN_SIZE * sizeof(uint8_t);
 985    DU_ALLOC(srvplmn->list.array[0]->pLMN_Identity.buf, srvplmn->list.array[0]->pLMN_Identity.size);
 986    buildPlmnIdret = buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrCgi.plmn,\
 987          srvplmn->list.array[0]->pLMN_Identity.buf);
 988    if(buildPlmnIdret!= ROK)
 989    {
 990       return RFAILED;
 991    }
 992    BuildExtensionsret = BuildExtensions(&srvplmn->list.array[0]->iE_Extensions);
 993    if(BuildExtensionsret!= ROK)
 994    {
 995       return RFAILED;
 996    }
 997    return ROK;
 998 }
 999 /*******************************************************************
1000  *
1001  * @brief Builds Served Cell List
1002  *
1003  * @details
1004  *
1005  *    Function : BuildServedCellList
1006  *
1007  *    Functionality: Building Served Cell List
1008  *
1009  * @params[in] PLMNID plmn
1010  * @return ROK     - success
1011  *         RFAILED - failure
1012  *
1013  * ****************************************************************/
1014
1015 uint8_t BuildServedCellList(GNB_DU_Served_Cells_List_t *duServedCell)
1016 {
1017    uint8_t  BuildNrcgiret=0;
1018    uint8_t  BuildFiveGSTacret=0;
1019    uint8_t  BuildServedPlmnret=0;
1020    uint8_t  BuildNrModeret=0;
1021    uint8_t  idx;
1022    uint8_t  plmnidx;
1023    uint8_t  plmnCnt=1;
1024    GNB_DU_Served_Cells_Item_t *srvCellItem;
1025    duServedCell->list.size = plmnCnt * sizeof(GNB_DU_Served_Cells_ItemIEs_t *);
1026    duServedCell->list.count = plmnCnt;
1027
1028    DU_ALLOC(duServedCell->list.array, duServedCell->list.size);
1029    if(duServedCell->list.array == NULLP)
1030    {
1031       return RFAILED;
1032    }
1033    for(plmnidx=0; plmnidx<plmnCnt; plmnidx++)
1034    {
1035       DU_ALLOC(duServedCell->list.array[plmnidx],\
1036             sizeof(GNB_DU_Served_Cells_ItemIEs_t));
1037       if(duServedCell->list.array[plmnidx] == NULLP)
1038       {
1039          return RFAILED;
1040       }
1041    }
1042    idx = 0;
1043    duServedCell->list.array[idx]->id = ProtocolIE_ID_id_GNB_DU_Served_Cells_Item;
1044    duServedCell->list.array[idx]->criticality = Criticality_reject;
1045    duServedCell->list.array[idx]->value.present = \
1046                                                   GNB_DU_Served_Cells_ItemIEs__value_PR_GNB_DU_Served_Cells_Item;
1047    srvCellItem = \
1048                  &duServedCell->list.array[idx]->value.choice.GNB_DU_Served_Cells_Item;
1049    /*nRCGI*/
1050    BuildNrcgiret = BuildNrcgi(&srvCellItem->served_Cell_Information.nRCGI);
1051    if(BuildNrcgiret != ROK)
1052    {
1053       return RFAILED;
1054    }
1055    /*nRPCI*/
1056    srvCellItem->served_Cell_Information.nRPCI = \
1057                                                 duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrPci;
1058
1059    /*fiveGS_TAC*/
1060    BuildFiveGSTacret = BuildFiveGSTac(&srvCellItem->served_Cell_Information);
1061    if(BuildFiveGSTacret != ROK)
1062    {
1063       return RFAILED;
1064    }
1065    /*Served PLMNs*/
1066    BuildServedPlmnret = BuildServedPlmn(&srvCellItem->served_Cell_Information.servedPLMNs);
1067    if(BuildServedPlmnret !=ROK)
1068    {
1069       return RFAILED;
1070    }
1071    /*nR Mode Info with FDD*/
1072    BuildNrModeret = BuildNrMode(&srvCellItem->served_Cell_Information.nR_Mode_Info);
1073    if(BuildNrModeret != ROK)
1074    {
1075       return RFAILED;
1076    }
1077    /*Measurement timing Config*/
1078    srvCellItem->served_Cell_Information.measurementTimingConfiguration.\
1079       size = sizeof(uint8_t);
1080    DU_ALLOC(srvCellItem->served_Cell_Information.\
1081          measurementTimingConfiguration.buf,srvCellItem->served_Cell_Information.measurementTimingConfiguration.size);
1082    if(srvCellItem->served_Cell_Information.\
1083          measurementTimingConfiguration.buf == NULLP)
1084    {
1085       return RFAILED;
1086    }
1087    srvCellItem->served_Cell_Information.measurementTimingConfiguration.buf[0] = \
1088                                                                                 duCfgParam.srvdCellLst[0].duCellInfo.measTimeCfg;
1089
1090    /* GNB DU System Information */
1091    DU_ALLOC(srvCellItem->gNB_DU_System_Information,
1092          sizeof(GNB_DU_System_Information_t));
1093    if(!srvCellItem->gNB_DU_System_Information)
1094    {
1095       return RFAILED;
1096    }
1097    /* MIB */
1098    srvCellItem->gNB_DU_System_Information->mIB_message.size = duCfgParam.srvdCellLst[0].duSysInfo.mibLen;
1099    DU_ALLOC(srvCellItem->gNB_DU_System_Information->mIB_message.buf,
1100          srvCellItem->gNB_DU_System_Information->mIB_message.size);
1101    if(!srvCellItem->gNB_DU_System_Information->mIB_message.buf)
1102    {
1103       return RFAILED;
1104    }
1105    memcpy(srvCellItem->gNB_DU_System_Information->mIB_message.buf, duCfgParam.srvdCellLst[0].duSysInfo.mibMsg, \
1106                    srvCellItem->gNB_DU_System_Information->mIB_message.size);
1107
1108    /* SIB1 */
1109    srvCellItem->gNB_DU_System_Information->sIB1_message.size =\
1110                                                               duCfgParam.srvdCellLst[0].duSysInfo.sib1Len;
1111
1112    DU_ALLOC(srvCellItem->gNB_DU_System_Information->sIB1_message.buf,
1113          srvCellItem->gNB_DU_System_Information->sIB1_message.size);
1114    if(!srvCellItem->gNB_DU_System_Information->sIB1_message.buf)
1115    {
1116       return RFAILED;
1117    }
1118    for(int x=0; x<srvCellItem->gNB_DU_System_Information->sIB1_message.size; x++)
1119    {
1120       srvCellItem->gNB_DU_System_Information->sIB1_message.buf[x]=\
1121                                                                   duCfgParam.srvdCellLst[0].duSysInfo.sib1Msg[x];
1122    }
1123    return ROK;
1124 }
1125 /*******************************************************************
1126  *
1127  * @brief Builds RRC Version
1128  *
1129  * @details
1130  *
1131  *    Function : BuildRrcVer
1132  *
1133  *    Functionality: Building RRC Version
1134  *
1135  * @params[in] int idx,int elementCnt,RRC_Version_t *rrcver
1136  * @return ROK     - success
1137  *         RFAILED - failure
1138  *
1139  * ****************************************************************/
1140 uint8_t BuildRrcVer(RRC_Version_t *rrcVer)
1141 {
1142    uint8_t rrcExt;
1143    uint8_t rrcLatest;
1144    rrcVer->latest_RRC_Version.size = sizeof(uint8_t);
1145    DU_ALLOC(rrcVer->latest_RRC_Version.buf,sizeof(uint8_t));
1146    if(rrcVer->latest_RRC_Version.buf == NULLP)
1147    {
1148       return RFAILED;
1149    }
1150    rrcVer->latest_RRC_Version.buf[0] = 0;
1151    rrcVer->latest_RRC_Version.bits_unused = 5;
1152    DU_ALLOC(rrcVer->iE_Extensions,sizeof(ProtocolExtensionContainer_4624P81_t));
1153    if(rrcVer->iE_Extensions == NULLP)
1154    {
1155       return RFAILED;
1156    }
1157    rrcVer->iE_Extensions->list.count = 1;
1158    rrcVer->iE_Extensions->list.size = sizeof(RRC_Version_ExtIEs_t *);
1159    DU_ALLOC(rrcVer->iE_Extensions->list.array,rrcVer->iE_Extensions->list.size);
1160    if(rrcVer->iE_Extensions->list.array == NULLP)
1161    {
1162       return RFAILED;
1163    }
1164    rrcExt = 0;
1165    DU_ALLOC(rrcVer->iE_Extensions->list.array[0],\
1166          sizeof(RRC_Version_ExtIEs_t));
1167    if(rrcVer->iE_Extensions->list.array[0] == NULLP)
1168    {
1169       return RFAILED;
1170    }
1171    rrcVer->iE_Extensions->list.array[rrcExt]->id = \
1172                                                    ProtocolIE_ID_id_latest_RRC_Version_Enhanced;
1173    rrcVer->iE_Extensions->list.array[rrcExt]->criticality = Criticality_reject;
1174    rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.present =\
1175                                                                       RRC_Version_ExtIEs__extensionValue_PR_Latest_RRC_Version_Enhanced;
1176    rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.choice\
1177       .Latest_RRC_Version_Enhanced.size = 3*sizeof(uint8_t);
1178    DU_ALLOC(rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.choice\
1179          .Latest_RRC_Version_Enhanced.buf,rrcVer->iE_Extensions->list.\
1180          array[rrcExt]->extensionValue.choice.Latest_RRC_Version_Enhanced.size);
1181    if(rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.choice\
1182          .Latest_RRC_Version_Enhanced.buf == NULLP)
1183    {
1184       return RFAILED;
1185    }
1186    rrcLatest = 0;
1187    rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.choice.\
1188       Latest_RRC_Version_Enhanced.buf[rrcLatest] = 15;
1189    rrcLatest++;
1190    rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.choice.\
1191       Latest_RRC_Version_Enhanced.buf[rrcLatest] = 5;
1192    rrcLatest++;
1193    rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.choice.\
1194       Latest_RRC_Version_Enhanced.buf[rrcLatest] = 0;
1195    return ROK;
1196 }
1197 /*******************************************************************
1198  *
1199  * @brief Sends F1 msg over SCTP
1200  *
1201  * @details
1202  *
1203  *    Function : sendF1APMsg
1204  *
1205  *    Functionality: Sends F1 msg over SCTP
1206  *
1207  * @params[in] Region region
1208  *             Pool pool
1209  * @return ROK     - success
1210  *         RFAILED - failure
1211  *
1212  * ****************************************************************/
1213 uint8_t sendF1APMsg()
1214 {
1215    Buffer *mBuf = NULLP;
1216
1217    if(ODU_GET_MSG_BUF(DU_APP_MEM_REGION, DU_POOL, &mBuf) == ROK)
1218    {
1219       if(ODU_ADD_POST_MSG_MULT((Data *)encBuf, encBufSize, mBuf) == ROK)
1220       {
1221             ODU_PRINT_MSG(mBuf, 0,0);
1222
1223             if(sctpSend(mBuf, F1_INTERFACE) != ROK)
1224             {
1225                DU_LOG("\nERROR  -->  F1AP : SCTP Send failed");
1226                ODU_PUT_MSG_BUF(mBuf);
1227                return RFAILED;
1228             }
1229       }
1230       else
1231       {
1232          DU_LOG("\nERROR  -->  F1AP : ODU_ADD_POST_MSG_MULT failed");
1233          ODU_PUT_MSG_BUF(mBuf);
1234          return RFAILED;
1235       }
1236       ODU_PUT_MSG_BUF(mBuf);
1237    }
1238    else
1239    {
1240       DU_LOG("\nERROR  -->  F1AP : Failed to allocate memory");
1241       return RFAILED;
1242    }
1243    return ROK;
1244 } /* sendF1APMsg */
1245
1246 /*******************************************************************
1247  *
1248  * @brief  deallocating the memory of function BuildAndSendF1SetupReq()
1249  *
1250  * @details
1251  *
1252  *    Function :  FreeRrcVer
1253  *
1254  *    Functionality: deallocating the memory of function BuildRrcVer
1255  *
1256  * @params[in] RRC_Version_t *rrcVer
1257  *
1258  * @return void
1259  *
1260  *****************************************************************/
1261 void FreeRrcVer(RRC_Version_t *rrcVer)
1262 {
1263    if(rrcVer->latest_RRC_Version.buf != NULLP)
1264    {
1265       if(rrcVer->iE_Extensions != NULLP)
1266       {
1267          if(rrcVer->iE_Extensions->list.array != NULLP)
1268          {
1269             if(rrcVer->iE_Extensions->list.array[0] != NULLP)
1270             {
1271                if(rrcVer->iE_Extensions->list.array[0]->extensionValue.choice.Latest_RRC_Version_Enhanced.buf
1272                      != NULLP)
1273                {
1274                   DU_FREE(rrcVer->iE_Extensions->list.array[0]->extensionValue.choice\
1275                         .Latest_RRC_Version_Enhanced.buf,rrcVer->iE_Extensions->list.\
1276                         array[0]->extensionValue.choice.Latest_RRC_Version_Enhanced.size);
1277                }
1278                DU_FREE(rrcVer->iE_Extensions->list.array[0],sizeof(RRC_Version_ExtIEs_t));
1279             }
1280             DU_FREE(rrcVer->iE_Extensions->list.array,sizeof(RRC_Version_ExtIEs_t*));
1281          }
1282          DU_FREE(rrcVer->iE_Extensions,sizeof(ProtocolExtensionContainer_4624P81_t));
1283       }
1284       DU_FREE(rrcVer->latest_RRC_Version.buf,rrcVer->latest_RRC_Version.size);
1285    }
1286 }
1287 /*******************************************************************
1288  *
1289  * @brief  deallocating the memory of function BuildAndSendF1SetupReq()
1290  *
1291  * @details
1292  *
1293  *    Function :  FreeServedCellList
1294  *
1295  *    Functionality:  deallocating the memory of function BuildServedCellList
1296
1297  *
1298  * @params[in] GNB_DU_Served_Cells_List_t *duServedCell
1299  *
1300  * @return void
1301  *
1302  * ****************************************************************/
1303 void FreeServedCellList( GNB_DU_Served_Cells_List_t *duServedCell)
1304 {
1305    uint8_t   plmnCnt=1;
1306    uint8_t  servId=0;
1307    uint8_t sliceId=0;
1308    uint8_t  ieId=0;
1309    uint8_t   extensionCnt=1;
1310    uint8_t plmnidx=0;
1311    GNB_DU_Served_Cells_Item_t *srvCellItem= &duServedCell->list.array[0]->value.choice.GNB_DU_Served_Cells_Item;
1312    if(duServedCell->list.array!=NULLP)
1313    {
1314       if(duServedCell->list.array[0]!=NULLP)
1315       {
1316          if(srvCellItem->served_Cell_Information.nRCGI.pLMN_Identity.buf!=NULLP)
1317          {
1318             if(srvCellItem->served_Cell_Information.nRCGI.nRCellIdentity.buf !=NULLP)
1319             {
1320                if(srvCellItem->served_Cell_Information.fiveGS_TAC!=NULLP)
1321                {
1322                   if(srvCellItem->served_Cell_Information.fiveGS_TAC->buf!=NULLP)
1323                   {
1324                      if(srvCellItem->served_Cell_Information.servedPLMNs.list.array!=NULLP)
1325                      {
1326                         if(srvCellItem->served_Cell_Information.servedPLMNs.list.array[0]!=NULLP)
1327                         {
1328                            if(srvCellItem->served_Cell_Information.servedPLMNs.list.array[servId]->pLMN_Identity.buf!=NULLP)
1329                            {
1330                               if(srvCellItem->served_Cell_Information.servedPLMNs.list.array[servId]->iE_Extensions!=NULLP)
1331                               {
1332                                  if(srvCellItem->served_Cell_Information.servedPLMNs.list.array[servId]->iE_Extensions->list.array!=NULLP)
1333                                  {
1334                                     if(srvCellItem->served_Cell_Information.servedPLMNs.list.array[servId]->iE_Extensions->list.array[0]!=NULLP)
1335                                     {
1336                                        if(srvCellItem->served_Cell_Information.servedPLMNs.list.array[servId]->iE_Extensions->list.array[0]->\
1337                                              extensionValue.choice.SliceSupportList.list.array!=NULLP)
1338                                        {
1339                                           if(srvCellItem->served_Cell_Information.servedPLMNs.list.array[servId]->iE_Extensions->list.array[0]->\
1340                                                 extensionValue.choice.SliceSupportList.list.array[sliceId]!= NULLP)
1341                                           {
1342                                              if(srvCellItem->served_Cell_Information.servedPLMNs.list.array[servId]->iE_Extensions->list.array[0]->\
1343                                                    extensionValue.choice.SliceSupportList.list.array[sliceId]->sNSSAI.sST.buf!=NULLP)
1344                                              {
1345                                                 if(srvCellItem->served_Cell_Information.servedPLMNs.list.array[servId]->iE_Extensions->list.array[0]->\
1346                                                       extensionValue.choice.SliceSupportList.list.array[sliceId]->sNSSAI.sD!=NULLP)
1347                                                 {
1348                                                    if(srvCellItem->served_Cell_Information.servedPLMNs.list.array[servId]->iE_Extensions->\
1349                                                          list.array[0]->extensionValue.choice.SliceSupportList.list.array[sliceId]->sNSSAI.sD->buf!=NULLP)
1350                                                    {
1351                                                       if(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD!=NULLP)
1352                                                       {
1353                                                          if(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD->uL_NRFreqInfo.\
1354                                                                freqBandListNr.list.array!=NULLP)
1355                                                          {
1356                                                             if(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD->uL_NRFreqInfo.\
1357                                                                   freqBandListNr.list.array[0]!=NULLP)
1358                                                             {
1359                                                                if(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD->dL_NRFreqInfo.\
1360                                                                      freqBandListNr.list.array)
1361                                                                {
1362                                                                   if(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD->dL_NRFreqInfo.\
1363                                                                         freqBandListNr.list.array[0]!=NULLP)
1364                                                                   {
1365                                                                      if(srvCellItem->served_Cell_Information.measurementTimingConfiguration.buf!=NULLP)
1366                                                                      {
1367                                                                         if(!srvCellItem->gNB_DU_System_Information)
1368                                                                         {
1369                                                                            if(srvCellItem->gNB_DU_System_Information->mIB_message.buf!=NULLP)
1370                                                                            {
1371                                                                               if(srvCellItem->gNB_DU_System_Information->sIB1_message.buf!=NULLP)
1372                                                                               {
1373                                                                                  DU_FREE(srvCellItem->gNB_DU_System_Information->sIB1_message.buf,\
1374                                                                                        srvCellItem->gNB_DU_System_Information->sIB1_message.size);
1375                                                                                  DU_FREE(duCfgParam.srvdCellLst[0].duSysInfo.sib1Msg,\
1376                                                                                        srvCellItem->gNB_DU_System_Information->sIB1_message.size);
1377                                                                               }
1378                                                                               DU_FREE(srvCellItem->gNB_DU_System_Information->mIB_message.buf,\
1379                                                                                     srvCellItem->gNB_DU_System_Information->mIB_message.size);
1380                                                                               DU_FREE(duCfgParam.srvdCellLst[0].duSysInfo.mibMsg,\
1381                                                                                     strlen((char*)duCfgParam.srvdCellLst[0].duSysInfo.mibMsg));
1382                                                                            }
1383                                                                            DU_FREE(srvCellItem->gNB_DU_System_Information,sizeof(GNB_DU_System_Information_t));
1384                                                                         }
1385                                                                         DU_FREE(srvCellItem->served_Cell_Information.measurementTimingConfiguration.buf,\
1386                                                                               srvCellItem->served_Cell_Information.measurementTimingConfiguration.size);
1387                                                                      }
1388                                                                      DU_FREE(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD->dL_NRFreqInfo.\
1389                                                                            freqBandListNr.list.array[0],sizeof(FreqBandNrItem_t));
1390                                                                   }
1391                                                                   DU_FREE(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD->dL_NRFreqInfo.\
1392                                                                         freqBandListNr.list.array,sizeof(FreqBandNrItem_t *));
1393                                                                }
1394                                                                DU_FREE(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD->uL_NRFreqInfo.freqBandListNr.\
1395                                                                      list.array[0],sizeof(FreqBandNrItem_t));
1396                                                             }
1397                                                             DU_FREE(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD->uL_NRFreqInfo.freqBandListNr.\
1398                                                                   list.array,sizeof(FreqBandNrItem_t*));
1399                                                          }
1400                                                          DU_FREE(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD,sizeof(FDD_Info_t));
1401                                                       }
1402                                                       DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.array[servId]->\
1403                                                             iE_Extensions->list.array[ieId]->extensionValue.choice.SliceSupportList.list.array[sliceId]->\
1404                                                             sNSSAI.sD->buf,srvCellItem->served_Cell_Information.servedPLMNs.list.array[servId]->iE_Extensions->
1405                                                             list.array[ieId]->extensionValue.choice.SliceSupportList.list.array[sliceId]->sNSSAI.sD->size);
1406                                                    }
1407                                                    DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.array[servId]->\
1408                                                          iE_Extensions->list.array[ieId]->extensionValue.choice.SliceSupportList.\
1409                                                          list.array[sliceId]->sNSSAI.sD,sizeof(OCTET_STRING_t));
1410                                                 }
1411                                                 DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.array[servId]->\
1412                                                       iE_Extensions->list.array[ieId]->extensionValue.choice.SliceSupportList.list.array[sliceId]->\
1413                                                       sNSSAI.sST.buf,sizeof(uint8_t));
1414                                              }
1415                                              DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.array[servId]->iE_Extensions->list.array[0]->\
1416                                                    extensionValue.choice.SliceSupportList.list.array[sliceId],sizeof(SliceSupportItem_t));
1417                                           }
1418                                           DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.array[servId]->iE_Extensions->list.array[0]->\
1419                                                 extensionValue.choice.SliceSupportList.list.array,sizeof(SliceSupportItem_t*));
1420                                        }
1421                                        DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.\
1422                                              array[servId]->iE_Extensions->list.array[plmnidx],sizeof(ServedPLMNs_ItemExtIEs_t));
1423                                     }
1424                                     DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.\
1425                                           array[servId]->iE_Extensions->list.array,\
1426                                           extensionCnt*sizeof(ServedPLMNs_ItemExtIEs_t*));
1427                                  }
1428                                  DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.\
1429                                        array[servId]->iE_Extensions,sizeof(ProtocolExtensionContainer_4624P3_t));
1430                               }
1431                               DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.\
1432                                     array[servId]->pLMN_Identity.buf,srvCellItem->served_Cell_Information.\
1433                                     servedPLMNs.list.array[servId]->pLMN_Identity.size
1434                                     * sizeof(uint8_t));
1435                            }
1436                            DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.array[plmnidx],\
1437                                  sizeof(ServedPLMNs_Item_t *));
1438                         }
1439                         DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.array,\
1440                               sizeof(ServedPLMNs_Item_t *));
1441                      }
1442                      DU_FREE(srvCellItem->served_Cell_Information.fiveGS_TAC->buf,\
1443                            sizeof(srvCellItem->served_Cell_Information.fiveGS_TAC->size));
1444                   }
1445                   DU_FREE(srvCellItem->served_Cell_Information.fiveGS_TAC,sizeof(FiveGS_TAC_t));
1446                }
1447                DU_FREE(srvCellItem->served_Cell_Information.nRCGI.nRCellIdentity.buf,\
1448                      srvCellItem->served_Cell_Information.nRCGI.nRCellIdentity.size *
1449                      sizeof(uint8_t));
1450             }
1451             DU_FREE(srvCellItem->served_Cell_Information.nRCGI.pLMN_Identity.buf,\
1452                   srvCellItem->served_Cell_Information.nRCGI.pLMN_Identity.size *
1453                   sizeof(uint8_t));
1454          }
1455          DU_FREE(duServedCell->list.array[plmnidx],sizeof(GNB_DU_Served_Cells_ItemIEs_t));
1456       }
1457       DU_FREE(duServedCell->list.array,plmnCnt*sizeof(GNB_DU_Served_Cells_ItemIEs_t*));
1458    }
1459 }
1460 /*******************************************************************
1461  *
1462  * @brief  deallocating the memory of function BuildAndSendF1SetupReq()
1463  *
1464  * @details
1465  *
1466  *    Function :  FreeF1SetupReq
1467  *
1468  *    Functionality:  deallocating the memory of function BuildAndSendF1SetupReq
1469  *
1470  * @params[in] F1AP_PDU_t *f1apMsg
1471  *
1472  * @return void
1473  *
1474  * ****************************************************************/
1475 void FreeF1SetupReq(F1AP_PDU_t *f1apMsg)
1476 {
1477    uint8_t ieIdx, ieIdx2;
1478    F1SetupRequest_t *f1SetupReq=NULLP;
1479
1480    if(f1apMsg != NULLP)
1481    {
1482       if(f1apMsg->choice.initiatingMessage != NULLP)
1483       {
1484          f1SetupReq = &f1apMsg->choice.initiatingMessage->value.choice.F1SetupRequest;
1485          if(f1SetupReq->protocolIEs.list.array != NULLP)
1486          {
1487             for(ieIdx = 0; ieIdx < f1SetupReq->protocolIEs.list.count; ieIdx++)
1488             {
1489                if(f1SetupReq->protocolIEs.list.array[ieIdx] != NULLP)
1490                {
1491                   switch(f1SetupReq->protocolIEs.list.array[ieIdx]->id)
1492                   {
1493                      case ProtocolIE_ID_id_TransactionID:
1494                         break;
1495                      case ProtocolIE_ID_id_gNB_DU_ID:
1496                         DU_FREE(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf,\
1497                               f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.size);
1498                         break;
1499                      case ProtocolIE_ID_id_gNB_DU_Name:
1500                         DU_FREE(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_Name.buf,\
1501                               strlen((char *)duCfgParam.duName));
1502                         break;
1503                      case ProtocolIE_ID_id_gNB_DU_Served_Cells_List:
1504                         FreeServedCellList(&f1SetupReq->protocolIEs.list.\
1505                               array[ieIdx]->value.choice.GNB_DU_Served_Cells_List);
1506                         break;
1507                      case ProtocolIE_ID_id_GNB_DU_RRC_Version:
1508                         FreeRrcVer(&f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.RRC_Version);
1509                         break;
1510                      default:
1511                         DU_LOG("\nERROR  -->  Invalid Event Type %ld", f1SetupReq->protocolIEs.list.array[ieIdx]->id);
1512                         break;
1513                   }
1514                }
1515                break;
1516             }
1517             for(ieIdx2=0; ieIdx2< ieIdx; ieIdx2++)
1518             {
1519                DU_FREE(f1SetupReq->protocolIEs.list.array[ieIdx2],sizeof(F1SetupRequestIEs_t));
1520             }
1521             DU_FREE(f1SetupReq->protocolIEs.list.array,\
1522                   f1SetupReq->protocolIEs.list.size);
1523          }
1524          DU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
1525       }
1526       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
1527    }
1528 }
1529 /*******************************************************************
1530  *
1531  * @brief Builds and Send the F1SetupRequest
1532  *
1533  * @details
1534  *
1535  *    Function : BuildAndSendF1SetupReq
1536  *
1537  * Functionality:Fills the F1SetupRequest
1538  *
1539  * @return ROK     - success
1540  *         RFAILED - failure
1541  *
1542  ******************************************************************/
1543 uint8_t BuildAndSendF1SetupReq()
1544 {
1545    uint8_t   ret, ieIdx, elementCnt;
1546    F1AP_PDU_t                 *f1apMsg = NULLP;
1547    F1SetupRequest_t           *f1SetupReq=NULLP;
1548    GNB_DU_Served_Cells_List_t *duServedCell=NULLP;
1549    RRC_Version_t              *rrcVer=NULLP;
1550    asn_enc_rval_t             encRetVal;        /* Encoder return value */
1551    ret= RFAILED;
1552
1553    DU_LOG("\nINFO   -->  F1AP : Building F1 Setup Request\n");
1554    do
1555    {
1556       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
1557       if(f1apMsg == NULLP)
1558       {
1559          break;
1560       }
1561       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
1562       DU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
1563       if(f1apMsg->choice.initiatingMessage == NULLP)
1564       {
1565          break;
1566       }
1567       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_F1Setup;
1568       f1apMsg->choice.initiatingMessage->criticality = Criticality_reject;
1569       f1apMsg->choice.initiatingMessage->value.present = \
1570                                                          InitiatingMessage__value_PR_F1SetupRequest;
1571
1572       f1SetupReq = &f1apMsg->choice.initiatingMessage->value.choice.F1SetupRequest;
1573
1574       elementCnt = (duCfgParam.duName != NULL) ? 5 : 4;
1575
1576       f1SetupReq->protocolIEs.list.count = elementCnt;
1577       f1SetupReq->protocolIEs.list.size = elementCnt * sizeof(F1SetupRequestIEs_t );
1578
1579       /* Initialize the F1Setup members */
1580       DU_ALLOC(f1SetupReq->protocolIEs.list.array,f1SetupReq->protocolIEs.list.size);
1581       if(f1SetupReq->protocolIEs.list.array == NULLP)
1582       {
1583          break;
1584       }
1585       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
1586       {
1587          DU_ALLOC(f1SetupReq->protocolIEs.list.array[ieIdx],\
1588                sizeof(F1SetupRequestIEs_t));
1589          if(f1SetupReq->protocolIEs.list.array[ieIdx] == NULLP)
1590          {
1591             break;
1592          }
1593       }
1594
1595       ieIdx = 0;
1596       /*TransactionID*/
1597       f1SetupReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_TransactionID;
1598       f1SetupReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
1599       f1SetupReq->protocolIEs.list.array[ieIdx]->value.present =\
1600                                                                F1SetupRequestIEs__value_PR_TransactionID;
1601       f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.TransactionID = \
1602                                                                              TRANS_ID;
1603
1604       /*DU ID*/
1605       ieIdx++;
1606       f1SetupReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_ID;
1607       f1SetupReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
1608       f1SetupReq->protocolIEs.list.array[ieIdx]->value.present = \
1609                                                                 F1SetupRequestIEs__value_PR_GNB_DU_ID;
1610       f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.size =\
1611                                                                              sizeof(uint8_t);
1612
1613       DU_ALLOC(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf,\
1614             f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.size);
1615       if(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf == \
1616             NULLP)
1617       {
1618          break;
1619       }
1620
1621       f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf[0] =\
1622          duCfgParam.duId;
1623
1624       /*DU Name*/
1625       if(duCfgParam.duName != NULL)
1626       {
1627          ieIdx++;
1628          f1SetupReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_Name;
1629          f1SetupReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_ignore;
1630          f1SetupReq->protocolIEs.list.array[ieIdx]->value.present = F1SetupRequestIEs__value_PR_GNB_DU_Name;
1631          f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_Name.size =\
1632             strlen((char *)duCfgParam.duName);
1633          DU_ALLOC(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.\
1634                GNB_DU_Name.buf, strlen((char *)duCfgParam.duName));
1635          if(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_Name.\
1636                buf == NULLP)
1637          {
1638             break;
1639          }
1640          strcpy((char*)f1SetupReq->protocolIEs.list.array[ieIdx]->value.\
1641                choice.GNB_DU_Name.buf,
1642                (char*)&duCfgParam.duName);
1643
1644       }
1645
1646       /*Served Cell list */
1647       ieIdx++;
1648       f1SetupReq->protocolIEs.list.array[ieIdx]->id = \
1649                                                      ProtocolIE_ID_id_gNB_DU_Served_Cells_List;
1650       f1SetupReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
1651       f1SetupReq->protocolIEs.list.array[ieIdx]->value.present = \
1652                                                                 F1SetupRequestIEs__value_PR_GNB_DU_Served_Cells_List;
1653       duServedCell = &f1SetupReq->protocolIEs.list.\
1654                      array[ieIdx]->value.choice.GNB_DU_Served_Cells_List;
1655       if(BuildServedCellList(duServedCell))
1656       {
1657          break;
1658       }
1659       /*RRC Version*/
1660       ieIdx++;
1661       f1SetupReq->protocolIEs.list.array[ieIdx]->id = \
1662                                                      ProtocolIE_ID_id_GNB_DU_RRC_Version ;
1663       f1SetupReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
1664       f1SetupReq->protocolIEs.list.array[ieIdx]->value.present = \
1665                                                                 F1SetupRequestIEs__value_PR_RRC_Version;
1666       rrcVer = &f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.RRC_Version;
1667       if(BuildRrcVer(rrcVer))
1668       {
1669          break;
1670       }
1671       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
1672
1673       /* Encode the F1SetupRequest type as APER */
1674       memset(encBuf, 0, ENC_BUF_MAX_LEN);
1675       encBufSize = 0;
1676       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
1677             encBuf);
1678
1679       /* Encode results */
1680       if(encRetVal.encoded == ENCODE_FAIL)
1681       {
1682          DU_LOG("\nERROR  -->  F1AP : Could not encode F1SetupRequest structure (at %s)\n",\
1683                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
1684          break;
1685       }
1686       else
1687       {
1688          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for F1SetupRequest\n");
1689          for(ieIdx=0; ieIdx< encBufSize; ieIdx++)
1690          {
1691             printf("%x",encBuf[ieIdx]);
1692          }
1693       }
1694
1695       /* Sending msg */
1696       if(sendF1APMsg() != ROK)
1697       {
1698          DU_LOG("\nERROR  -->  F1AP : Sending F1 Setup request failed");
1699          break;
1700       }
1701
1702       ret=ROK;
1703       break;
1704    }while(true);
1705
1706    FreeF1SetupReq(f1apMsg);
1707
1708    return ret;
1709 }/* End of BuildAndSendF1SetupReq */
1710
1711 /*******************************************************************
1712  *
1713  * @brief Deallocating memory of BuildAndSendDUConfigUpdate
1714  *
1715  * @details
1716  *
1717  *    Function : FreeDUConfigUpdate
1718  *
1719  *    Functionality: Deallocating memory of variables allocated in
1720  *                    BuildAndSendDUConfigUpdate function
1721  *
1722  * @params[in]  F1AP_PDU_t *f1apDuCfg
1723  *
1724  * @return ROK     - void
1725  *
1726  * ****************************************************************/
1727 void FreeDUConfigUpdate(F1AP_PDU_t *f1apDuCfg)
1728 {
1729    uint8_t  i;
1730    uint8_t  idx;
1731    GNBDUConfigurationUpdate_t *duCfgUpdate = NULLP;
1732    Served_Cells_To_Modify_List_t  *cellsToModify;
1733    Served_Cells_To_Modify_Item_t *modifyItem;
1734    idx=0;
1735    i=1;
1736    if(f1apDuCfg != NULLP)
1737    {
1738       if(f1apDuCfg->choice.initiatingMessage != NULLP)
1739       {
1740          duCfgUpdate = &f1apDuCfg->choice.initiatingMessage->\
1741                        value.choice.GNBDUConfigurationUpdate;
1742          if(duCfgUpdate->protocolIEs.list.array != NULLP)
1743          {
1744             if(duCfgUpdate->protocolIEs.list.array[i] != NULLP)
1745             {
1746                cellsToModify = &duCfgUpdate->protocolIEs.list.array[i]->\
1747                                value.choice.Served_Cells_To_Modify_List;
1748                if(cellsToModify->list.array != NULLP)
1749                {
1750                   if(cellsToModify->list.array[idx] != NULLP)
1751                   {
1752                      modifyItem=&cellsToModify->list.array[idx]->value.choice.\
1753                                 Served_Cells_To_Modify_Item;
1754                      if(modifyItem->oldNRCGI.pLMN_Identity.buf != NULLP)
1755                      {
1756                         if(modifyItem->oldNRCGI.nRCellIdentity.buf != NULLP)
1757                         {
1758                            if(modifyItem->served_Cell_Information.nRCGI.pLMN_Identity.buf != NULLP)
1759                            {
1760                               if(modifyItem->served_Cell_Information.nRCGI.nRCellIdentity.buf
1761                                     != NULLP)
1762                               {
1763                                  if(modifyItem->served_Cell_Information.servedPLMNs.list.array\
1764                                        != NULLP)
1765                                  {
1766                                     if(!modifyItem->served_Cell_Information.servedPLMNs.list.array[idx])
1767                                     {
1768                                        if(modifyItem->served_Cell_Information.servedPLMNs.list.\
1769                                              array[idx]->pLMN_Identity.buf != NULLP)
1770                                        {
1771                                           if(modifyItem->served_Cell_Information.servedPLMNs.list.\
1772                                                 array[idx]->iE_Extensions!= NULLP)
1773                                           {
1774                                              if(modifyItem->served_Cell_Information.servedPLMNs.list.\
1775                                                    array[idx]->iE_Extensions->list.array != NULLP)
1776                                              {
1777                                                 if(modifyItem->served_Cell_Information.servedPLMNs.list.\
1778                                                       array[idx]->iE_Extensions->list.array[idx])
1779                                                 {
1780                                                    if(modifyItem->served_Cell_Information.servedPLMNs.list.array[idx]->\
1781                                                          iE_Extensions->list.array[idx]->extensionValue.choice.SliceSupportList.\
1782                                                          list.array !=NULLP)
1783                                                    {
1784                                                       if(modifyItem->served_Cell_Information.servedPLMNs.list.array[idx]->\
1785                                                             iE_Extensions->list.array[idx]->extensionValue.choice.SliceSupportList.\
1786                                                             list.array[idx]!=NULLP)
1787                                                       {
1788                                                          if(modifyItem->served_Cell_Information.servedPLMNs.list.array[idx]->\
1789                                                                iE_Extensions->list.array[idx]->extensionValue.choice.SliceSupportList.\
1790                                                                list.array[idx]->sNSSAI.sST.buf!=NULLP)
1791                                                          {
1792                                                             if(modifyItem->served_Cell_Information.servedPLMNs.list.array[idx]->\
1793                                                                   iE_Extensions->list.array[idx]->extensionValue.choice.SliceSupportList.\
1794                                                                   list.array[idx]->sNSSAI.sD != NULLP)
1795                                                             {
1796                                                                if(modifyItem->served_Cell_Information.servedPLMNs.list.array[idx]->\
1797                                                                      iE_Extensions->list.array[idx]->extensionValue.choice.SliceSupportList.\
1798                                                                      list.array[idx]->sNSSAI.sD->buf!=NULLP)
1799                                                                {
1800                                                                   if(modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD
1801                                                                         !=NULLP)
1802                                                                   {
1803                                                                      if(modifyItem->served_Cell_Information.nR_Mode_Info.choice.\
1804                                                                            fDD->uL_NRFreqInfo.freqBandListNr.list.array!=NULLP)
1805                                                                      {
1806                                                                         if(modifyItem->served_Cell_Information.nR_Mode_Info.choice.\
1807                                                                               fDD->uL_NRFreqInfo.freqBandListNr.list.array[idx]!=NULLP)
1808                                                                         {
1809                                                                            if(modifyItem->served_Cell_Information.nR_Mode_Info.choice.\
1810                                                                                  fDD->dL_NRFreqInfo.freqBandListNr.list.array !=NULLP)
1811                                                                            {
1812                                                                               if(modifyItem->served_Cell_Information.nR_Mode_Info.\
1813                                                                                     choice.fDD->dL_NRFreqInfo.freqBandListNr.list.\
1814                                                                                     array[idx]!= NULLP)
1815                                                                               {
1816                                                                                  if(modifyItem->served_Cell_Information.\
1817                                                                                        measurementTimingConfiguration.buf !=NULLP)
1818                                                                                  {
1819                                                                                     idx=2;
1820                                                                                     if(duCfgUpdate->protocolIEs.list.array[idx]->value.\
1821                                                                                           choice.GNB_DU_ID.buf!=NULLP)
1822                                                                                     {
1823                                                                                        DU_FREE(duCfgUpdate->protocolIEs.list.\
1824                                                                                              array[idx]->value.choice.GNB_DU_ID.buf,\
1825                                                                                              duCfgUpdate->protocolIEs.list.array[idx]->\
1826                                                                                              value.choice.GNB_DU_ID.size);
1827                                                                                     }
1828                                                                                     idx=0;
1829                                                                                     DU_FREE(modifyItem->served_Cell_Information.\
1830                                                                                           measurementTimingConfiguration.\
1831                                                                                           buf,modifyItem->served_Cell_Information.\
1832                                                                                           measurementTimingConfiguration.size);
1833                                                                                  }
1834                                                                                  DU_FREE(modifyItem->served_Cell_Information.\
1835                                                                                        nR_Mode_Info.choice.fDD->dL_NRFreqInfo.freqBandListNr.\
1836                                                                                        list.array[idx],sizeof(FreqBandNrItem_t));
1837                                                                               }
1838                                                                               DU_FREE(modifyItem->served_Cell_Information.nR_Mode_Info\
1839                                                                                     .choice.fDD->dL_NRFreqInfo.freqBandListNr.list.array,\
1840                                                                                     modifyItem->served_Cell_Information.nR_Mode_Info.\
1841                                                                                     choice.fDD->dL_NRFreqInfo.freqBandListNr.list.size);
1842                                                                            }
1843                                                                            DU_FREE(modifyItem->served_Cell_Information.nR_Mode_Info.\
1844                                                                                  choice.fDD->uL_NRFreqInfo.freqBandListNr.list.\
1845                                                                                  array[idx],sizeof(FreqBandNrItem_t));
1846                                                                         }
1847                                                                         DU_FREE(modifyItem->served_Cell_Information.nR_Mode_Info.\
1848                                                                               choice.\
1849                                                                               fDD->uL_NRFreqInfo.freqBandListNr.list.\
1850                                                                               array,modifyItem->served_Cell_Information.nR_Mode_Info.choice.\
1851                                                                               fDD->uL_NRFreqInfo.freqBandListNr.list.size);
1852                                                                      }
1853                                                                      DU_FREE(modifyItem->served_Cell_Information.nR_Mode_Info.choice.\
1854                                                                            fDD,sizeof(FDD_Info_t));
1855                                                                   }
1856                                                                   DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.\
1857                                                                         array[idx]->iE_Extensions->list.array[idx]->extensionValue.choice.\
1858                                                                         SliceSupportList.\
1859                                                                         list.array[idx]->sNSSAI.sD->buf,modifyItem->served_Cell_Information.\
1860                                                                         servedPLMNs.list.array[idx]->iE_Extensions->list.array[idx]->\
1861                                                                         extensionValue.choice.SliceSupportList.list.array[idx]->\
1862                                                                         sNSSAI.sD->size);
1863
1864                                                                }
1865                                                                DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.\
1866                                                                      array[idx]->\
1867                                                                      iE_Extensions->list.array[idx]->extensionValue.choice.SliceSupportList.\
1868                                                                      list.array[idx]->sNSSAI.sD,sizeof(OCTET_STRING_t));
1869                                                             }
1870                                                             DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.array[idx]->\
1871                                                                   iE_Extensions->list.array[idx]->extensionValue.choice.SliceSupportList.\
1872                                                                   list.array[idx]->sNSSAI.sST.buf,modifyItem->served_Cell_Information.\
1873                                                                   servedPLMNs.\
1874                                                                   list.array[idx]->iE_Extensions->list.array[idx]->extensionValue.choice.\
1875                                                                   SliceSupportList.list.array[idx]->sNSSAI.sST.size);
1876                                                          }
1877                                                          DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.array[idx]->\
1878                                                                iE_Extensions->list.array[idx]->extensionValue.choice.SliceSupportList.\
1879                                                                list.array[idx],sizeof(SliceSupportItem_t));
1880                                                       }
1881                                                       DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.array[idx]->\
1882                                                             iE_Extensions->list.array[idx]->extensionValue.choice.SliceSupportList.\
1883                                                             list.array,\
1884                                                             modifyItem->served_Cell_Information.servedPLMNs.list.array[idx]->\
1885                                                             iE_Extensions->list.array[idx]->extensionValue.choice.SliceSupportList.list.size);
1886                                                    }
1887                                                 }
1888                                                 for(i=0;i<modifyItem->served_Cell_Information.servedPLMNs.list.\
1889                                                       array[idx]->iE_Extensions->list.count;i++)
1890                                                 {
1891                                                    DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.\
1892                                                          array[idx]->iE_Extensions->list.array[i],\
1893                                                          sizeof(ServedPLMNs_ItemExtIEs_t ));
1894                                                 }
1895                                                 DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.\
1896                                                       array[idx]->iE_Extensions->list.array,modifyItem->served_Cell_Information.servedPLMNs.
1897                                                       list.array[idx]->iE_Extensions->list.size);
1898                                              }
1899                                              DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.\
1900                                                    array[idx]->iE_Extensions,sizeof(ProtocolExtensionContainer_4624P3_t));
1901                                           }
1902                                           DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.\
1903                                                 array[idx]->pLMN_Identity.buf,
1904                                                 modifyItem->served_Cell_Information.servedPLMNs.list.array[idx]->pLMN_Identity.size);
1905                                        }
1906                                     }
1907                                     for(i=0;i<modifyItem->served_Cell_Information.servedPLMNs.list.count;i++)
1908                                     {
1909                                        if(modifyItem->served_Cell_Information.servedPLMNs.list.array[i]
1910                                              != NULLP)
1911                                        {
1912                                           DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.array[i],\
1913                                                 sizeof(ServedPLMNs_Item_t));
1914                                        }
1915                                     }
1916                                     DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.array,\
1917                                           modifyItem->served_Cell_Information.servedPLMNs.list.size);
1918                                  }
1919                                  DU_FREE(modifyItem->served_Cell_Information.nRCGI.nRCellIdentity.buf,\
1920                                        modifyItem->served_Cell_Information.nRCGI.nRCellIdentity.size);
1921                               }
1922                               DU_FREE(modifyItem->served_Cell_Information.nRCGI.pLMN_Identity.buf,\
1923                                     modifyItem->served_Cell_Information.nRCGI.pLMN_Identity.size);
1924                            }
1925                            DU_FREE(modifyItem->oldNRCGI.nRCellIdentity.buf,\
1926                                  modifyItem->oldNRCGI.nRCellIdentity.size);
1927                         }
1928                         DU_FREE(modifyItem->oldNRCGI.pLMN_Identity.buf,\
1929                               modifyItem->oldNRCGI.pLMN_Identity.size);
1930                      }
1931                   }
1932                   for(i=0; i<cellsToModify->list.count ;i++)
1933                   {
1934                      if(cellsToModify->list.array[i] != NULLP)
1935                      {
1936                         DU_FREE(cellsToModify->list.array[i],\
1937                               sizeof(Served_Cells_To_Modify_ItemIEs_t));
1938                      }
1939                   }
1940                   DU_FREE(cellsToModify->list.array,cellsToModify->list.size);
1941                }
1942             }
1943             for(i=0;i<duCfgUpdate->protocolIEs.list.count;i++)
1944             {
1945                if(duCfgUpdate->protocolIEs.list.array[i] !=NULLP)
1946                {
1947                   DU_FREE(duCfgUpdate->protocolIEs.list.array[i],\
1948                         sizeof(GNBDUConfigurationUpdateIEs_t));
1949                }
1950             }
1951             DU_FREE(duCfgUpdate->protocolIEs.list.array,duCfgUpdate->protocolIEs.list.size);
1952          }
1953          DU_FREE(f1apDuCfg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
1954       }
1955       DU_FREE(f1apDuCfg, (Size)sizeof(F1AP_PDU_t));
1956    }
1957 }
1958
1959 /*******************************************************************
1960  *
1961  * @brief Fills Served Plmns required in ServCellInfo IE
1962  *
1963  * @details
1964  *
1965  *    Function : fillServedPlmns
1966  *
1967  *    Functionality: Fills Served Plmns required in ServCellInfo IE
1968  *
1969  * @params[in] Pointer to ServedPLMNs_List_t *
1970  *
1971  * @return ROK     - success
1972  *         RFAILED - failure
1973  *
1974  *****************************************************************/
1975
1976 uint8_t fillServedPlmns(ServedPLMNs_List_t *servedPlmn)
1977 {
1978    uint8_t ieIdx, ieListCnt;
1979
1980    servedPlmn->list.array[0]->pLMN_Identity.size = 3*sizeof(uint8_t);
1981    DU_ALLOC(servedPlmn->list.array[0]->pLMN_Identity.buf, servedPlmn->list.\
1982          array[0]->pLMN_Identity.size);
1983    if(servedPlmn->list.array[0]->pLMN_Identity.buf == NULLP)
1984    {
1985       return RFAILED;
1986    }
1987    buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.plmn[0],\
1988          servedPlmn->list.array[0]->pLMN_Identity.buf);
1989    DU_ALLOC(servedPlmn->list.array[0]->iE_Extensions,sizeof(ProtocolExtensionContainer_4624P3_t));
1990    if(servedPlmn->list.array[0]->iE_Extensions == NULLP)
1991    {
1992       return RFAILED;
1993    }
1994
1995    ieListCnt=1;
1996    servedPlmn->list.array[0]->iE_Extensions->list.count = ieListCnt;
1997    servedPlmn->list.array[0]->iE_Extensions->list.size = ieListCnt *sizeof(ServedPLMNs_ItemExtIEs_t *);
1998    DU_ALLOC(servedPlmn->list.array[0]->iE_Extensions->list.array,servedPlmn->list.array[0]->\
1999          iE_Extensions->list.size);
2000    if(servedPlmn->list.array[0]->iE_Extensions->list.array == NULLP)
2001    {
2002       return RFAILED;
2003    }
2004    for(ieIdx=0;ieIdx<ieListCnt;ieIdx++)
2005    {
2006       DU_ALLOC(servedPlmn->list.array[0]->iE_Extensions->list.array[ieIdx],\
2007             sizeof(ServedPLMNs_ItemExtIEs_t));
2008       if(servedPlmn->list.array[0]->iE_Extensions->list.array[ieIdx] == NULLP)
2009       {
2010          return RFAILED;
2011       }
2012    }
2013    //plmnIeExt = servedPlmn->list.array[0]->iE_Extensions;
2014    servedPlmn->list.array[0]->iE_Extensions->list.array[0]->id =ProtocolIE_ID_id_TAISliceSupportList;
2015    servedPlmn->list.array[0]->iE_Extensions->list.array[0]->criticality = Criticality_ignore;
2016    servedPlmn->list.array[0]->iE_Extensions->list.array[0]->extensionValue.present = \
2017       ServedPLMNs_ItemExtIEs__extensionValue_PR_SliceSupportList;
2018    servedPlmn->list.array[0]->iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2019       list.count = 1;
2020    servedPlmn->list.array[0]->\
2021       iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2022       list.size = sizeof(SliceSupportItem_t *);
2023    DU_ALLOC(servedPlmn->list.array[0]->\
2024          iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2025          list.array,servedPlmn->list.array[0]->\
2026          iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.list.size);
2027    if(servedPlmn->list.array[0]->\
2028          iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2029          list.array == NULLP)
2030    {
2031       return RFAILED;
2032    }
2033
2034    DU_ALLOC(servedPlmn->list.array[0]->\
2035          iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2036          list.array[0],sizeof( SliceSupportItem_t));
2037    if(servedPlmn->list.array[0]->\
2038          iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2039          list.array[0] == NULLP)
2040    {
2041       return RFAILED;
2042    }
2043    servedPlmn->list.array[0]->\
2044       iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2045       list.array[0]->sNSSAI.sST.size = sizeof(uint8_t);
2046    DU_ALLOC(servedPlmn->list.array[0]->\
2047          iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2048          list.array[0]->sNSSAI.sST.buf,servedPlmn->list.array[0]->\
2049          iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.list.array[0]->sNSSAI.sST.size);
2050    if(servedPlmn->list.array[0]->\
2051          iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2052          list.array[0]->sNSSAI.sST.buf == NULLP)
2053    {
2054       return RFAILED;
2055    }
2056    servedPlmn->list.array[0]->\
2057       iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2058       list.array[0]->sNSSAI.sST.buf[0] = 3;
2059    DU_ALLOC(servedPlmn->list.array[0]->\
2060          iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2061          list.array[0]->sNSSAI.sD,sizeof(OCTET_STRING_t));
2062    if(servedPlmn->list.array[0]->\
2063          iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2064          list.array[0]->sNSSAI.sD == NULLP)
2065    {
2066       return RFAILED;
2067    }
2068    servedPlmn->list.array[0]->\
2069       iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2070       list.array[0]->sNSSAI.sD->size = 3*sizeof(uint8_t);
2071    DU_ALLOC(servedPlmn->list.array[0]->\
2072          iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2073          list.array[0]->sNSSAI.sD->buf,servedPlmn->list.array[0]->\
2074          iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2075          list.array[0]->sNSSAI.sD->size);
2076    if(servedPlmn->list.array[0]->\
2077          iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2078          list.array[0]->sNSSAI.sD->buf == NULLP)
2079    {
2080       return RFAILED;
2081    }
2082    servedPlmn->list.array[0]->\
2083       iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2084       list.array[0]->sNSSAI.sD->buf[0] = 3;
2085    servedPlmn->list.array[0]->\
2086       iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2087       list.array[0]->sNSSAI.sD->buf[1] = 6;
2088    servedPlmn->list.array[0]->\
2089       iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2090       list.array[0]->sNSSAI.sD->buf[2] = 9;
2091    return ROK;
2092 }
2093
2094 /*******************************************************************
2095  *
2096  * @brief Fills Nr Fdd Info required in ServCellInfo IE
2097  *
2098  * @details
2099  *
2100  *    Function : fillNrFddInfo
2101  *
2102  *    Functionality: Fills Nr Fdd Info required in ServCellInfo IE
2103  *
2104  * @params[in] Pointer to NR_Mode_Info_t *
2105  *
2106  * @return ROK     - success
2107  *         RFAILED - failure
2108  *
2109  *****************************************************************/
2110
2111 uint8_t fillNrFddInfo(NR_Mode_Info_t *nrFdd)
2112 {
2113    nrFdd->choice.fDD->uL_NRFreqInfo.nRARFCN = duCfgParam.srvdCellLst[0].duCellInfo.\
2114       f1Mode.mode.fdd.ulNrFreqInfo.nrArfcn;
2115    nrFdd->choice.fDD->uL_NRFreqInfo.freqBandListNr.list.count = 1;
2116    nrFdd->choice.fDD->uL_NRFreqInfo.freqBandListNr.list.size = sizeof(FreqBandNrItem_t*);
2117    DU_ALLOC(nrFdd->choice.fDD->uL_NRFreqInfo.freqBandListNr.list.\
2118          array, nrFdd->choice.fDD->uL_NRFreqInfo.freqBandListNr.list.size);
2119    if(nrFdd->choice.fDD->uL_NRFreqInfo.freqBandListNr.list.array == NULLP)
2120    {
2121       return RFAILED;
2122    }
2123    DU_ALLOC(nrFdd->choice.fDD->uL_NRFreqInfo.freqBandListNr.list.array[0], \
2124       sizeof(FreqBandNrItem_t));
2125    if(nrFdd->choice.fDD->uL_NRFreqInfo.freqBandListNr.list.array[0] == NULLP)
2126    {
2127       return RFAILED;
2128    }
2129    nrFdd->choice.fDD->uL_NRFreqInfo.freqBandListNr.list.array[0]->freqBandIndicatorNr = \
2130       duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.fdd.ulNrFreqInfo.\
2131       freqBand[0].nrFreqBand;
2132    nrFdd->choice.fDD->uL_NRFreqInfo.freqBandListNr.list.array[0]->supportedSULBandList.list.count=0;
2133    nrFdd->choice.fDD->dL_NRFreqInfo.nRARFCN = duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.fdd.\
2134       dlNrFreqInfo.nrArfcn;
2135    nrFdd->choice.fDD->dL_NRFreqInfo.freqBandListNr.list.count = 1;
2136    nrFdd->choice.fDD->dL_NRFreqInfo.freqBandListNr.list.size = sizeof(FreqBandNrItem_t *);
2137    DU_ALLOC(nrFdd->choice.fDD->dL_NRFreqInfo.freqBandListNr.list.array,nrFdd->\
2138          choice.fDD->dL_NRFreqInfo.freqBandListNr.list.size);
2139    if(nrFdd->choice.fDD->dL_NRFreqInfo.freqBandListNr.list.array == NULLP)
2140    {
2141       return RFAILED;
2142    }
2143    DU_ALLOC(nrFdd->choice.fDD->dL_NRFreqInfo.freqBandListNr.list.array[0],\
2144          sizeof(FreqBandNrItem_t));
2145    if(nrFdd->choice.fDD->dL_NRFreqInfo.freqBandListNr.list.array[0] == NULLP)
2146    {
2147       return RFAILED;
2148    }
2149    nrFdd->choice.fDD->dL_NRFreqInfo.freqBandListNr.list.array[0]->freqBandIndicatorNr = \
2150       duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.fdd.dlNrFreqInfo.\
2151       freqBand[0].nrFreqBand;
2152    nrFdd->choice.fDD->dL_NRFreqInfo.freqBandListNr.list.array[0]->supportedSULBandList.list.count=0;
2153
2154    /*Transmission Bandwidth*/
2155    nrFdd->choice.fDD->uL_Transmission_Bandwidth.nRSCS = duCfgParam.srvdCellLst[0].duCellInfo.\
2156       f1Mode.mode.fdd.ulTxBw.nrScs;
2157    nrFdd->choice.fDD->uL_Transmission_Bandwidth.nRNRB = duCfgParam.srvdCellLst[0].duCellInfo.\
2158       f1Mode.mode.fdd.ulTxBw.nrb;
2159    nrFdd->choice.fDD->dL_Transmission_Bandwidth.nRSCS = duCfgParam.srvdCellLst[0].duCellInfo.\
2160       f1Mode.mode.fdd.dlTxBw.nrScs;
2161    nrFdd->choice.fDD->dL_Transmission_Bandwidth.nRNRB = duCfgParam.srvdCellLst[0].duCellInfo.\
2162       f1Mode.mode.fdd.dlTxBw.nrb;
2163
2164    return ROK;
2165 }
2166
2167 /*******************************************************************
2168  *
2169  * @brief Fills ServCellInfo IE
2170  *
2171  * @details
2172  *
2173  *    Function : fillServedCellInfo
2174  *
2175  *    Functionality: Fills ServCellInfo
2176  *
2177  * @params[in] Pointer to Served_Cell_Information_t *
2178  *
2179  * @return ROK     - success
2180  *         RFAILED - failure
2181  *
2182  *****************************************************************/
2183
2184 uint8_t fillServedCellInfo(Served_Cell_Information_t *srvCellInfo)
2185 {
2186    uint8_t tmp, ieIdx, ieListCnt;
2187
2188    /*nRCGI*/
2189    srvCellInfo->nRCGI.pLMN_Identity.size =3*sizeof(uint8_t);
2190    DU_ALLOC(srvCellInfo->nRCGI.pLMN_Identity.buf,\
2191          srvCellInfo->nRCGI.pLMN_Identity.size);
2192    if(srvCellInfo->nRCGI.pLMN_Identity.buf == NULLP)
2193    {
2194       return RFAILED;
2195    }
2196    buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrCgi.plmn,\
2197          srvCellInfo->nRCGI.pLMN_Identity.buf);
2198    srvCellInfo->nRCGI.nRCellIdentity.size =5*sizeof(uint8_t);
2199    DU_ALLOC(srvCellInfo->nRCGI.nRCellIdentity.buf,\
2200          srvCellInfo->nRCGI.nRCellIdentity.size);
2201    if(srvCellInfo->nRCGI.nRCellIdentity.buf == NULLP)
2202    {
2203       return RFAILED;
2204    }
2205    for (tmp = 0 ; tmp < srvCellInfo->\
2206          nRCGI.nRCellIdentity.size-1 ; tmp++)
2207    {
2208       srvCellInfo->nRCGI.nRCellIdentity.buf[tmp] = 0;
2209    }
2210    srvCellInfo->nRCGI.nRCellIdentity.buf[4] = 16;
2211    srvCellInfo->nRCGI.nRCellIdentity.bits_unused =4;
2212
2213    /*nRPCI*/
2214    srvCellInfo->nRPCI = duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrPci;
2215
2216    /*servedPLMNs*/
2217    ieListCnt = 1;
2218    srvCellInfo->servedPLMNs.list.count = ieListCnt;
2219    srvCellInfo->servedPLMNs.list.size = ieListCnt*sizeof(ServedPLMNs_Item_t *);
2220    DU_ALLOC(srvCellInfo->servedPLMNs.list.array,\
2221          srvCellInfo->servedPLMNs.list.size);
2222    if(srvCellInfo->servedPLMNs.list.array == NULLP)
2223    {
2224       return RFAILED;
2225    }
2226    for(ieIdx=0; ieIdx < ieListCnt; ieIdx++)
2227    {
2228       DU_ALLOC(srvCellInfo->servedPLMNs.list.array[ieIdx],\
2229             sizeof(ServedPLMNs_Item_t));
2230       if(srvCellInfo->servedPLMNs.list.array[ieIdx]== NULLP)
2231       {
2232          return RFAILED;
2233       }
2234    }
2235    if(fillServedPlmns(&srvCellInfo->servedPLMNs))
2236    {
2237       return RFAILED;
2238    }
2239
2240    /*nR Mode Info with FDD*/
2241    srvCellInfo->nR_Mode_Info.present = NR_Mode_Info_PR_fDD;
2242    DU_ALLOC(srvCellInfo->nR_Mode_Info.choice.fDD,\
2243          sizeof(FDD_Info_t));
2244    if(srvCellInfo->nR_Mode_Info.choice.fDD == NULLP)
2245    {
2246       return RFAILED;
2247    }
2248    if(fillNrFddInfo(&srvCellInfo->nR_Mode_Info))
2249       return RFAILED;
2250
2251    /*Measurement timing Config*/
2252    srvCellInfo->measurementTimingConfiguration.size = sizeof(uint8_t);
2253    DU_ALLOC(srvCellInfo->measurementTimingConfiguration.\
2254          buf,srvCellInfo->measurementTimingConfiguration.size);
2255    if(srvCellInfo->measurementTimingConfiguration.buf == NULLP)
2256    {
2257       return RFAILED;
2258    }
2259    srvCellInfo->measurementTimingConfiguration.\
2260          buf[0] = duCfgParam.srvdCellLst[0].duCellInfo.measTimeCfg;
2261
2262    return ROK;
2263 }
2264
2265 /*******************************************************************
2266  *
2267  * @brief Fills ServCellToModItem IE
2268  *
2269  * @details
2270  *
2271  *    Function : fillServCellToModItem
2272  *
2273  *    Functionality: Fills ServCellToModItem IE
2274  *
2275  * @params[in] Pointer to Served_Cells_To_Modify_Item_t *
2276  *
2277  * @return ROK     - success
2278  *         RFAILED - failure
2279  *
2280  *****************************************************************/
2281
2282 uint8_t fillServCellToModItem(Served_Cells_To_Modify_Item_t *modifyItem)
2283 {
2284    uint8_t ieIdx;
2285
2286    /*pLMN_Identity*/
2287    modifyItem->oldNRCGI.pLMN_Identity.size = 3*sizeof(uint8_t);
2288    DU_ALLOC(modifyItem->oldNRCGI.pLMN_Identity.buf,modifyItem->oldNRCGI.pLMN_Identity.size);
2289    if(modifyItem->oldNRCGI.pLMN_Identity.buf == NULLP)
2290    {
2291       return RFAILED;
2292    }
2293    buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrCgi.plmn,\
2294          modifyItem->oldNRCGI.pLMN_Identity.buf);
2295
2296    /*nRCellIdentity*/
2297    modifyItem->oldNRCGI.nRCellIdentity.size = 5*sizeof(uint8_t);
2298    DU_ALLOC(modifyItem->oldNRCGI.nRCellIdentity.buf,\
2299          modifyItem->oldNRCGI.nRCellIdentity.size);
2300    if(modifyItem->oldNRCGI.nRCellIdentity.buf == NULLP)
2301    {
2302       return RFAILED;
2303    }
2304    for(ieIdx = 0; ieIdx < modifyItem->oldNRCGI.nRCellIdentity.size-1; ieIdx++)
2305    {
2306       modifyItem->oldNRCGI.nRCellIdentity.buf[ieIdx] = 0;
2307    }
2308    modifyItem->oldNRCGI.nRCellIdentity.buf[4] = 16;
2309    modifyItem->oldNRCGI.nRCellIdentity.bits_unused = 4;
2310
2311    if(fillServedCellInfo(&modifyItem->served_Cell_Information))
2312       return RFAILED;
2313    else
2314       return ROK;
2315 }
2316
2317 /*******************************************************************
2318  *
2319  * @brief Builds ServCellToModList
2320  *
2321  * @details
2322  *
2323  *    Function : buildServCellToModList
2324  *
2325  *    Functionality: Builds the serv cell to Mod List
2326  *
2327  * @params[in] Pointer to Served_Cells_To_Modify_List_t *
2328  *
2329  * @return ROK     - success
2330  *         RFAILED - failure
2331  *
2332  *****************************************************************/
2333
2334 uint8_t buildServCellToModList(Served_Cells_To_Modify_List_t *cellsToModify)
2335 {
2336    uint8_t ieListCnt, ieIdx;
2337    Served_Cells_To_Modify_Item_t *modifyItem = NULLP;
2338
2339    ieListCnt = 1;
2340    cellsToModify->list.count = ieListCnt;
2341    cellsToModify->list.size = ieListCnt*sizeof(Served_Cells_To_Modify_ItemIEs_t *);
2342    DU_ALLOC(cellsToModify->list.array,cellsToModify->list.size);
2343    if(cellsToModify->list.array == NULLP)
2344    {
2345       return RFAILED;
2346    }
2347    for(ieIdx=0; ieIdx< ieListCnt; ieIdx++)
2348    {
2349       DU_ALLOC(cellsToModify->list.array[ieIdx],sizeof(Served_Cells_To_Modify_ItemIEs_t));
2350       if(cellsToModify->list.array[ieIdx] == NULLP)
2351       {
2352          return RFAILED;
2353       }
2354    }
2355    cellsToModify->list.array[0]->id = ProtocolIE_ID_id_Served_Cells_To_Modify_Item;
2356    cellsToModify->list.array[0]->criticality = Criticality_reject;
2357    cellsToModify->list.array[0]->value.present =\
2358       Served_Cells_To_Modify_ItemIEs__value_PR_Served_Cells_To_Modify_Item;
2359    modifyItem=&cellsToModify->list.array[0]->value.choice.Served_Cells_To_Modify_Item;
2360
2361    if(fillServCellToModItem(modifyItem))
2362       return RFAILED;
2363    else
2364       return ROK;
2365 }
2366
2367 /*******************************************************************
2368  *
2369  * @brief Builds and sends the DUConfigUpdate
2370  *
2371  * @details
2372  *
2373  *    Function : BuildAndSendDUConfigUpdate
2374  *
2375  *    Functionality: Constructs the DU Update message and sends
2376  *                   it to the CU through SCTP.
2377  *
2378  * @params[in] void **buf,Buffer to which encoded pattern is written into
2379  * @params[in] int *size,size of buffer
2380  *
2381  * @return ROK     - success
2382  *         RFAILED - failure
2383  *
2384  * ****************************************************************/
2385 uint8_t BuildAndSendDUConfigUpdate()
2386 {
2387    uint8_t ret, ieIdx, elementCnt;
2388    F1AP_PDU_t                 *f1apDuCfg = NULLP;
2389    GNBDUConfigurationUpdate_t *duCfgUpdate = NULLP;
2390    asn_enc_rval_t encRetVal;     /* Encoder return value */
2391    memset(&encRetVal, 0, sizeof(asn_enc_rval_t));
2392    ret= RFAILED;
2393
2394    while(true)
2395    {
2396       DU_LOG("\nINFO   -->  F1AP : Building DU config update\n");
2397       /* Allocate the memory for F1DuCfg */
2398       DU_ALLOC(f1apDuCfg, sizeof(F1AP_PDU_t));
2399       if(f1apDuCfg == NULLP)
2400       {
2401          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
2402          break;
2403       }
2404
2405       f1apDuCfg->present = F1AP_PDU_PR_initiatingMessage;
2406       DU_ALLOC(f1apDuCfg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
2407       if(f1apDuCfg->choice.initiatingMessage == NULLP)
2408       {
2409          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
2410          break;
2411       }
2412
2413       f1apDuCfg->choice.initiatingMessage->procedureCode = \
2414                                                            ProcedureCode_id_gNBDUConfigurationUpdate;
2415       f1apDuCfg->choice.initiatingMessage->criticality = Criticality_reject;
2416       f1apDuCfg->choice.initiatingMessage->value.present = \
2417                                                            InitiatingMessage__value_PR_GNBDUConfigurationUpdate;
2418       duCfgUpdate = &f1apDuCfg->choice.initiatingMessage->value.\
2419                     choice.GNBDUConfigurationUpdate;
2420       elementCnt = 3;
2421       duCfgUpdate->protocolIEs.list.count = elementCnt;
2422       duCfgUpdate->protocolIEs.list.size = \
2423                                            elementCnt * sizeof(GNBDUConfigurationUpdateIEs_t*);
2424
2425       /* Initialize the F1Setup members */
2426       DU_ALLOC(duCfgUpdate->protocolIEs.list.array,duCfgUpdate->protocolIEs.list.size);
2427       if(duCfgUpdate->protocolIEs.list.array == NULLP)
2428       {
2429          DU_LOG("ERROR  -->  F1AP : Memory allocation for F1RequestIEs failed");
2430          break;
2431       }
2432       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
2433       {
2434          DU_ALLOC(duCfgUpdate->protocolIEs.list.array[ieIdx],sizeof(GNBDUConfigurationUpdateIEs_t));
2435          if(duCfgUpdate->protocolIEs.list.array[ieIdx] == NULLP)
2436          {
2437             break;
2438          }
2439       }
2440
2441       /*TransactionID*/
2442       ieIdx = 0;
2443       duCfgUpdate->protocolIEs.list.array[ieIdx]->id=ProtocolIE_ID_id_TransactionID;
2444       duCfgUpdate->protocolIEs.list.array[ieIdx]->criticality= Criticality_reject;
2445       duCfgUpdate->protocolIEs.list.array[ieIdx]->value.present = \
2446          GNBDUConfigurationUpdateIEs__value_PR_TransactionID;
2447       duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.TransactionID = TRANS_ID;
2448
2449       /*Served Cell to Modify */
2450       ieIdx++;
2451       duCfgUpdate->protocolIEs.list.array[ieIdx]->id = \
2452                                                       ProtocolIE_ID_id_Served_Cells_To_Modify_List;
2453       duCfgUpdate->protocolIEs.list.array[ieIdx]->criticality =Criticality_reject;
2454       duCfgUpdate->protocolIEs.list.array[ieIdx]->value.present = \
2455          GNBDUConfigurationUpdateIEs__value_PR_Served_Cells_To_Modify_List;
2456       if(buildServCellToModList(&duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.\
2457          Served_Cells_To_Modify_List))
2458          break;
2459
2460       // NOTE :GNB DU SYS INFO:MIB AND SIB1 INFORMATION TO BE BUILT AND FILLED HERE
2461       /*GNB DU ID */
2462       ieIdx++;
2463       duCfgUpdate->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_ID;
2464       duCfgUpdate->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
2465       duCfgUpdate->protocolIEs.list.array[ieIdx]->value.present = \
2466         GNBDUConfigurationUpdateIEs__value_PR_GNB_DU_ID;
2467       duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.size = sizeof(uint8_t);
2468       DU_ALLOC(duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf,\
2469             duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.size);
2470       if(duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf == NULLP)
2471       {
2472          break;
2473       }
2474       duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf[0] = duCfgParam.duId;
2475
2476       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apDuCfg);
2477
2478       /* Encode the DU Config Update type as APER */
2479       memset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
2480       encBufSize = 0;
2481       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apDuCfg, PrepFinalEncBuf, encBuf);
2482
2483       /* Checking encode results */
2484       if(encRetVal.encoded == ENCODE_FAIL)
2485       {
2486          DU_LOG("ERROR  -->  F1AP : Could not encode DUConfigUpdate structure (at %s)\n",\
2487          encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
2488          break;
2489       }
2490       else
2491       {
2492          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for DUConfigUpdate\n");
2493          for(ieIdx =0; ieIdx < encBufSize; ieIdx++)
2494          {
2495             printf("%x",encBuf[ieIdx]);
2496          }
2497       }
2498       /* Sending msg */
2499       if(sendF1APMsg() != ROK)
2500       {
2501          DU_LOG("\nERROR  -->  F1AP : Sending GNB-DU Config Update failed");
2502          break;
2503       }
2504
2505       ret = ROK;
2506       break;
2507    }
2508    FreeDUConfigUpdate(f1apDuCfg);
2509
2510    return ret;
2511 }
2512
2513
2514 /*******************************************************************
2515  *
2516  * @brief free the ULRRCMessageTransfer
2517  *
2518  * @details
2519  *
2520  *    Function : FreeULRRCMessageTransfer
2521  *
2522  *    Functionality: Deallocating the memory of variable allocated in
2523  *                      FreeULRRCMessageTransfer
2524  *
2525  * @params[in]
2526  *
2527  * @return ROK     - void
2528  *
2529  ******************************************************************/
2530 void FreeULRRCMessageTransfer( F1AP_PDU_t *f1apMsg)
2531 {
2532    uint8_t idx1;
2533    ULRRCMessageTransfer_t  *ulRRCMsg;
2534
2535    if(f1apMsg != NULLP)
2536    {
2537       if(f1apMsg->choice.initiatingMessage != NULLP)
2538       {
2539          ulRRCMsg = &f1apMsg->choice.initiatingMessage->value.choice.ULRRCMessageTransfer;
2540          if(ulRRCMsg->protocolIEs.list.array != NULLP)
2541          {
2542             for(idx1=0;idx1<ulRRCMsg->protocolIEs.list.count;idx1++)
2543             {
2544                if(ulRRCMsg->protocolIEs.list.array[idx1] != NULLP)
2545                {
2546                   if(ulRRCMsg->protocolIEs.list.array[idx1]->value.present ==
2547                         ULRRCMessageTransferIEs__value_PR_RRCContainer)
2548                   {
2549                      DU_FREE(ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.buf,
2550                            ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.size);
2551                   }
2552                   DU_FREE(ulRRCMsg->protocolIEs.list.array[idx1],sizeof(ULRRCMessageTransferIEs_t));
2553                }
2554             }
2555             DU_FREE(ulRRCMsg->protocolIEs.list.array,ulRRCMsg->protocolIEs.list.size );
2556          }
2557          DU_FREE(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
2558       }
2559       DU_FREE(f1apMsg,sizeof(F1AP_PDU_t));
2560    }
2561 }
2562 /*******************************************************************
2563  *
2564  * @brief Builds and sends the ULRRCMessageTransfer
2565  *
2566  * @details
2567  *
2568  *    Function : BuildAndSendULRRCMessageTransfer
2569  *
2570  *    Functionality: Constructs the UL RRC Message Transfer and sends
2571  *                   it to the CU through SCTP.
2572  *
2573  * @params[in]
2574  *
2575  * @return ROK     - success
2576  *         RFAILED - failure
2577  *
2578  * ****************************************************************/
2579 uint8_t BuildAndSendULRRCMessageTransfer(DuUeCb  ueCb, uint8_t lcId, \
2580       uint16_t msgLen, uint8_t *rrcMsg)
2581 {
2582    uint8_t   elementCnt =0;
2583    uint8_t   idx1 =0;
2584    uint8_t   idx =0;
2585    F1AP_PDU_t                   *f1apMsg = NULLP;
2586    ULRRCMessageTransfer_t       *ulRRCMsg = NULLP;
2587    asn_enc_rval_t               encRetVal;        /* Encoder return value */
2588    uint8_t ret =RFAILED;
2589
2590    memset(&encRetVal, 0, sizeof(asn_enc_rval_t));
2591
2592    while(true)
2593    {
2594       DU_LOG("\n INFO   -->  F1AP : Building UL RRC Message Transfer Message\n");
2595
2596       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
2597       if(f1apMsg == NULLP)
2598       {
2599          DU_LOG(" ERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
2600          break;
2601       }
2602       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
2603       DU_ALLOC(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
2604       if(f1apMsg->choice.initiatingMessage == NULLP)
2605       {
2606          DU_LOG(" ERROR  -->  F1AP : Memory allocation for      F1AP-PDU failed");
2607          break;
2608       }
2609       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_ULRRCMessageTransfer;
2610       f1apMsg->choice.initiatingMessage->criticality = Criticality_ignore;
2611       f1apMsg->choice.initiatingMessage->value.present = \
2612                                                          InitiatingMessage__value_PR_ULRRCMessageTransfer;
2613       ulRRCMsg =
2614          &f1apMsg->choice.initiatingMessage->value.choice.ULRRCMessageTransfer;
2615       elementCnt = 4;
2616       ulRRCMsg->protocolIEs.list.count = elementCnt;
2617       ulRRCMsg->protocolIEs.list.size = \
2618                                         elementCnt * sizeof(ULRRCMessageTransferIEs_t *);
2619
2620       /* Initialize the F1Setup members */
2621       DU_ALLOC(ulRRCMsg->protocolIEs.list.array, ulRRCMsg->protocolIEs.list.size);
2622       if(ulRRCMsg->protocolIEs.list.array == NULLP)
2623       {
2624          DU_LOG(" ERROR  -->  F1AP : Memory allocation for UL RRC MessageTransferIEs failed");
2625          break;
2626       }
2627       for(idx=0; idx<elementCnt; idx++)
2628       {
2629          DU_ALLOC(ulRRCMsg->protocolIEs.list.array[idx],sizeof(ULRRCMessageTransferIEs_t));
2630          if(ulRRCMsg->protocolIEs.list.array[idx] == NULLP)
2631          {
2632             break;
2633          }
2634       }
2635
2636       idx1 = 0;
2637
2638       /*GNB CU UE F1AP ID*/
2639       ulRRCMsg->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
2640       ulRRCMsg->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
2641       ulRRCMsg->protocolIEs.list.array[idx1]->value.present = \
2642                                                               ULRRCMessageTransferIEs__value_PR_GNB_CU_UE_F1AP_ID;
2643       ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.GNB_CU_UE_F1AP_ID = ueCb.gnbCuUeF1apId;
2644
2645       /*GNB DU UE F1AP ID*/
2646       idx1++;
2647       ulRRCMsg->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
2648       ulRRCMsg->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
2649       ulRRCMsg->protocolIEs.list.array[idx1]->value.present = \
2650                                                               ULRRCMessageTransferIEs__value_PR_GNB_DU_UE_F1AP_ID;
2651       ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.GNB_DU_UE_F1AP_ID = ueCb.gnbDuUeF1apId;
2652
2653       /*SRBID*/
2654       idx1++;
2655       ulRRCMsg->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_SRBID;
2656       ulRRCMsg->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
2657       ulRRCMsg->protocolIEs.list.array[idx1]->value.present = \
2658                                                               ULRRCMessageTransferIEs__value_PR_SRBID;
2659       ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.SRBID = lcId;
2660
2661       /*RRCContainer*/
2662       idx1++;
2663       ulRRCMsg->protocolIEs.list.array[idx1]->id  = ProtocolIE_ID_id_RRCContainer;
2664       ulRRCMsg->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
2665       ulRRCMsg->protocolIEs.list.array[idx1]->value.present = \
2666                                                               ULRRCMessageTransferIEs__value_PR_RRCContainer;
2667       ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.size = msgLen;
2668       DU_ALLOC(ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.buf,
2669             ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.size)
2670       if(!ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.buf)
2671       {
2672          DU_LOG(" ERROR  -->  F1AP : Memory allocation for BuildAndSendULRRCMessageTransfer failed");
2673          break;
2674       }
2675       memset(ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.buf, 0, msgLen);
2676       memcpy(ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.buf, \
2677             rrcMsg, ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.size);
2678
2679       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
2680
2681       /* Encode the F1SetupRequest type as APER */
2682       memset(encBuf, 0, ENC_BUF_MAX_LEN);
2683       encBufSize = 0;
2684       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
2685             encBuf);
2686       /* Encode results */
2687       if(encRetVal.encoded == ENCODE_FAIL)
2688       {
2689          DU_LOG( "\nERROR  -->  F1AP : Could not encode ULRRCMessageTransfer structure (at %s)\n",\
2690                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
2691          break;
2692       }
2693       else
2694       {
2695          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for ULRRCMessageTransfer\n");
2696          for(int i=0; i< encBufSize; i++)
2697          {
2698             printf("%x",encBuf[i]);
2699          }
2700       }
2701
2702       /* Sending  msg  */
2703       if(sendF1APMsg()  !=      ROK)
2704       {
2705          DU_LOG("\nERROR  -->   F1AP : Sending  UL RRC Message Transfer Failed");
2706          break;
2707       }
2708       ret = ROK;
2709       break;
2710    }
2711    FreeULRRCMessageTransfer(f1apMsg);
2712
2713    return ret;
2714 }/* End of BuildAndSendULRRCMessageTransfer*/
2715
2716 /*******************************************************************
2717  *
2718  * @brief Builds tag config
2719  *
2720  * @details
2721  *
2722  *    Function : BuildTagConfig
2723  *
2724  *    Functionality: Builds tag config in MacCellGroupConfig
2725  *
2726  * @params[in] TAG_Config *tag_Config
2727  *
2728  * @return ROK     - success
2729  *         RFAILED - failure
2730  *
2731  * ****************************************************************/
2732 uint8_t BuildTagConfig(struct TAG_Config *tagConfig)
2733 {
2734    struct TAG_Config__tag_ToAddModList *tagList;
2735    uint8_t                     idx, elementCnt;
2736
2737    tagConfig->tag_ToReleaseList = NULLP;
2738    tagConfig->tag_ToAddModList = NULLP;
2739    DU_ALLOC(tagConfig->tag_ToAddModList, sizeof(struct TAG_Config__tag_ToAddModList));
2740    if(!tagConfig->tag_ToAddModList)
2741    {
2742       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildTagConfig");
2743       return RFAILED;
2744    }
2745
2746    elementCnt = 1; //ODU_VALUE_ONE;
2747    tagList = tagConfig->tag_ToAddModList;
2748    tagList->list.count = elementCnt;
2749    tagList->list.size  =  elementCnt * sizeof(struct TAG *);
2750
2751    tagList->list.array = NULLP;
2752    DU_ALLOC(tagList->list.array, tagList->list.size);
2753    if(!tagList->list.array)
2754    {
2755       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildTagConfig");
2756       return RFAILED;
2757    }
2758
2759    for(idx=0; idx<tagList->list.count; idx++)
2760    {
2761       tagList->list.array[idx] = NULLP;
2762       DU_ALLOC(tagList->list.array[idx], sizeof(struct TAG));
2763       if(!tagList->list.array[idx])
2764       {
2765          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildTagConfig");
2766          return RFAILED;
2767       }
2768    }
2769
2770    idx = 0;
2771    tagList->list.array[idx]->tag_Id = TAG_ID;
2772    tagList->list.array[idx]->timeAlignmentTimer = TIME_ALIGNMENT_TMR;
2773
2774    return ROK;
2775 }
2776
2777 /*******************************************************************
2778  *
2779  * @brief Builds PHR Config
2780  *
2781  * @details
2782  *
2783  *    Function : BuildPhrConfig
2784  *
2785  *    Functionality: Builds phrConfig in MacCellGroupConfig
2786  *
2787  * @params[in] PHR Config *
2788  *
2789  * @return ROK     - success
2790  *         RFAILED - failure
2791  *
2792  * ****************************************************************/
2793 uint8_t BuildPhrConfig(struct MAC_CellGroupConfig__phr_Config *phrConfig)
2794 {
2795
2796    phrConfig->present = MAC_CellGroupConfig__phr_Config_PR_setup;
2797    phrConfig->choice.setup = NULLP;
2798    DU_ALLOC(phrConfig->choice.setup, sizeof(struct PHR_Config));
2799    if(!phrConfig->choice.setup)
2800    {
2801       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildPhrConfig");
2802       return RFAILED;
2803    }
2804
2805    phrConfig->choice.setup->phr_PeriodicTimer        = PHR_PERIODIC_TMR;
2806    phrConfig->choice.setup->phr_ProhibitTimer        = PHR_PROHIBHIT_TMR;
2807    phrConfig->choice.setup->phr_Tx_PowerFactorChange = PHR_PWR_FACTOR_CHANGE;
2808    phrConfig->choice.setup->multiplePHR              = false;
2809    phrConfig->choice.setup->dummy                    = false;
2810    phrConfig->choice.setup->phr_Type2OtherCell       = false;
2811    phrConfig->choice.setup->phr_ModeOtherCG          = PHR_MODE_OTHER_CG;
2812
2813    return ROK;
2814 }
2815
2816 /*******************************************************************
2817  *
2818  * @brief Builds BSR Config
2819  *
2820  * @details
2821  *
2822  *    Function : BuildBsrConfig
2823  *
2824  *    Functionality: Builds BuildBsrConfig in MacCellGroupConfig
2825  *
2826  * @params[in] BSR_Config *bsrConfig
2827  *
2828  * @return ROK     - success
2829  *         RFAILED - failure
2830  *
2831  * ****************************************************************/
2832 uint8_t BuildBsrConfig(struct BSR_Config *bsrConfig)
2833 {
2834    bsrConfig->periodicBSR_Timer = PERIODIC_BSR_TMR;
2835    bsrConfig->retxBSR_Timer     = RETX_BSR_TMR;
2836    bsrConfig->logicalChannelSR_DelayTimer = NULLP;
2837
2838    return ROK;
2839 }
2840
2841 /*******************************************************************
2842  *
2843  * @brief Builds scheduling request config
2844  *
2845  * @details
2846  *
2847  *    Function : BuildSchedulingReqConfig
2848  *
2849  *    Functionality: Builds BuildSchedulingReqConfig in MacCellGroupConfig
2850  *
2851  * @params[in] SchedulingRequestConfig *schedulingRequestConfig
2852  *
2853  * @return ROK     - success
2854  *         RFAILED - failure
2855  *
2856  * ****************************************************************/
2857 uint8_t BuildSchedulingReqConfig(struct SchedulingRequestConfig *schedulingRequestConfig)
2858 {
2859    struct SchedulingRequestConfig__schedulingRequestToAddModList *schReqList;
2860    uint8_t                     idx, elementCnt;
2861
2862    schedulingRequestConfig->schedulingRequestToAddModList = NULLP;
2863    DU_ALLOC(schedulingRequestConfig->schedulingRequestToAddModList,
2864          sizeof(struct SchedulingRequestConfig__schedulingRequestToAddModList));
2865    if(!schedulingRequestConfig->schedulingRequestToAddModList)
2866    {
2867       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSchedulingReqConfig");
2868       return RFAILED;
2869    }
2870
2871    elementCnt = 1; //ODU_VALUE_ONE;
2872    schReqList = schedulingRequestConfig->schedulingRequestToAddModList;
2873    schReqList->list.count = elementCnt;
2874    schReqList->list.size  = elementCnt * sizeof(struct SchedulingRequestToAddMod *);
2875
2876    schReqList->list.array = NULLP;
2877    DU_ALLOC(schReqList->list.array, schReqList->list.size);
2878    if(!schReqList->list.array)
2879    {
2880       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSchedulingReqConfig");
2881       return RFAILED;
2882    }
2883
2884    for(idx=0;idx<schReqList->list.count; idx++)
2885    {
2886       schReqList->list.array[idx] = NULLP;
2887       DU_ALLOC(schReqList->list.array[idx], sizeof(struct SchedulingRequestToAddMod));
2888       if(!schReqList->list.array[idx])
2889       {
2890          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSchedulingReqConfig");
2891          return RFAILED;
2892       }
2893    }
2894
2895    idx = 0;
2896    schReqList->list.array[idx]->schedulingRequestId = SCH_REQ_ID;
2897
2898    schReqList->list.array[idx]->sr_ProhibitTimer = NULLP;
2899    DU_ALLOC(schReqList->list.array[idx]->sr_ProhibitTimer, sizeof(long));
2900    if(!schReqList->list.array[idx]->sr_ProhibitTimer)
2901    {
2902       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSchedulingReqConfig");
2903       return RFAILED;
2904    }
2905    *(schReqList->list.array[idx]->sr_ProhibitTimer) = SR_PROHIBIT_TMR;
2906    schReqList->list.array[idx]->sr_TransMax = SR_TRANS_MAX;
2907    schedulingRequestConfig->schedulingRequestToReleaseList = NULLP;
2908
2909    return ROK;
2910 }
2911
2912 /*******************************************************************
2913  *
2914  * @brief Builds RLC Config
2915  *
2916  * @details
2917  *
2918  *    Function : BuildRlcConfig
2919  *
2920  *    Functionality: Builds RLC Config in BuildRlcBearerToAddModList
2921  *
2922  * @params[in] RLC_Config *rlcConfig
2923  *
2924  * @return ROK     - success
2925  *         RFAILED - failure
2926  *
2927  * ****************************************************************/
2928 uint8_t BuildRlcConfig(struct RLC_Config *rlcConfig)
2929 {
2930
2931    rlcConfig->present = RLC_Config_PR_am;
2932
2933    rlcConfig->choice.am = NULLP;
2934    DU_ALLOC(rlcConfig->choice.am, sizeof(struct RLC_Config__am));
2935    if(!rlcConfig->choice.am)
2936    {
2937       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfig");
2938       return RFAILED;
2939    }
2940
2941    /* UL */
2942    rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength = NULLP;
2943    DU_ALLOC(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
2944    if(!rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength)
2945    {
2946       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfig");
2947       return RFAILED;
2948    }
2949    *(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength) = SN_FIELD_LEN;
2950    rlcConfig->choice.am->ul_AM_RLC.t_PollRetransmit  = T_POLL_RETRANSMIT;
2951    rlcConfig->choice.am->ul_AM_RLC.pollPDU           = POLL_PDU;
2952    rlcConfig->choice.am->ul_AM_RLC.pollByte          = POLL_BYTE;
2953    rlcConfig->choice.am->ul_AM_RLC.maxRetxThreshold  = MAX_RETX_THRESHOLD;
2954
2955    /* DL */
2956    rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength = NULLP;
2957    DU_ALLOC(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
2958    if(!rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength)
2959    {
2960       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfig");
2961       return RFAILED;
2962    }
2963    *(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength) = SN_FIELD_LEN;
2964    rlcConfig->choice.am->dl_AM_RLC.t_Reassembly      = T_REASSEMBLY;
2965    rlcConfig->choice.am->dl_AM_RLC.t_StatusProhibit  = T_STATUS_PROHIBHIT;
2966
2967    return ROK;
2968 }
2969
2970 /*******************************************************************
2971  *
2972  * @brief Builds MAC LC Config
2973  *
2974  * @details
2975  *
2976  *    Function : BuildMacLCConfig
2977  *
2978  *    Functionality: Builds MAC LC Config in BuildRlcBearerToAddModList
2979  *
2980  * @params[in] struct LogicalChannelConfig macLcConfig
2981  *
2982  * @return ROK     - success
2983  *         RFAILED - failure
2984  *
2985  * ****************************************************************/
2986 uint8_t BuildMacLCConfig(struct LogicalChannelConfig *macLcConfig)
2987 {
2988
2989    macLcConfig->ul_SpecificParameters = NULLP;
2990    DU_ALLOC(macLcConfig->ul_SpecificParameters, sizeof(struct LogicalChannelConfig__ul_SpecificParameters));
2991    if(!macLcConfig->ul_SpecificParameters)
2992    {
2993       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacLCConfig");
2994       return RFAILED;
2995    }
2996
2997    macLcConfig->ul_SpecificParameters->priority = MAC_LC_PRIORITY;
2998    macLcConfig->ul_SpecificParameters->prioritisedBitRate =     PRIORTISIED_BIT_RATE;
2999    macLcConfig->ul_SpecificParameters->bucketSizeDuration =     BUCKET_SIZE_DURATION;
3000    macLcConfig->ul_SpecificParameters->allowedServingCells = NULLP;
3001    macLcConfig->ul_SpecificParameters->allowedSCS_List = NULLP;
3002    macLcConfig->ul_SpecificParameters->maxPUSCH_Duration = NULLP;
3003    macLcConfig->ul_SpecificParameters->configuredGrantType1Allowed = NULLP;
3004
3005    macLcConfig->ul_SpecificParameters->logicalChannelGroup = NULLP;
3006    DU_ALLOC(macLcConfig->ul_SpecificParameters->logicalChannelGroup,    sizeof(long));
3007    if(!macLcConfig->ul_SpecificParameters->logicalChannelGroup)
3008    {
3009       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacLCConfig");
3010       return RFAILED;
3011    }
3012    *(macLcConfig->ul_SpecificParameters->logicalChannelGroup) = LC_GRP;
3013
3014    macLcConfig->ul_SpecificParameters->schedulingRequestID = NULLP;
3015    DU_ALLOC(macLcConfig->ul_SpecificParameters->schedulingRequestID,    sizeof(SchedulingRequestId_t));
3016    if(!macLcConfig->ul_SpecificParameters->schedulingRequestID)
3017    {
3018       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacLCConfig");
3019       return RFAILED;
3020    }
3021    *(macLcConfig->ul_SpecificParameters->schedulingRequestID) = SCH_REQ_ID;
3022
3023    macLcConfig->ul_SpecificParameters->logicalChannelSR_Mask = false;
3024    macLcConfig->ul_SpecificParameters->logicalChannelSR_DelayTimerApplied = false;
3025    macLcConfig->ul_SpecificParameters->bitRateQueryProhibitTimer = NULLP;
3026
3027    return ROK;
3028 }
3029
3030 /*******************************************************************
3031  *
3032  * @brief Builds RLC Bearer to Add/Mod list
3033  *
3034  * @details
3035  *
3036  *    Function :BuildRlcBearerToAddModList
3037  *
3038  *    Functionality: Builds RLC Bearer to Add/Mod list in DuToCuRrcContainer
3039  *
3040  * @params[in] rlc_BearerToAddModList
3041  *
3042  * @return ROK     - success
3043  *         RFAILED - failure
3044  *
3045  * ****************************************************************/
3046 uint8_t BuildRlcBearerToAddModList(struct CellGroupConfigRrc__rlc_BearerToAddModList *rlcBearerList)
3047 {
3048    uint8_t                     idx, elementCnt;
3049
3050    elementCnt = 1;
3051    rlcBearerList->list.count = elementCnt;
3052    rlcBearerList->list.size  = elementCnt * sizeof(struct RLC_BearerConfig *);
3053
3054    rlcBearerList->list.array = NULLP;
3055    DU_ALLOC(rlcBearerList->list.array, rlcBearerList->list.size);
3056    if(!rlcBearerList->list.array)
3057    {
3058       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
3059       return RFAILED;
3060    }
3061
3062    for(idx=0; idx<rlcBearerList->list.count; idx++)
3063    {
3064       rlcBearerList->list.array[idx] = NULLP;
3065       DU_ALLOC(rlcBearerList->list.array[idx], sizeof(struct RLC_BearerConfig));
3066       if(!rlcBearerList->list.array[idx])
3067       {
3068          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
3069          return RFAILED;
3070       }
3071    }
3072
3073    idx = 0;
3074    rlcBearerList->list.array[idx]->logicalChannelIdentity = SRB1_LCID;
3075
3076    DU_ALLOC(rlcBearerList->list.array[idx]->servedRadioBearer, \
3077       sizeof(struct RLC_BearerConfig__servedRadioBearer));
3078    if(!rlcBearerList->list.array[idx]->servedRadioBearer)
3079    {
3080       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
3081       return RFAILED;
3082    }
3083
3084    rlcBearerList->list.array[idx]->servedRadioBearer->present = \
3085       RLC_BearerConfig__servedRadioBearer_PR_srb_Identity;
3086    rlcBearerList->list.array[idx]->servedRadioBearer->choice.srb_Identity = \
3087       SRB1_LCID;
3088
3089    rlcBearerList->list.array[idx]->reestablishRLC = NULLP;
3090    rlcBearerList->list.array[idx]->rlc_Config = NULLP;
3091    DU_ALLOC(rlcBearerList->list.array[idx]->rlc_Config, sizeof(struct RLC_Config));
3092    if(!rlcBearerList->list.array[idx]->rlc_Config)
3093    {
3094       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
3095       return RFAILED;
3096    }
3097
3098    if(BuildRlcConfig(rlcBearerList->list.array[idx]->rlc_Config) != ROK)
3099    {
3100       DU_LOG("\nERROR  -->  F1AP : BuildRlcConfig failed");
3101       return RFAILED;
3102    }
3103
3104    rlcBearerList->list.array[idx]->mac_LogicalChannelConfig = NULLP;
3105    DU_ALLOC(rlcBearerList->list.array[idx]->mac_LogicalChannelConfig, \
3106       sizeof(struct LogicalChannelConfig));
3107    if(!rlcBearerList->list.array[idx]->mac_LogicalChannelConfig)
3108    {
3109       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
3110       return RFAILED;
3111    }
3112
3113    if(BuildMacLCConfig(rlcBearerList->list.array[idx]->mac_LogicalChannelConfig) != ROK)
3114    {
3115       DU_LOG("\nERROR  -->  F1AP : BuildMacLCConfig failed");
3116       return RFAILED;
3117    }
3118
3119    return ROK;
3120 }
3121
3122 /*******************************************************************
3123  *
3124  * @brief Build Control resource set to add/modify list
3125  *
3126  * @details
3127  *
3128  *    Function : BuildControlRSetToAddModList
3129  *
3130  *    Functionality: Build Control resource set to add/modify list
3131  *
3132  * @params[in]
3133  * struct PDCCH_Config__controlResourceSetToAddModList *controlRSetList
3134  *
3135  * @return ROK     - success
3136  *         RFAILED - failure
3137  *
3138  * ****************************************************************/
3139    uint8_t BuildControlRSetToAddModList
3140 (
3141  struct PDCCH_Config__controlResourceSetToAddModList *controlRSetList
3142  )
3143 {
3144    uint8_t idx;
3145    uint8_t elementCnt;
3146    uint8_t numBytes, bitsUnused;
3147    struct ControlResourceSet *controlRSet;
3148    uint8_t freqDomainResource[FREQ_DOM_RSRC_SIZE] = {0};
3149    uint8_t coreset0EndPrb, coreset1StartPrb, coreset1NumPrb;
3150
3151
3152    elementCnt = 1;
3153    controlRSetList->list.count = elementCnt;
3154    controlRSetList->list.size = \
3155                                 elementCnt * sizeof(struct ControlResourceSet *);
3156
3157    controlRSetList->list.array = NULLP;
3158    DU_ALLOC(controlRSetList->list.array, controlRSetList->list.size);
3159    if(!controlRSetList->list.array)
3160    {
3161       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3162       return RFAILED;
3163    }
3164
3165    for(idx = 0; idx < elementCnt; idx++)
3166    {
3167       controlRSetList->list.array[idx] = NULLP;
3168       DU_ALLOC(controlRSetList->list.array[idx], sizeof(struct ControlResourceSet));
3169       if(!controlRSetList->list.array[idx])
3170       {
3171          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3172          return RFAILED;
3173       }
3174    }
3175
3176    idx=0;
3177    controlRSet = controlRSetList->list.array[idx];
3178
3179    controlRSet->controlResourceSetId = PDCCH_CTRL_RSRC_SET_ONE_ID;
3180
3181    /* size 6 bytes
3182     * 3 LSBs unsued
3183     * Bit string stored ff0000000000
3184     */
3185    numBytes = 6;
3186    bitsUnused = 3;
3187    controlRSet->frequencyDomainResources.size = numBytes * sizeof(uint8_t);
3188
3189    controlRSet->frequencyDomainResources.buf = NULLP;
3190    DU_ALLOC(controlRSet->frequencyDomainResources.buf, \
3191          controlRSet->frequencyDomainResources.size);
3192    if(!controlRSet->frequencyDomainResources.buf)
3193    {
3194       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3195       return RFAILED;
3196    }
3197
3198    memset(controlRSet->frequencyDomainResources.buf, 0, FREQ_DOM_RSRC_SIZE);
3199    coreset0EndPrb = CORESET0_END_PRB;
3200    coreset1StartPrb = coreset0EndPrb + 6;
3201    coreset1NumPrb = CORESET1_NUM_PRB;
3202    /* calculate the PRBs */
3203    freqDomRscAllocType0(((coreset1StartPrb)/6), (coreset1NumPrb/6), freqDomainResource);
3204    memcpy(controlRSet->frequencyDomainResources.buf, freqDomainResource, FREQ_DOM_RSRC_SIZE);
3205    controlRSet->frequencyDomainResources.bits_unused = bitsUnused;
3206
3207    controlRSet->duration = PDCCH_CTRL_RSRC_SET_ONE_DURATION;
3208    controlRSet->cce_REG_MappingType.present = \
3209                                               ControlResourceSet__cce_REG_MappingType_PR_nonInterleaved;
3210
3211    controlRSet->precoderGranularity = PDCCH_CTRL_RSRC_SET_ONE_PRECOD_GRANULARITY;
3212    controlRSet->tci_StatesPDCCH_ToAddList = NULLP;
3213    controlRSet->tci_StatesPDCCH_ToReleaseList = NULLP;
3214    controlRSet->tci_PresentInDCI = NULLP;
3215 #if 0
3216    uint8_t tciStateIdx;
3217
3218    DU_ALLOC(controlRset->tci_StatesPDCCH_ToAddList, \
3219          sizeof(struct ControlResourceSet__tci_StatesPDCCH_ToAddList));
3220    if(!controlRset->tci_StatesPDCCH_ToAddList)
3221    {
3222       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3223       return RFAILED;
3224    }
3225
3226    elementCnt = 1;
3227    controlRset->tci_StatesPDCCH_ToAddList->list.count = elementCnt;
3228    controlRset->tci_StatesPDCCH_ToAddList->list.size = elementCnt * sizeof(TCI_StateId_t *);
3229    DU_ALLOC(controlRset->tci_StatesPDCCH_ToAddList->list.array, \
3230          controlRset->tci_StatesPDCCH_ToAddList->list.size)
3231       if(!controlRset->tci_StatesPDCCH_ToAddList->list.array)
3232       {
3233          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3234          return RFAILED;
3235       }
3236
3237    for(tciStateIdx = 0; tciStateIdx <elementCntl; tciStateIdx++)
3238    {
3239       DU_ALLOC(controlRset->tci_StatesPDCCH_ToAddList->list.array[tciStateIdx], sizeof(TCI_StateId_t));
3240       if(!controlRset->tci_StatesPDCCH_ToAddList->list.array[tciStateIdx])
3241       {
3242          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3243          return RFAILED;
3244       }
3245    }
3246
3247    tciStateIdx = 0;
3248    /* TODO */
3249    *(controlRset->tci_StatesPDCCH_ToAddList->list.array[tciStateIdx]);
3250
3251    DU_ALLOC(controlRset->tci_PresentInDCI, sizeof(long));
3252    if(!controlRset->tci_PresentInDCI)
3253    {
3254       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3255       return RFAILED;
3256    }
3257    /* TODO */
3258    *(controlRset->tci_PresentInDCI);
3259 #endif
3260
3261    controlRSet->pdcch_DMRS_ScramblingID = NULLP;
3262    DU_ALLOC(controlRSet->pdcch_DMRS_ScramblingID, sizeof(long));
3263    if(!controlRSet->pdcch_DMRS_ScramblingID)
3264    {
3265       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3266       return RFAILED;
3267    }
3268    *(controlRSet->pdcch_DMRS_ScramblingID) = SCRAMBLING_ID;
3269
3270    return ROK;
3271 } /* End BuildControlRSetToAddModList */
3272
3273 /*******************************************************************
3274  *
3275  * @brief Build search space to add/modify list
3276  *
3277  * @details
3278  *
3279  *    Function : BuildSearchSpcToAddModList
3280  *
3281  *    Functionality: Build search space to add/modify list
3282  *
3283  * @params[in]
3284  * @return ROK     - success
3285  *         RFAILED - failure
3286  *
3287  * ****************************************************************/
3288    uint8_t BuildSearchSpcToAddModList
3289 (
3290  struct PDCCH_Config__searchSpacesToAddModList *searchSpcList
3291  )
3292 {
3293    uint8_t idx;
3294    uint8_t numBytes;
3295    uint8_t byteIdx;
3296    uint8_t bitsUnused;
3297    uint8_t elementCnt;
3298    struct SearchSpace *searchSpc;
3299
3300    elementCnt = 1;
3301    searchSpcList->list.count = elementCnt;
3302    searchSpcList->list.size = elementCnt * sizeof(struct SearchSpace *);
3303
3304    searchSpcList->list.array = NULLP;
3305    DU_ALLOC(searchSpcList->list.array, searchSpcList->list.size);
3306    if(!searchSpcList->list.array)
3307    {
3308       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3309       return RFAILED;
3310    }
3311
3312    for(idx = 0; idx < elementCnt; idx++)
3313    {
3314       searchSpcList->list.array[idx] = NULLP;
3315       DU_ALLOC(searchSpcList->list.array[idx], sizeof(struct SearchSpace));
3316       if(!searchSpcList->list.array[idx])
3317       {
3318          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3319          return RFAILED;
3320       }
3321    }
3322
3323    idx = 0;
3324    searchSpc = searchSpcList->list.array[idx];
3325
3326    searchSpc->searchSpaceId = PDCCH_SRCH_SPC_TWO_ID;
3327
3328    searchSpc->controlResourceSetId = NULLP;
3329    DU_ALLOC(searchSpc->controlResourceSetId, sizeof(ControlResourceSetId_t));
3330    if(!searchSpc->controlResourceSetId)
3331    {
3332       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3333       return RFAILED;
3334    }
3335    *(searchSpc->controlResourceSetId) = PDCCH_CTRL_RSRC_SET_ONE_ID;
3336
3337    searchSpc->monitoringSlotPeriodicityAndOffset = NULLP;
3338    DU_ALLOC(searchSpc->monitoringSlotPeriodicityAndOffset, \
3339          sizeof(struct SearchSpace__monitoringSlotPeriodicityAndOffset));
3340    if(!searchSpc->monitoringSlotPeriodicityAndOffset)
3341    {
3342       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3343       return RFAILED;
3344    }
3345    searchSpc->monitoringSlotPeriodicityAndOffset->present = \
3346                                                             SearchSpace__monitoringSlotPeriodicityAndOffset_PR_sl1;
3347
3348    searchSpc->duration = NULLP;
3349    searchSpc->monitoringSymbolsWithinSlot = NULLP;
3350    DU_ALLOC(searchSpc->monitoringSymbolsWithinSlot, sizeof(BIT_STRING_t));
3351    if(!searchSpc->monitoringSymbolsWithinSlot)
3352    {
3353       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3354       return RFAILED;
3355    }
3356
3357    /* Values taken from reference logs :
3358     * size 2 bytes
3359     * 2 LSBs unsued
3360     * Bit string stores 8000
3361     */
3362    numBytes = 2;
3363    bitsUnused = 2;
3364
3365    searchSpc->monitoringSymbolsWithinSlot->size = numBytes * sizeof(uint8_t);
3366    searchSpc->monitoringSymbolsWithinSlot->buf = NULLP;
3367    DU_ALLOC(searchSpc->monitoringSymbolsWithinSlot->buf, \
3368          searchSpc->monitoringSymbolsWithinSlot->size);
3369    if(!searchSpc->monitoringSymbolsWithinSlot->buf)
3370    {
3371       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3372       return RFAILED;
3373    }
3374
3375    byteIdx = 0;
3376    searchSpc->monitoringSymbolsWithinSlot->buf[byteIdx++] = \
3377                                                             PDCCH_SYMBOL_WITHIN_SLOT /* setting MSB to 128 i.e. 0x80 */;
3378    searchSpc->monitoringSymbolsWithinSlot->buf[byteIdx++] = 0;
3379    searchSpc->monitoringSymbolsWithinSlot->bits_unused = bitsUnused;
3380
3381    searchSpc->nrofCandidates = NULLP;
3382    DU_ALLOC(searchSpc->nrofCandidates, sizeof(struct SearchSpace__nrofCandidates));
3383    if(!searchSpc->nrofCandidates)
3384    {
3385       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3386       return RFAILED;
3387    }
3388
3389    searchSpc->nrofCandidates->aggregationLevel1 = \
3390                                                   PDCCH_SRCH_SPC_TWO_AGG_LVL1_CANDIDATE;
3391    searchSpc->nrofCandidates->aggregationLevel2 = \
3392                                                   PDCCH_SRCH_SPC_TWO_AGG_LVL2_CANDIDATE;
3393    searchSpc->nrofCandidates->aggregationLevel4 = \
3394                                                   PDCCH_SRCH_SPC_TWO_AGG_LVL4_CANDIDATE;
3395    searchSpc->nrofCandidates->aggregationLevel8 = \
3396                                                   PDCCH_SRCH_SPC_TWO_AGG_LVL8_CANDIDATE;
3397    searchSpc->nrofCandidates->aggregationLevel16 = \
3398                                                    PDCCH_SRCH_SPC_TWO_AGG_LVL16_CANDIDATE;
3399
3400    searchSpc->searchSpaceType = NULLP;
3401    DU_ALLOC(searchSpc->searchSpaceType, sizeof(struct SearchSpace__searchSpaceType));
3402    if(!searchSpc->searchSpaceType)
3403    {
3404       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3405       return RFAILED;
3406    }
3407
3408    searchSpc->searchSpaceType->present = SearchSpace__searchSpaceType_PR_ue_Specific;
3409
3410    searchSpc->searchSpaceType->choice.ue_Specific = NULLP;
3411    DU_ALLOC(searchSpc->searchSpaceType->choice.ue_Specific, \
3412          sizeof(struct SearchSpace__searchSpaceType__ue_Specific));
3413    if(!searchSpc->searchSpaceType->choice.ue_Specific)
3414    {
3415       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3416       return RFAILED;
3417    }
3418    searchSpc->searchSpaceType->choice.ue_Specific->dci_Formats = \
3419                                                                  PDCCH_SRCH_SPC_TWO_UE_SPEC_DCI_FORMAT;
3420
3421    return ROK;
3422 }/* End BuildSearchSpcToAddModList */
3423
3424 /*******************************************************************
3425  *
3426  * @brief Builds BWP DL dedicated PDCCH config
3427  *
3428  * @details
3429  *
3430  *    Function : BuildBWPDlDedPdcchCfg
3431  *
3432  *    Functionality: Builds BWP DL dedicated PDCCH config
3433  *
3434  * @params[in] struct PDCCH_Config *pdcchCfg
3435  *
3436  * @return ROK     - success
3437  *         RFAILED - failure
3438  *
3439  * ****************************************************************/
3440 uint8_t BuildBWPDlDedPdcchCfg(struct PDCCH_Config *pdcchCfg)
3441 {
3442    pdcchCfg->controlResourceSetToAddModList = NULLP;
3443    DU_ALLOC(pdcchCfg->controlResourceSetToAddModList, \
3444          sizeof(struct PDCCH_Config__controlResourceSetToAddModList));
3445    if(!pdcchCfg->controlResourceSetToAddModList)
3446    {
3447       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdcchCfg");
3448       return RFAILED;
3449    }
3450
3451    if(BuildControlRSetToAddModList(pdcchCfg->controlResourceSetToAddModList) != ROK)
3452    {
3453       return RFAILED;
3454    }
3455
3456    pdcchCfg->controlResourceSetToReleaseList = NULLP;
3457
3458    pdcchCfg->searchSpacesToAddModList = NULLP;
3459    DU_ALLOC(pdcchCfg->searchSpacesToAddModList, \
3460          sizeof(struct PDCCH_Config__searchSpacesToAddModList));
3461    if(!pdcchCfg->searchSpacesToAddModList)
3462    {
3463       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdcchCfg");
3464       return RFAILED;
3465    }
3466
3467    if(BuildSearchSpcToAddModList(pdcchCfg->searchSpacesToAddModList) != ROK)
3468    {
3469       return RFAILED;
3470    }
3471
3472    pdcchCfg->searchSpacesToReleaseList = NULLP;
3473    pdcchCfg->downlinkPreemption = NULLP;
3474    pdcchCfg->tpc_PUSCH = NULLP;
3475    pdcchCfg->tpc_PUCCH = NULLP;
3476    pdcchCfg->tpc_SRS = NULLP;
3477
3478    return ROK;
3479 }
3480
3481 /*******************************************************************
3482  *
3483  * @brief Builds DMRS DL PDSCH Mapping type A
3484  *
3485  * @details
3486  *
3487  *    Function : BuildDMRSDLPdschMapTypeA
3488  *
3489  *    Functionality: Builds DMRS DL PDSCH Mapping type A
3490  *
3491  * @params[in]
3492  * struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA *dmrsDlCfg
3493  * @return ROK     - success
3494  *         RFAILED - failure
3495  *
3496  * ****************************************************************/
3497    uint8_t BuildDMRSDLPdschMapTypeA
3498 (
3499  struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA *dmrsDlCfg
3500  )
3501 {
3502    dmrsDlCfg->present = PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA_PR_setup;
3503    dmrsDlCfg->choice.setup = NULLP;
3504    DU_ALLOC(dmrsDlCfg->choice.setup, sizeof(struct DMRS_DownlinkConfig));
3505    if(!dmrsDlCfg->choice.setup)
3506    {
3507       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
3508       return RFAILED;
3509    }
3510
3511    dmrsDlCfg->choice.setup->dmrs_Type = NULLP;
3512    dmrsDlCfg->choice.setup->dmrs_AdditionalPosition = NULLP;
3513    DU_ALLOC(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition, sizeof(long));
3514    if(!dmrsDlCfg->choice.setup->dmrs_AdditionalPosition)
3515    {
3516       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSDLPdschMapTypeA");
3517       return RFAILED;
3518    }
3519    *(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition) = DMRS_ADDITIONAL_POS;
3520
3521    dmrsDlCfg->choice.setup->maxLength = NULLP;
3522    dmrsDlCfg->choice.setup->scramblingID0 = NULLP;
3523    dmrsDlCfg->choice.setup->scramblingID1 = NULLP;
3524    dmrsDlCfg->choice.setup->phaseTrackingRS = NULLP;
3525
3526    return ROK;
3527 }
3528
3529 /*******************************************************************
3530  *
3531  * @brief Builds TCI states to add/modify list
3532  *
3533  * @details
3534  *
3535  *    Function : BuildTCIStatesToAddModList
3536  *
3537  *    Functionality:Builds TCI states to add/modify list
3538  *
3539  * @params[in]
3540  * struct PDSCH_Config__tci_StatesToAddModList *tciStatesList
3541  *
3542  * @return ROK     - success
3543  *         RFAILED - failure
3544  *
3545  * ****************************************************************/
3546 uint8_t BuildTCIStatesToAddModList(struct PDSCH_Config__tci_StatesToAddModList *tciStatesList)
3547 {
3548    return ROK;
3549 }
3550
3551 /*******************************************************************
3552  *
3553  * @brief Builds PDSCH time domain allocation list
3554  *
3555  * @details
3556  *
3557  *    Function : BuildPdschTimeDomAllocList
3558  *
3559  *    Functionality: Builds PDSCH time domain allocation list
3560  *
3561  * @params[in]
3562  * struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList
3563  *
3564  * @return ROK     - success
3565  *         RFAILED - failure
3566  *
3567  * ****************************************************************/
3568    uint8_t BuildPdschTimeDomAllocList
3569 (
3570  struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList
3571  )
3572 {
3573    uint8_t idx;
3574    uint8_t elementCnt;
3575    struct PDSCH_TimeDomainResourceAllocation *timeDomAlloc;
3576
3577    timeDomAllocList->present = \
3578                                PDSCH_Config__pdsch_TimeDomainAllocationList_PR_setup;
3579
3580    timeDomAllocList->choice.setup = NULLP;
3581    DU_ALLOC(timeDomAllocList->choice.setup, \
3582          sizeof(struct PDSCH_TimeDomainResourceAllocationList));
3583    if(!timeDomAllocList->choice.setup)
3584    {
3585       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
3586       return RFAILED;
3587    }
3588
3589    elementCnt = 1;
3590    timeDomAllocList->choice.setup->list.count = elementCnt;
3591    timeDomAllocList->choice.setup->list.size = \
3592                                                elementCnt * sizeof(struct PDSCH_TimeDomainResourceAllocation *);
3593
3594    timeDomAllocList->choice.setup->list.array = NULLP;
3595    DU_ALLOC(timeDomAllocList->choice.setup->list.array, \
3596          timeDomAllocList->choice.setup->list.size);
3597    if(!timeDomAllocList->choice.setup->list.array)
3598    {
3599       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
3600       return RFAILED;
3601    }
3602
3603    for(idx = 0; idx < elementCnt; idx++)
3604    {
3605       timeDomAllocList->choice.setup->list.array[idx] = NULLP;
3606       DU_ALLOC(timeDomAllocList->choice.setup->list.array[idx], \
3607             sizeof(struct PDSCH_TimeDomainResourceAllocation));
3608       if(!timeDomAllocList->choice.setup->list.array[idx])
3609       {
3610          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
3611          return RFAILED;
3612       }
3613    }
3614
3615    idx = 0;
3616    timeDomAlloc = timeDomAllocList->choice.setup->list.array[idx];
3617
3618    timeDomAlloc->k0 = NULLP;
3619    timeDomAlloc->mappingType = PDSCH_MAPPING_TYPE_A;
3620    timeDomAlloc->startSymbolAndLength = \
3621                                         calcSliv(PDSCH_START_SYMBOL, PDSCH_LENGTH_SYMBOL);
3622
3623    return ROK;
3624 }
3625
3626 /*******************************************************************
3627  *
3628  * @brief Builds PDSCH PRB Bundling type
3629  *
3630  * @details
3631  *
3632  *    Function : BuildPdschPrbBundlingType
3633  *
3634  *    Functionality: Builds PDSCH PRB Bundling type
3635  *
3636  * @params[in]
3637  * struct PDSCH_Config__prb_BundlingType *prbBndlType
3638  *
3639  * @return ROK     - success
3640  *         RFAILED - failure
3641  *
3642  * ****************************************************************/
3643    uint8_t BuildPdschPrbBundlingType
3644 (
3645  struct PDSCH_Config__prb_BundlingType *prbBndlType
3646  )
3647 {
3648    prbBndlType->present = PDSCH_Config__prb_BundlingType_PR_staticBundling;
3649
3650    prbBndlType->choice.staticBundling = NULLP;
3651    DU_ALLOC(prbBndlType->choice.staticBundling, \
3652          sizeof(struct PDSCH_Config__prb_BundlingType__staticBundling));
3653    if(!prbBndlType->choice.staticBundling)
3654    {
3655       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschPrbBundlingType");
3656       return RFAILED;
3657    }
3658    prbBndlType->choice.staticBundling->bundleSize = NULLP;
3659
3660    return ROK;
3661 }
3662
3663 /*******************************************************************
3664  *
3665  * @brief Builds BWP DL dedicated PDSCH config
3666  *
3667  * @details
3668  *
3669  *    Function : BuildBWPDlDedPdschCfg
3670  *
3671  *    Functionality: Builds BWP DL dedicated PDSCH config
3672  *
3673  * @params[in] struct PDSCH_Config *pdschCfg
3674  *
3675  * @return ROK     - success
3676  *         RFAILED - failure
3677  *
3678  * ****************************************************************/
3679 uint8_t BuildBWPDlDedPdschCfg(struct PDSCH_Config *pdschCfg)
3680 {
3681    pdschCfg->dataScramblingIdentityPDSCH = NULLP;
3682
3683    pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA = NULLP;
3684    DU_ALLOC(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA, \
3685          sizeof(struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA));
3686    if(!pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA)
3687    {
3688       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
3689       return RFAILED;
3690    }
3691
3692    if(BuildDMRSDLPdschMapTypeA(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA) != ROK)
3693    {
3694       return RFAILED;
3695    }
3696
3697    pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeB = NULLP;
3698    pdschCfg->tci_StatesToAddModList = NULLP;
3699    pdschCfg->tci_StatesToReleaseList = NULLP;
3700    pdschCfg->vrb_ToPRB_Interleaver = NULLP;
3701 #if 0
3702    DU_ALLOC(pdschCfg->tci_StatesToAddModList, sizeof(struct PDSCH_Config__tci_StatesToAddModList));
3703    if(!pdschCfg->tci_StatesToAddModList)
3704    {
3705       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
3706       return RFAILED;
3707    }
3708    if(BuildTCIStatesToAddModList(pdschCfg->tci_StatesToAddModList) != ROK)
3709    {
3710       return RFAILED;
3711    }
3712 #endif
3713
3714    pdschCfg->resourceAllocation = RES_ALLOC_TYPE;
3715
3716    pdschCfg->pdsch_TimeDomainAllocationList = NULLP;
3717    DU_ALLOC(pdschCfg->pdsch_TimeDomainAllocationList, \
3718          sizeof(struct PDSCH_Config__pdsch_TimeDomainAllocationList));
3719    if(!pdschCfg->pdsch_TimeDomainAllocationList)
3720    {
3721       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
3722       return RFAILED;
3723    }
3724
3725    if(BuildPdschTimeDomAllocList(pdschCfg->pdsch_TimeDomainAllocationList) != ROK)
3726    {
3727       return RFAILED;
3728    }
3729
3730    pdschCfg->pdsch_AggregationFactor = NULLP;
3731    pdschCfg->rateMatchPatternToAddModList = NULLP;
3732    pdschCfg->rateMatchPatternToReleaseList = NULLP;
3733    pdschCfg->rateMatchPatternGroup1 = NULLP;
3734    pdschCfg->rateMatchPatternGroup2 = NULLP;
3735    pdschCfg->rbg_Size = PDSCH_RBG_SIZE;
3736    pdschCfg->mcs_Table = NULLP;
3737
3738    pdschCfg->maxNrofCodeWordsScheduledByDCI = NULLP;
3739    DU_ALLOC(pdschCfg->maxNrofCodeWordsScheduledByDCI, sizeof(long));
3740    if(!pdschCfg->maxNrofCodeWordsScheduledByDCI)
3741    {
3742       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
3743       return RFAILED;
3744    }
3745    *(pdschCfg->maxNrofCodeWordsScheduledByDCI) = PDSCH_MAX_CODEWORD_SCH_BY_DCI;
3746
3747    if(BuildPdschPrbBundlingType(&pdschCfg->prb_BundlingType) != ROK)
3748    {
3749       return RFAILED;
3750    }
3751
3752    pdschCfg->zp_CSI_RS_ResourceToAddModList = NULLP;
3753    pdschCfg->zp_CSI_RS_ResourceToReleaseList = NULLP;
3754    pdschCfg->aperiodic_ZP_CSI_RS_ResourceSetsToAddModList = NULLP;
3755    pdschCfg->aperiodic_ZP_CSI_RS_ResourceSetsToReleaseList = NULLP;
3756    pdschCfg->sp_ZP_CSI_RS_ResourceSetsToAddModList = NULLP;
3757    pdschCfg->sp_ZP_CSI_RS_ResourceSetsToReleaseList = NULLP;
3758    pdschCfg->p_ZP_CSI_RS_ResourceSet = NULLP;
3759
3760    return ROK;
3761 }
3762
3763 /*******************************************************************
3764  *
3765  * @brief Builds intitial DL BWP
3766  * @details
3767  *
3768  *    Function : BuildInitialDlBWP
3769  *
3770  *    Functionality: Builds intitial DL BWP in spCellCfgDed
3771  *
3772  * @params[in] BWP_DownlinkDedicated_t *dlBwp
3773  *
3774  * @return ROK     - success
3775  *         RFAILED - failure
3776  *
3777  * ****************************************************************/
3778 uint8_t BuildInitialDlBWP(BWP_DownlinkDedicated_t *dlBwp)
3779 {
3780    dlBwp->pdcch_Config = NULLP;
3781    DU_ALLOC(dlBwp->pdcch_Config, sizeof(struct BWP_DownlinkDedicated__pdcch_Config));
3782    if(!dlBwp->pdcch_Config)
3783    {
3784       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failure in BuildInitialDlBWP");
3785       return RFAILED;
3786    }
3787    dlBwp->pdcch_Config->present = BWP_DownlinkDedicated__pdcch_Config_PR_setup;
3788
3789    dlBwp->pdcch_Config->choice.setup = NULLP;
3790    DU_ALLOC(dlBwp->pdcch_Config->choice.setup, sizeof(struct PDCCH_Config));
3791    if(!dlBwp->pdcch_Config->choice.setup)
3792    {
3793       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failure in BuildInitialDlBWP");
3794       return RFAILED;
3795    }
3796    if(BuildBWPDlDedPdcchCfg(dlBwp->pdcch_Config->choice.setup) != ROK)
3797    {
3798       return RFAILED;
3799    }
3800
3801    dlBwp->pdsch_Config = NULLP;
3802    DU_ALLOC(dlBwp->pdsch_Config, sizeof(struct BWP_DownlinkDedicated__pdsch_Config));
3803    if(!dlBwp->pdsch_Config)
3804    {
3805       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failure in BuildInitialDlBWP");
3806       return RFAILED;
3807    }
3808    dlBwp->pdsch_Config->present = BWP_DownlinkDedicated__pdsch_Config_PR_setup;
3809
3810    dlBwp->pdsch_Config->choice.setup = NULLP;
3811    DU_ALLOC(dlBwp->pdsch_Config->choice.setup, sizeof(struct PDSCH_Config));
3812    if(!dlBwp->pdsch_Config->choice.setup)
3813    {
3814       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failure in BuildInitialDlBWP");
3815       return RFAILED;
3816    }
3817
3818    if(BuildBWPDlDedPdschCfg(dlBwp->pdsch_Config->choice.setup) != ROK)
3819    {
3820       return RFAILED;
3821    }
3822
3823    dlBwp->sps_Config = NULLP;
3824    dlBwp->radioLinkMonitoringConfig = NULLP;
3825    return ROK;
3826 }
3827
3828 /*******************************************************************
3829  *
3830  * @brief Builds DMRS UL Pusch Mapping type A
3831  *
3832  * @details
3833  *
3834  *    Function : BuildDMRSULPuschMapTypeA
3835  *
3836  *    Functionality: Builds DMRS UL Pusch Mapping type A
3837  *
3838  * @params[in]
3839  *    struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA *dmrsUlCfg
3840  * @return ROK     - success
3841  *         RFAILED - failure
3842  *
3843  * ****************************************************************/
3844    uint8_t BuildDMRSULPuschMapTypeA
3845 (
3846  struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA *dmrsUlCfg
3847  )
3848 {
3849    dmrsUlCfg->present = PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA_PR_setup;
3850    dmrsUlCfg->choice.setup= NULLP;
3851    DU_ALLOC(dmrsUlCfg->choice.setup, sizeof(DMRS_UplinkConfig_t));
3852    if(!dmrsUlCfg->choice.setup)
3853    {
3854       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
3855       return RFAILED;
3856    }
3857
3858    dmrsUlCfg->choice.setup->dmrs_Type = NULLP;
3859    dmrsUlCfg->choice.setup->dmrs_AdditionalPosition = NULLP;
3860    DU_ALLOC(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition, sizeof(long));
3861    if(!dmrsUlCfg->choice.setup->dmrs_AdditionalPosition)
3862    {
3863       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
3864       return RFAILED;
3865    }
3866    *(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition) = DMRS_ADDITIONAL_POS;
3867
3868    dmrsUlCfg->choice.setup->phaseTrackingRS = NULLP;
3869    dmrsUlCfg->choice.setup->maxLength = NULLP;
3870    dmrsUlCfg->choice.setup->transformPrecodingDisabled = NULLP;
3871    DU_ALLOC(dmrsUlCfg->choice.setup->transformPrecodingDisabled, \
3872          sizeof(struct DMRS_UplinkConfig__transformPrecodingDisabled));
3873    if(!dmrsUlCfg->choice.setup->transformPrecodingDisabled)
3874    {
3875       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
3876       return RFAILED;
3877    }
3878
3879    dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0 = NULLP;
3880    DU_ALLOC(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0,\
3881          sizeof(long));
3882    if(!dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0)
3883    {
3884       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
3885       return RFAILED;
3886    }
3887    *(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0) = SCRAMBLING_ID;
3888
3889    dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID1 = NULLP;
3890    dmrsUlCfg->choice.setup->transformPrecodingEnabled = NULLP;
3891    return ROK;
3892 }
3893
3894 /*******************************************************************
3895  *
3896  * @brief Build PUSCH time domain allocation list
3897  *
3898  * @details
3899  *
3900  *    Function : BuildPuschTimeDomAllocList
3901  *
3902  *    Functionality: Build PUSCH time domain allocation list
3903  *
3904  * @params[in]
3905  * struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList
3906  *
3907  * @return ROK     - success
3908  *         RFAILED - failure
3909  *
3910  * ****************************************************************/
3911    uint8_t BuildPuschTimeDomAllocList
3912 (
3913  struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList
3914  )
3915 {
3916    uint8_t idx;
3917    uint8_t elementCnt;
3918    PUSCH_TimeDomainResourceAllocation_t  *timeDomAlloc;
3919
3920    timeDomAllocList->present = PUSCH_Config__pusch_TimeDomainAllocationList_PR_setup;
3921    timeDomAllocList->choice.setup = NULLP;
3922    DU_ALLOC(timeDomAllocList->choice.setup, \
3923          sizeof(struct PUSCH_TimeDomainResourceAllocationList));
3924    if(!timeDomAllocList->choice.setup)
3925    {
3926       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
3927       return RFAILED;
3928    }
3929
3930    elementCnt = 1;
3931    timeDomAllocList->choice.setup->list.count = elementCnt;
3932    timeDomAllocList->choice.setup->list.size = \
3933                                                elementCnt * sizeof(PUSCH_TimeDomainResourceAllocation_t *);
3934    timeDomAllocList->choice.setup->list.array = NULLP;
3935    DU_ALLOC(timeDomAllocList->choice.setup->list.array, \
3936          timeDomAllocList->choice.setup->list.size);
3937    if(!timeDomAllocList->choice.setup->list.array)
3938    {
3939       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
3940       return RFAILED;
3941    }
3942
3943    for(idx = 0; idx < elementCnt; idx++)
3944    {
3945       timeDomAllocList->choice.setup->list.array[idx] = NULLP;
3946       DU_ALLOC(timeDomAllocList->choice.setup->list.array[idx],\
3947             sizeof(PUSCH_TimeDomainResourceAllocation_t));
3948       if(!timeDomAllocList->choice.setup->list.array[idx])
3949       {
3950          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
3951          return RFAILED;
3952       }
3953    }
3954
3955    idx = 0;
3956    timeDomAlloc = timeDomAllocList->choice.setup->list.array[idx];
3957    DU_ALLOC(timeDomAlloc->k2, sizeof(long));
3958    if(!timeDomAlloc->k2)
3959    {
3960       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
3961       return RFAILED;
3962    }
3963    *(timeDomAlloc->k2) = PUSCH_K2;
3964    timeDomAlloc->mappingType = PUSCH_MAPPING_TYPE_A;
3965    timeDomAlloc->startSymbolAndLength = calcSliv(PUSCH_START_SYMBOL, PUSCH_LENGTH_SYMBOL);
3966    return ROK;
3967 }
3968
3969 /*******************************************************************
3970  *
3971  * @brief Builds BWP UL dedicated PUSCH Config
3972  *
3973  * @details
3974  *
3975  *    Function : BuildBWPUlDedPuschCfg
3976  *
3977  *    Functionality:
3978  *      Builds BWP UL dedicated PUSCH Config
3979  *
3980  * @params[in] : PUSCH_Config_t *puschCfg
3981  *
3982  * @return ROK     - success
3983  *         RFAILED - failure
3984  *
3985  * ****************************************************************/
3986 uint8_t BuildBWPUlDedPuschCfg(PUSCH_Config_t *puschCfg)
3987 {
3988    puschCfg->dataScramblingIdentityPUSCH = NULLP;
3989    DU_ALLOC(puschCfg->dataScramblingIdentityPUSCH, sizeof(long));
3990    if(!puschCfg->dataScramblingIdentityPUSCH)
3991    {
3992       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
3993       return RFAILED;
3994    }
3995    *(puschCfg->dataScramblingIdentityPUSCH) = SCRAMBLING_ID;
3996
3997    puschCfg->txConfig = NULLP;
3998    puschCfg->dmrs_UplinkForPUSCH_MappingTypeA = NULLP;
3999    DU_ALLOC(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA, \
4000          sizeof(struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA));
4001    if(!puschCfg->dmrs_UplinkForPUSCH_MappingTypeA)
4002    {
4003       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
4004       return RFAILED;
4005    }
4006
4007    if(BuildDMRSULPuschMapTypeA(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA) != ROK)
4008    {
4009       return RFAILED;
4010    }
4011
4012    puschCfg->dmrs_UplinkForPUSCH_MappingTypeB = NULLP;
4013    puschCfg->pusch_PowerControl = NULLP;
4014    puschCfg->frequencyHopping = NULLP;
4015    puschCfg->frequencyHoppingOffsetLists = NULLP;
4016    puschCfg->resourceAllocation = RES_ALLOC_TYPE;
4017
4018    puschCfg->pusch_TimeDomainAllocationList = NULLP;
4019    DU_ALLOC(puschCfg->pusch_TimeDomainAllocationList, \
4020          sizeof(struct PUSCH_Config__pusch_TimeDomainAllocationList));
4021    if(!puschCfg->pusch_TimeDomainAllocationList)
4022    {
4023       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
4024       return RFAILED;
4025    }
4026
4027    if(BuildPuschTimeDomAllocList(puschCfg->pusch_TimeDomainAllocationList) != ROK)
4028    {
4029       return RFAILED;
4030    }
4031
4032    puschCfg->pusch_AggregationFactor = NULLP;
4033    puschCfg->mcs_Table = NULLP;
4034    puschCfg->mcs_TableTransformPrecoder = NULLP;
4035    puschCfg->transformPrecoder = NULLP;
4036    DU_ALLOC(puschCfg->transformPrecoder, sizeof(long));
4037    if(!puschCfg->transformPrecoder)
4038    {
4039       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
4040       return RFAILED;
4041    }
4042    *(puschCfg->transformPrecoder) = PUSCH_TRANSFORM_PRECODER;
4043
4044    puschCfg->codebookSubset = NULLP;
4045    puschCfg->maxRank = NULLP;
4046    puschCfg->rbg_Size = NULLP;
4047    puschCfg->uci_OnPUSCH = NULLP;
4048    puschCfg->tp_pi2BPSK = NULLP;
4049
4050    return ROK;
4051 }
4052
4053 /*******************************************************************
4054  *
4055  * @brief Fills SRS resource to add/modify list
4056  *
4057  * @details
4058  *
4059  *    Function : BuildSrsRsrcAddModList
4060  *
4061  *    Functionality: Fills SRS resource to add/modify list
4062  *
4063  * @params[in]
4064  * @return ROK     - success
4065  *         RFAILED - failure
4066  *
4067  * ****************************************************************/
4068 uint8_t BuildSrsRsrcAddModList(struct SRS_Config__srs_ResourceToAddModList *resourceList)
4069 {
4070    uint8_t   elementCnt;
4071    uint8_t   rsrcIdx;
4072
4073    elementCnt = 1;
4074    resourceList->list.count = elementCnt;
4075    resourceList->list.size = elementCnt * sizeof(SRS_Resource_t *);
4076    resourceList->list.array = NULLP;
4077    DU_ALLOC(resourceList->list.array, resourceList->list.size);
4078    if(!resourceList->list.array)
4079    {
4080       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcAddModList");
4081       return RFAILED;
4082    }
4083
4084    for(rsrcIdx = 0; rsrcIdx < resourceList->list.count; rsrcIdx++)
4085    {
4086       DU_ALLOC(resourceList->list.array[rsrcIdx], sizeof(SRS_Resource_t));
4087       if(!resourceList->list.array[rsrcIdx])
4088       {
4089          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcAddModList");
4090          return RFAILED;
4091       }
4092    }
4093
4094    rsrcIdx = 0;
4095    resourceList->list.array[rsrcIdx]->srs_ResourceId = SRS_RSRC_ID;
4096    resourceList->list.array[rsrcIdx]->nrofSRS_Ports = SRS_Resource__nrofSRS_Ports_port1;
4097    resourceList->list.array[rsrcIdx]->transmissionComb.present = SRS_Resource__transmissionComb_PR_n2;
4098
4099    resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2 = NULLP;
4100    DU_ALLOC(resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2, \
4101          sizeof(struct SRS_Resource__transmissionComb__n2));
4102    if(!resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2)
4103    {
4104       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcAddModList");
4105       return RFAILED;
4106    }
4107    resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2->combOffset_n2\
4108       = SRS_COMB_OFFSET_N2;
4109    resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2->cyclicShift_n2\
4110       = SRS_CYCLIC_SHIFT_N2;
4111
4112    resourceList->list.array[rsrcIdx]->resourceMapping.startPosition = \
4113                                                                       PUSCH_START_SYMBOL;
4114    resourceList->list.array[rsrcIdx]->resourceMapping.nrofSymbols =  \
4115                                                                      SRS_Resource__resourceMapping__nrofSymbols_n1;
4116    resourceList->list.array[rsrcIdx]->resourceMapping.repetitionFactor = \
4117                                                                          SRS_Resource__resourceMapping__repetitionFactor_n1;
4118
4119    resourceList->list.array[rsrcIdx]->freqDomainPosition = SRS_FREQ_DOM_POS;
4120    resourceList->list.array[rsrcIdx]->freqDomainShift = SRS_FREQ_DOM_SHIFT;
4121    resourceList->list.array[rsrcIdx]->freqHopping.c_SRS = C_SRS;
4122    resourceList->list.array[rsrcIdx]->freqHopping.b_SRS = B_SRS;
4123    resourceList->list.array[rsrcIdx]->freqHopping.b_hop = B_HOP;
4124    resourceList->list.array[rsrcIdx]->groupOrSequenceHopping = \
4125                                                                SRS_Resource__groupOrSequenceHopping_neither;
4126
4127    /* Setting resource type to aperiodic for intergration purposes */
4128    resourceList->list.array[rsrcIdx]->resourceType.present = \
4129                                                              SRS_Resource__resourceType_PR_aperiodic;
4130    resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic = NULLP;
4131    DU_ALLOC(resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic,
4132          sizeof(struct SRS_Resource__resourceType__aperiodic));
4133    if(!resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic)
4134    {
4135       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcAddModList");
4136       return RFAILED;
4137    }
4138    resourceList->list.array[rsrcIdx]->sequenceId = SRS_SEQ_ID;
4139
4140    return ROK;
4141 }
4142
4143 /*******************************************************************
4144  *
4145  * @brief Build SRS resource set Add/mod list
4146  *
4147  * @details
4148  *
4149  *    Function : BuildSrsRsrcSetAddModList
4150  *
4151  *    Functionality: Build SRS resource set Add/mod list
4152  *
4153  * @params[in]
4154  * @return ROK     - success
4155  *         RFAILED - failure
4156  *
4157  * ****************************************************************/
4158    uint8_t BuildSrsRsrcSetAddModList
4159 (
4160  struct SRS_Config__srs_ResourceSetToAddModList *rsrcSetList
4161  )
4162 {
4163    uint8_t  elementCnt;
4164    uint8_t  rSetIdx;
4165    uint8_t  rsrcIdx;
4166    struct SRS_ResourceSet__srs_ResourceIdList *rsrcIdList;
4167
4168    elementCnt = 1;
4169    rsrcSetList->list.count = elementCnt;
4170    rsrcSetList->list.size = elementCnt * sizeof(SRS_ResourceSet_t *);
4171    rsrcSetList->list.array = NULLP;
4172    DU_ALLOC(rsrcSetList->list.array, rsrcSetList->list.size);
4173    if(!rsrcSetList->list.array)
4174    {
4175       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
4176       return RFAILED;
4177    }
4178
4179    for(rSetIdx = 0; rSetIdx < rsrcSetList->list.count; rSetIdx++)
4180    {
4181       DU_ALLOC(rsrcSetList->list.array[rSetIdx], sizeof(SRS_ResourceSet_t));
4182       if(!rsrcSetList->list.array[rSetIdx])
4183       {
4184          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
4185          return RFAILED;
4186       }
4187    }
4188
4189    rSetIdx = 0;
4190    rsrcSetList->list.array[rSetIdx]->srs_ResourceSetId = SRS_RSET_ID;
4191
4192    /* Fill Resource Id list in resource set */
4193    rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList = NULLP;
4194    DU_ALLOC(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList,\
4195          sizeof(struct SRS_ResourceSet__srs_ResourceIdList));
4196    if(!rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList)
4197    {
4198       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
4199       return RFAILED;
4200    }
4201
4202    elementCnt = 1;
4203    rsrcIdList = rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList;
4204    rsrcIdList->list.count = elementCnt;
4205    rsrcIdList->list.size = elementCnt * sizeof(SRS_ResourceId_t *);
4206    rsrcIdList->list.array = NULLP;
4207    DU_ALLOC(rsrcIdList->list.array, rsrcIdList->list.size);
4208    if(!rsrcIdList->list.array)
4209    {
4210       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
4211       return RFAILED;
4212    }
4213
4214    for(rsrcIdx = 0; rsrcIdx < rsrcIdList->list.count; rsrcIdx++)
4215    {
4216       DU_ALLOC(rsrcIdList->list.array[rsrcIdx], sizeof(SRS_ResourceId_t));
4217       if(!rsrcIdList->list.array[rsrcIdx])
4218       {
4219          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
4220          return RFAILED;
4221       }
4222    }
4223
4224    rsrcIdx = 0;
4225    *rsrcIdList->list.array[rsrcIdx] = SRS_RSRC_ID;
4226
4227    /* Fill resource type */
4228    rsrcSetList->list.array[rSetIdx]->resourceType.present = \
4229                                                             SRS_ResourceSet__resourceType_PR_aperiodic;
4230
4231    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic = NULLP;
4232    DU_ALLOC(rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic, \
4233          sizeof(struct SRS_ResourceSet__resourceType__aperiodic));
4234    if(!rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic)
4235    {
4236       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
4237       return RFAILED;
4238    }
4239    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic->aperiodicSRS_ResourceTrigger \
4240       = APERIODIC_SRS_RESRC_TRIGGER;
4241
4242    /* TODO : Fill values for below IEs as expected by Viavi */
4243    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic->csi_RS = NULLP;
4244    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic->slotOffset = NULLP;
4245
4246
4247    rsrcSetList->list.array[rSetIdx]->usage = SRS_ResourceSet__usage_codebook;
4248    rsrcSetList->list.array[rSetIdx]->alpha = NULLP;
4249    rsrcSetList->list.array[rSetIdx]->p0 = NULLP;
4250    rsrcSetList->list.array[rSetIdx]->pathlossReferenceRS = NULLP;
4251    rsrcSetList->list.array[rSetIdx]->srs_PowerControlAdjustmentStates = NULLP;
4252
4253    return ROK;
4254 }
4255
4256 /*******************************************************************
4257  *
4258  * @brief Builds BWP UL dedicated SRS Config
4259  *
4260  * @details
4261  *
4262  *    Function : BuildBWPUlDedSrsCfg
4263  *
4264  *    Functionality: Builds BWP UL dedicated SRS Config
4265  *
4266  * @params[in] SRS Config
4267  * @return ROK     - success
4268  *         RFAILED - failure
4269  *
4270  * ****************************************************************/
4271 uint8_t BuildBWPUlDedSrsCfg(SRS_Config_t *srsCfg)
4272 {
4273    srsCfg->srs_ResourceSetToReleaseList = NULLP;
4274    srsCfg->srs_ResourceSetToAddModList = NULLP;
4275    DU_ALLOC(srsCfg->srs_ResourceSetToAddModList, \
4276          sizeof(struct SRS_Config__srs_ResourceSetToAddModList));
4277    if(!srsCfg->srs_ResourceSetToAddModList)
4278    {
4279       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedSrsCfg");
4280       return RFAILED;
4281    }
4282    if(BuildSrsRsrcSetAddModList(srsCfg->srs_ResourceSetToAddModList) != ROK)
4283    {
4284       return RFAILED;
4285    }
4286
4287    srsCfg->srs_ResourceToReleaseList = NULLP;
4288
4289    /* Resource to Add/Modify list */
4290    srsCfg->srs_ResourceToAddModList = NULLP;
4291    DU_ALLOC(srsCfg->srs_ResourceToAddModList, \
4292          sizeof(struct SRS_Config__srs_ResourceToAddModList));
4293    if(!srsCfg->srs_ResourceToAddModList)
4294    {
4295       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedSrsCfg");
4296       return RFAILED;
4297    }
4298
4299    if(BuildSrsRsrcAddModList(srsCfg->srs_ResourceToAddModList) != ROK)
4300    {
4301       return RFAILED;
4302    }
4303
4304    srsCfg->tpc_Accumulation = NULLP;
4305
4306    return ROK;
4307 }
4308
4309
4310
4311 /*******************************************************************
4312  *
4313  * @brief Builds Pusch Serving cell Config
4314  *
4315  * @details
4316  *
4317  *    Function : BuildPuschSrvCellCfg
4318  *
4319  *    Functionality: Builds Pusch Serving cell Config
4320  *
4321  * @params[in] struct UplinkConfig__pusch_ServingCellConfig *puschCfg
4322  *
4323  * @return ROK     - success
4324  *         RFAILED - failure
4325  *
4326  * ****************************************************************/
4327 uint8_t BuildPuschSrvCellCfg(struct UplinkConfig__pusch_ServingCellConfig *puschCfg)
4328 {
4329    puschCfg->present = UplinkConfig__pusch_ServingCellConfig_PR_setup;
4330    puschCfg->choice.setup = NULLP;
4331    DU_ALLOC(puschCfg->choice.setup, sizeof(struct PUSCH_ServingCellConfig));
4332    if(!puschCfg->choice.setup)
4333    {
4334       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
4335       return RFAILED;
4336    }
4337
4338    puschCfg->choice.setup->codeBlockGroupTransmission = NULLP;
4339    puschCfg->choice.setup->rateMatching = NULLP;
4340    puschCfg->choice.setup->xOverhead = NULLP;
4341    puschCfg->choice.setup->ext1 = NULLP;
4342    DU_ALLOC(puschCfg->choice.setup->ext1, sizeof(struct PUSCH_ServingCellConfig__ext1));
4343    if(!puschCfg->choice.setup->ext1)
4344    {
4345       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
4346       return RFAILED;
4347    }
4348
4349    puschCfg->choice.setup->ext1->maxMIMO_Layers = NULLP;
4350    DU_ALLOC(puschCfg->choice.setup->ext1->maxMIMO_Layers, sizeof(long));
4351    if(!puschCfg->choice.setup->ext1->maxMIMO_Layers)
4352    {
4353       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
4354       return RFAILED;
4355    }
4356    *(puschCfg->choice.setup->ext1->maxMIMO_Layers) = PUSCH_MAX_MIMO_LAYERS;
4357
4358    puschCfg->choice.setup->ext1->processingType2Enabled= NULLP;
4359    DU_ALLOC(puschCfg->choice.setup->ext1->processingType2Enabled,sizeof(BOOLEAN_t));
4360    if(!puschCfg->choice.setup->ext1->processingType2Enabled)
4361    {
4362       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
4363       return RFAILED;
4364    }
4365    *(puschCfg->choice.setup->ext1->processingType2Enabled) = PUSCH_PROCESS_TYPE2_ENABLED;
4366    return ROK;
4367 }
4368
4369 /*******************************************************************
4370  *
4371  * @brief Builds inital UL BWP
4372  *
4373  * @details
4374  *
4375  *    Function : BuildInitialUlBWP
4376  *
4377  *    Functionality: Builds initial UL BWP
4378  *
4379  * @params[in] BWP_UplinkDedicated_t *ulBwp
4380  * @return ROK     - success
4381  *         RFAILED - failure
4382  *
4383  * ****************************************************************/
4384 uint8_t BuildInitialUlBWP(BWP_UplinkDedicated_t *ulBwp)
4385 {
4386    ulBwp->pucch_Config = NULLP;
4387
4388    /* Fill BWP UL dedicated PUSCH config */
4389    ulBwp->pusch_Config = NULLP;
4390    DU_ALLOC(ulBwp->pusch_Config, sizeof(struct BWP_UplinkDedicated__pusch_Config));
4391    if(!ulBwp->pusch_Config)
4392    {
4393       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
4394       return RFAILED;
4395    }
4396
4397    ulBwp->pusch_Config->present = BWP_UplinkDedicated__pusch_Config_PR_setup;
4398    ulBwp->pusch_Config->choice.setup = NULLP;
4399    DU_ALLOC(ulBwp->pusch_Config->choice.setup, sizeof(PUSCH_Config_t));
4400    if(!ulBwp->pusch_Config->choice.setup)
4401    {
4402       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
4403       return RFAILED;
4404    }
4405
4406    if(BuildBWPUlDedPuschCfg(ulBwp->pusch_Config->choice.setup) != ROK)
4407    {
4408       return RFAILED;
4409    }
4410
4411    ulBwp->configuredGrantConfig = NULLP;
4412
4413    /* Fill BPW UL dedicated SRS config */
4414    ulBwp->srs_Config = NULLP;
4415    DU_ALLOC(ulBwp->srs_Config, sizeof(struct BWP_UplinkDedicated__srs_Config));
4416    if(!ulBwp->srs_Config)
4417    {
4418       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
4419       return RFAILED;
4420    }
4421
4422    ulBwp->srs_Config->present = BWP_UplinkDedicated__srs_Config_PR_setup;
4423    ulBwp->srs_Config->choice.setup = NULLP;
4424    DU_ALLOC(ulBwp->srs_Config->choice.setup, sizeof(SRS_Config_t));
4425    if(!ulBwp->srs_Config->choice.setup)
4426    {
4427       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
4428       return RFAILED;
4429    }
4430
4431    if(BuildBWPUlDedSrsCfg(ulBwp->srs_Config->choice.setup) != ROK)
4432    {
4433       return RFAILED;
4434    }
4435
4436    ulBwp->beamFailureRecoveryConfig = NULLP;
4437
4438    return ROK;
4439 }
4440
4441 /*******************************************************************
4442  *
4443  * @brief Builds UL config
4444  * @details
4445  *
4446  *    Function : BuildUlCfg
4447  *
4448  *    Functionality: Builds UL config in spCellCfgDed
4449  *
4450  * @params[in] UplinkConfig_t *ulCfg
4451  *
4452  * @return ROK     - success
4453  *         RFAILED - failure
4454  *
4455  * ****************************************************************/
4456 uint8_t BuildUlCfg(UplinkConfig_t *ulCfg)
4457 {
4458    ulCfg->initialUplinkBWP = NULLP;
4459    DU_ALLOC(ulCfg->initialUplinkBWP, sizeof(BWP_UplinkDedicated_t));
4460    if(!ulCfg->initialUplinkBWP)
4461    {
4462       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failed in BuildUlCfg");
4463       return RFAILED;
4464    }
4465
4466    if(BuildInitialUlBWP(ulCfg->initialUplinkBWP) != ROK)
4467    {
4468       return RFAILED;
4469    }
4470
4471    ulCfg->uplinkBWP_ToReleaseList = NULLP;
4472    ulCfg->uplinkBWP_ToAddModList = NULLP;
4473    ulCfg->firstActiveUplinkBWP_Id = NULLP;
4474    DU_ALLOC(ulCfg->firstActiveUplinkBWP_Id, sizeof(BWP_Id_t));
4475    if(!ulCfg->firstActiveUplinkBWP_Id)
4476    {
4477       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failed in BuildUlCfg");
4478       return RFAILED;
4479    }
4480    *(ulCfg->firstActiveUplinkBWP_Id) = ACTIVE_UL_BWP_ID;
4481
4482    ulCfg->pusch_ServingCellConfig = NULLP;
4483    DU_ALLOC(ulCfg->pusch_ServingCellConfig, \
4484          sizeof(struct UplinkConfig__pusch_ServingCellConfig));
4485    if(!ulCfg->pusch_ServingCellConfig)
4486    {
4487       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failed in BuildUlCfg");
4488       return RFAILED;
4489    }
4490
4491    if(BuildPuschSrvCellCfg(ulCfg->pusch_ServingCellConfig) != ROK)
4492    {
4493       return RFAILED;
4494    }
4495
4496    ulCfg->carrierSwitching = NULLP;
4497    ulCfg->ext1 = NULLP;
4498    return ROK;
4499 }
4500
4501 /*******************************************************************
4502  *
4503  * @brief Builds PDSCH serving cell config
4504  * @details
4505  *
4506  *    Function : BuildPdschSrvCellCfg
4507  *
4508  *    Functionality: Builds PDSCH serving cell config in spCellCfgDed
4509  *
4510  * @params[in] struct ServingCellConfig__pdsch_ServingCellConfig *pdschCfg
4511  *
4512  * @return ROK     - success
4513  *         RFAILED - failure
4514  *
4515  * ****************************************************************/
4516 uint8_t BuildPdschSrvCellCfg(struct ServingCellConfig__pdsch_ServingCellConfig *pdschCfg)
4517 {
4518    pdschCfg->present =  ServingCellConfig__pdsch_ServingCellConfig_PR_setup;
4519    pdschCfg->choice.setup = NULLP;
4520    DU_ALLOC(pdschCfg->choice.setup, sizeof( struct PDSCH_ServingCellConfig));
4521    if(!pdschCfg->choice.setup)
4522    {
4523       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschSrvCellCfg");
4524       return RFAILED;
4525    }
4526
4527    pdschCfg->choice.setup->codeBlockGroupTransmission = NULLP;
4528    pdschCfg->choice.setup->xOverhead = NULLP;
4529    pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH = NULLP;
4530    DU_ALLOC(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH, sizeof(long));
4531    if(!pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH)
4532    {
4533       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschSrvCellCfg");
4534       return RFAILED;
4535    }
4536    *(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH)= PDSCH_NUM_HARQ_PROC;
4537    pdschCfg->choice.setup->pucch_Cell = NULLP;
4538    pdschCfg->choice.setup->ext1 = NULLP;
4539
4540    return ROK;
4541 }
4542
4543 /*******************************************************************
4544  *
4545  * @brief Builds CSI Meas config
4546  * @details
4547  *
4548  *    Function : BuildCsiMeasCfg
4549  *
4550  *    Functionality: Builds CSI Meas config in spCellCfgDed
4551  *
4552  * @params[in] struct ServingCellConfig__csi_MeasConfig *csiMeasCfg
4553  *
4554  * @return ROK     - success
4555  *         RFAILED - failure
4556  *
4557  * ****************************************************************/
4558 uint8_t BuildCsiMeasCfg(struct ServingCellConfig__csi_MeasConfig *csiMeasCfg)
4559 {
4560
4561    return ROK;
4562 }
4563
4564 /*******************************************************************
4565  *
4566  * @brief Builds Spcell config dedicated
4567  * @details
4568  *
4569  *    Function : BuildSpCellCfgDed
4570  *
4571  *    Functionality: Builds sp cell config dedicated in spCellCfg
4572  *
4573  * @params[in] ServingCellConfig_t srvCellCfg
4574  *
4575  * @return ROK     - success
4576  *         RFAILED - failure
4577  *
4578  * ****************************************************************/
4579 uint8_t BuildSpCellCfgDed(ServingCellConfig_t *srvCellCfg)
4580 {
4581    srvCellCfg->tdd_UL_DL_ConfigurationDedicated = NULLP;
4582    DU_ALLOC(srvCellCfg->tdd_UL_DL_ConfigurationDedicated, sizeof(TDD_UL_DL_ConfigDedicated_t));
4583    if(!srvCellCfg->tdd_UL_DL_ConfigurationDedicated)
4584    {
4585       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
4586       return RFAILED;
4587    }
4588
4589    srvCellCfg->initialDownlinkBWP = NULLP;
4590    DU_ALLOC(srvCellCfg->initialDownlinkBWP, sizeof(BWP_DownlinkDedicated_t));
4591    if(!srvCellCfg->initialDownlinkBWP)
4592    {
4593       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
4594       return RFAILED;
4595    }
4596
4597    if(BuildInitialDlBWP(srvCellCfg->initialDownlinkBWP) != ROK)
4598    {
4599       DU_LOG("\nERROR  -->  F1AP : BuildInitialDlBWP failed");
4600       return RFAILED;
4601    }
4602    srvCellCfg->downlinkBWP_ToReleaseList = NULLP;
4603    srvCellCfg->downlinkBWP_ToAddModList = NULLP;
4604
4605    srvCellCfg->firstActiveDownlinkBWP_Id = NULLP;
4606    DU_ALLOC(srvCellCfg->firstActiveDownlinkBWP_Id, sizeof(long));
4607    if(!srvCellCfg->firstActiveDownlinkBWP_Id)
4608    {
4609       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
4610       return RFAILED;
4611    }
4612    *(srvCellCfg->firstActiveDownlinkBWP_Id) = ACTIVE_DL_BWP_ID;
4613
4614    srvCellCfg->bwp_InactivityTimer = NULLP;
4615
4616    srvCellCfg->defaultDownlinkBWP_Id = NULLP;
4617    DU_ALLOC(srvCellCfg->defaultDownlinkBWP_Id, sizeof(long));
4618    if(!srvCellCfg->defaultDownlinkBWP_Id)
4619    {
4620       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
4621       return RFAILED;
4622    }
4623    *(srvCellCfg->defaultDownlinkBWP_Id) = ACTIVE_DL_BWP_ID;
4624
4625    srvCellCfg->uplinkConfig = NULLP;
4626    DU_ALLOC(srvCellCfg->uplinkConfig, sizeof(UplinkConfig_t));
4627    if(!srvCellCfg->uplinkConfig)
4628    {
4629       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
4630       return RFAILED;
4631    }
4632
4633    if(BuildUlCfg(srvCellCfg->uplinkConfig) != ROK)
4634    {
4635       DU_LOG("\nERROR  -->  F1AP : BuildUlCfg failed");
4636       return RFAILED;
4637    }
4638    srvCellCfg->supplementaryUplink = NULLP;
4639    srvCellCfg->pdcch_ServingCellConfig = NULLP;
4640
4641    srvCellCfg->pdsch_ServingCellConfig = NULLP;
4642    DU_ALLOC(srvCellCfg->pdsch_ServingCellConfig, sizeof(struct  ServingCellConfig__pdsch_ServingCellConfig));
4643    if(!srvCellCfg->pdsch_ServingCellConfig)
4644    {
4645       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
4646       return RFAILED;
4647    }
4648
4649    if(BuildPdschSrvCellCfg(srvCellCfg->pdsch_ServingCellConfig) != ROK)
4650    {
4651       DU_LOG("\nERROR  -->  F1AP : BuildPdschSrvCellCfg failed");
4652       return RFAILED;
4653    }
4654
4655    srvCellCfg->csi_MeasConfig = NULLP;
4656 #if 0
4657    DU_ALLOC(srvCellCfg->csi_MeasConfig, sizeof(struct   ServingCellConfig__csi_MeasConfig))
4658       if(!srvCellCfg->csi_MeasConfig)
4659       {
4660          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
4661          return RFAILED;
4662       }
4663
4664    if(BuildCsiMeasCfg(srvCellCfg->csi_MeasConfig) != ROK)
4665    {
4666       DU_LOG("\nF1AP : BuildCsiMeasCfg failed");
4667       return RFAILED;
4668    }
4669 #endif
4670    srvCellCfg->sCellDeactivationTimer = NULLP;
4671    srvCellCfg->crossCarrierSchedulingConfig = NULLP;
4672    srvCellCfg->tag_Id = TAG_ID;
4673    srvCellCfg->dummy = NULLP;
4674    srvCellCfg->pathlossReferenceLinking = NULLP;
4675    srvCellCfg->servingCellMO = NULLP;
4676    srvCellCfg->ext1 = NULLP;
4677
4678    return ROK;
4679 }
4680 /*******************************************************************
4681  *
4682  * @brief Builds Spcell config
4683  *
4684  * @details
4685  *
4686  *    Function : BuildSpCellCfg
4687  *
4688  *    Functionality: Builds sp cell config in DuToCuRrcContainer
4689  *
4690  * @params[in] SpCellConfig_t spCellCfg
4691  *
4692  * @return ROK     - success
4693  *         RFAILED - failure
4694  *
4695  * ****************************************************************/
4696 uint8_t BuildSpCellCfg(SpCellConfig_t *spCellCfg)
4697 {
4698
4699    spCellCfg->servCellIndex = NULLP;
4700    DU_ALLOC(spCellCfg->servCellIndex, sizeof(long));
4701    if(!spCellCfg->servCellIndex)
4702    {
4703       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfg");
4704       return RFAILED;
4705    }
4706    *(spCellCfg->servCellIndex) = SERV_CELL_IDX;
4707
4708    spCellCfg->reconfigurationWithSync = NULLP;
4709    spCellCfg->rlf_TimersAndConstants = NULLP;
4710    spCellCfg->rlmInSyncOutOfSyncThreshold = NULLP;
4711    DU_ALLOC(spCellCfg->rlmInSyncOutOfSyncThreshold, sizeof(long));
4712    if(!spCellCfg->rlmInSyncOutOfSyncThreshold)
4713    {
4714       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfg");
4715       return RFAILED;
4716    }
4717    *(spCellCfg->rlmInSyncOutOfSyncThreshold) = RLM_SYNC_OUT_SYNC_THRESHOLD;
4718
4719    spCellCfg->spCellConfigDedicated = NULLP;
4720    DU_ALLOC(spCellCfg->spCellConfigDedicated, sizeof(ServingCellConfig_t));
4721    if(!spCellCfg->spCellConfigDedicated)
4722    {
4723       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfg");
4724       return RFAILED;
4725    }
4726    if(BuildSpCellCfgDed(spCellCfg->spCellConfigDedicated) != ROK)
4727    {
4728       DU_LOG("\nERROR  -->  F1AP : BuildSpCellCfgDed failed");
4729       return RFAILED;
4730    }
4731    return ROK;
4732 }
4733 /*******************************************************************
4734  *
4735  * @brief Builds Phy cell group config
4736  *
4737  * @details
4738  *
4739  *    Function : BuildPhyCellGrpCfg
4740  *
4741  *    Functionality: Builds Phy cell group config in DuToCuRrcContainer
4742  *
4743  * @params[in] PhysicalCellGroupConfig_t *phyCellGrpCfg
4744  *
4745  * @return ROK     - success
4746  *         RFAILED - failure
4747  *
4748  * ****************************************************************/
4749 uint8_t BuildPhyCellGrpCfg(PhysicalCellGroupConfig_t *phyCellGrpCfg)
4750 {
4751    phyCellGrpCfg->harq_ACK_SpatialBundlingPUCCH = NULLP;
4752    phyCellGrpCfg->harq_ACK_SpatialBundlingPUSCH = NULLP;
4753
4754    phyCellGrpCfg->p_NR_FR1 = NULLP;
4755    DU_ALLOC(phyCellGrpCfg->p_NR_FR1, sizeof(long));
4756    if(!phyCellGrpCfg->p_NR_FR1)
4757    {
4758       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildPhyCellGrpCfg");
4759       return RFAILED;
4760    }
4761    *(phyCellGrpCfg->p_NR_FR1)             = P_NR_FR1;
4762    phyCellGrpCfg->pdsch_HARQ_ACK_Codebook = PDSCH_HARQ_ACK_CODEBOOK;
4763    phyCellGrpCfg->tpc_SRS_RNTI = NULLP;
4764    phyCellGrpCfg->tpc_PUCCH_RNTI = NULLP;
4765    phyCellGrpCfg->tpc_PUSCH_RNTI = NULLP;
4766    phyCellGrpCfg->sp_CSI_RNTI = NULLP;
4767    phyCellGrpCfg->cs_RNTI = NULLP;
4768    phyCellGrpCfg->ext1 = NULLP;
4769    phyCellGrpCfg->ext2 = NULLP;
4770
4771    return ROK;
4772 }
4773 /*******************************************************************
4774  *
4775  * @brief Builds Mac cell group config
4776  *
4777  * @details
4778  *
4779  *    Function : BuildMacCellGrpCfg
4780  *
4781  *    Functionality: Builds Mac cell group config in DuToCuRrcContainer
4782  *
4783  * @params[in] MAC_CellGroupConfig_t *macCellGrpCfg
4784  *
4785  * @return ROK     - success
4786  *         RFAILED - failure
4787  *
4788  * ****************************************************************/
4789 uint8_t BuildMacCellGrpCfg(MAC_CellGroupConfig_t *macCellGrpCfg)
4790 {
4791    macCellGrpCfg->drx_Config = NULLP;
4792    macCellGrpCfg->schedulingRequestConfig = NULLP;
4793    DU_ALLOC(macCellGrpCfg->schedulingRequestConfig, sizeof(struct SchedulingRequestConfig));
4794    if(!macCellGrpCfg->schedulingRequestConfig)
4795    {
4796       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacCellGrpCfg");
4797       return RFAILED;
4798    }
4799
4800    if(BuildSchedulingReqConfig(macCellGrpCfg->schedulingRequestConfig) != ROK)
4801    {
4802       DU_LOG("\nERROR  -->  F1AP : BuildSchedulingReqConfig failed");
4803       return RFAILED;
4804    }
4805
4806    macCellGrpCfg->bsr_Config = NULLP;
4807    DU_ALLOC(macCellGrpCfg->bsr_Config, sizeof(struct BSR_Config));
4808    if(!macCellGrpCfg->bsr_Config)
4809    {
4810       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacCellGrpCfg");
4811       return RFAILED;
4812    }
4813
4814    if(BuildBsrConfig(macCellGrpCfg->bsr_Config) != ROK)
4815    {
4816       DU_LOG("\nERROR  -->  F1AP : BuildBsrConfig failed");
4817       return RFAILED;
4818    }
4819
4820    macCellGrpCfg->tag_Config = NULLP;
4821    DU_ALLOC(macCellGrpCfg->tag_Config, sizeof(struct TAG_Config));
4822    if(!macCellGrpCfg->tag_Config)
4823    {
4824       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacCellGrpCfg");
4825       return RFAILED;
4826    }
4827
4828    if(BuildTagConfig(macCellGrpCfg->tag_Config) != ROK)
4829    {
4830       DU_LOG("\nERROR  -->  F1AP : BuildTagConfig failed");
4831       return RFAILED;
4832    }
4833
4834    macCellGrpCfg->phr_Config = NULLP;
4835    DU_ALLOC(macCellGrpCfg->phr_Config, sizeof(struct MAC_CellGroupConfig__phr_Config));
4836    if(!macCellGrpCfg->phr_Config)
4837    {
4838       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacCellGrpCfg");
4839       return RFAILED;
4840    }
4841
4842    if(BuildPhrConfig(macCellGrpCfg->phr_Config) != ROK)
4843    {
4844       DU_LOG("\nERROR  -->  F1AP : BuildPhrConfig failed");
4845       return RFAILED;
4846    }
4847
4848    macCellGrpCfg->skipUplinkTxDynamic = false;
4849    macCellGrpCfg->ext1 = NULLP;
4850
4851    return ROK;
4852 }
4853 /*******************************************************************
4854  *
4855  * @brief Frees memeory allocated for SearchSpcToAddModList
4856  *
4857  * @details
4858  *
4859  *    Function : FreeSearchSpcToAddModList
4860  *
4861  *    Functionality: Deallocating memory of SearchSpcToAddModList
4862  *
4863  * @params[in] struct PDCCH_Config__searchSpacesToAddModList *searchSpcList
4864  *
4865  * @return void
4866  *
4867  4221 * ****************************************************************/
4868 void FreeSearchSpcToAddModList(struct PDCCH_Config__searchSpacesToAddModList *searchSpcList)
4869 {
4870    uint8_t idx1=0;
4871    uint8_t idx2=0;
4872    struct  SearchSpace *searchSpc=NULLP;
4873
4874    if(searchSpcList->list.array)
4875    {
4876       if(searchSpcList->list.array[idx2])
4877       {
4878          searchSpc = searchSpcList->list.array[idx2];
4879          if(searchSpc->controlResourceSetId)
4880          {
4881             if(searchSpc->monitoringSlotPeriodicityAndOffset)
4882             {
4883                if(searchSpc->monitoringSymbolsWithinSlot)
4884                {
4885                   if(searchSpc->monitoringSymbolsWithinSlot->buf)
4886                   {
4887                      if(searchSpc->nrofCandidates)
4888                      {
4889                         if(searchSpc->searchSpaceType)
4890                         {
4891                            DU_FREE(searchSpc->searchSpaceType->choice.ue_Specific,\
4892                                  sizeof(struct SearchSpace__searchSpaceType__ue_Specific));
4893                            DU_FREE(searchSpc->searchSpaceType, sizeof(struct
4894                                     SearchSpace__searchSpaceType));
4895                         }
4896                         DU_FREE(searchSpc->nrofCandidates,
4897                               sizeof(struct SearchSpace__nrofCandidates));
4898                      }
4899                      DU_FREE(searchSpc->monitoringSymbolsWithinSlot->buf, \
4900                            searchSpc->monitoringSymbolsWithinSlot->size);
4901                   }
4902                   DU_FREE(searchSpc->monitoringSymbolsWithinSlot,
4903                         sizeof(BIT_STRING_t));
4904                }
4905                DU_FREE(searchSpc->monitoringSlotPeriodicityAndOffset, \
4906                      sizeof(struct SearchSpace__monitoringSlotPeriodicityAndOffset));
4907             }
4908             DU_FREE(searchSpc->controlResourceSetId,
4909                   sizeof(ControlResourceSetId_t));
4910          }
4911       }
4912       for(idx1 = 0; idx1 < searchSpcList->list.count; idx1++)
4913       {
4914          DU_FREE(searchSpcList->list.array[idx1],
4915                sizeof(struct SearchSpace));
4916       }
4917       DU_FREE(searchSpcList->list.array,searchSpcList->list.size);
4918    }
4919 }
4920 /*******************************************************************
4921  *
4922  * @brief Frees memory allocated for PdschTimeDomAllocList
4923  *
4924  * @details
4925  *
4926  *    Function : FreePdschTimeDomAllocList
4927  *
4928  *    Functionality: Deallocating memory of PdschTimeDomAllocList
4929  *
4930  * @params[in] struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList
4931  *
4932  * @return void
4933  *
4934  4221 * ****************************************************************/
4935 void FreePdschTimeDomAllocList( struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList)
4936 {
4937    uint8_t idx1=0;
4938
4939    if(timeDomAllocList->choice.setup)
4940    {
4941       if(timeDomAllocList->choice.setup->list.array)
4942       {
4943          for(idx1 = 0; idx1 <timeDomAllocList->choice.setup->list.count ; idx1++)
4944          {
4945             DU_FREE(timeDomAllocList->choice.setup->list.array[idx1],
4946                   sizeof(struct PDSCH_TimeDomainResourceAllocation));
4947          }
4948          DU_FREE(timeDomAllocList->choice.setup->list.array, \
4949                timeDomAllocList->choice.setup->list.size);
4950       }
4951       DU_FREE(timeDomAllocList->choice.setup,\
4952             sizeof(struct PDSCH_TimeDomainResourceAllocationList));
4953    }
4954 }
4955 /*******************************************************************
4956  *
4957  * @brief Frees memory allocated for PuschTimeDomAllocList
4958  *
4959  *@details
4960  *
4961  *    Function : FreePuschTimeDomAllocList
4962  *
4963  *    Functionality: Deallocating memory of PuschTimeDomAllocList
4964  *
4965  * @params[in] PUSCH_Config_t *puschCfg
4966  *
4967  * @return void
4968  *
4969  * ****************************************************************/
4970 void FreePuschTimeDomAllocList(PUSCH_Config_t *puschCfg)
4971 {
4972    uint8_t idx1=0;
4973    uint8_t idx2=0;
4974    struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList_t=NULLP;
4975
4976    if(puschCfg->pusch_TimeDomainAllocationList)
4977    {
4978       timeDomAllocList_t=puschCfg->pusch_TimeDomainAllocationList;
4979       if(timeDomAllocList_t->choice.setup)
4980       {
4981          if(timeDomAllocList_t->choice.setup->list.array)
4982          {
4983             DU_FREE(timeDomAllocList_t->choice.setup->list.array[idx2]->k2, sizeof(long));
4984             for(idx1 = 0; idx1<timeDomAllocList_t->choice.setup->list.count; idx1++)
4985             {
4986                DU_FREE(timeDomAllocList_t->choice.setup->list.array[idx1],\
4987                      sizeof(PUSCH_TimeDomainResourceAllocation_t));
4988             }
4989             DU_FREE(timeDomAllocList_t->choice.setup->list.array, \
4990                   timeDomAllocList_t->choice.setup->list.size);
4991          }
4992          DU_FREE(timeDomAllocList_t->choice.setup, \
4993                sizeof(struct PUSCH_TimeDomainResourceAllocationList));
4994       }
4995       DU_FREE(puschCfg->transformPrecoder, sizeof(long));
4996       DU_FREE(puschCfg->pusch_TimeDomainAllocationList, \
4997             sizeof(struct PUSCH_Config__pusch_TimeDomainAllocationList));
4998    }
4999
5000 }
5001 /*******************************************************************
5002  *
5003  * @brief Frees memory allocated for InitialUlBWP
5004  *
5005  * @details
5006  *
5007  *    Function : FreeInitialUlBWP
5008  *
5009  *    Functionality: Deallocating memory of InitialUlBWP
5010  *
5011  * @params[in] BWP_UplinkDedicated_t *ulBwp
5012  *
5013  * @return void
5014  *
5015  * ****************************************************************/
5016 void FreeInitialUlBWP(BWP_UplinkDedicated_t *ulBwp)
5017 {
5018    uint8_t  rSetIdx, rsrcIdx;
5019    SRS_Config_t   *srsCfg = NULLP;
5020    PUSCH_Config_t *puschCfg = NULLP;
5021    struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA *dmrsUlCfg = NULLP;
5022    struct SRS_Config__srs_ResourceSetToAddModList *rsrcSetList = NULLP;
5023    struct SRS_ResourceSet__srs_ResourceIdList *rsrcIdList = NULLP;
5024    struct SRS_Config__srs_ResourceToAddModList *resourceList = NULLP;
5025
5026    if(ulBwp->pusch_Config)
5027    {
5028       if(ulBwp->pusch_Config->choice.setup)
5029       {
5030          puschCfg=ulBwp->pusch_Config->choice.setup;
5031          if(puschCfg->dataScramblingIdentityPUSCH)
5032          {
5033             if(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA)
5034             {
5035                FreePuschTimeDomAllocList(puschCfg);
5036                dmrsUlCfg=puschCfg->dmrs_UplinkForPUSCH_MappingTypeA;
5037                if(dmrsUlCfg->choice.setup)
5038                {
5039                   if(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition)
5040                   {
5041                      if(dmrsUlCfg->choice.setup->transformPrecodingDisabled)
5042                      {
5043                         DU_FREE(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0,\
5044                               sizeof(long));
5045                         DU_FREE(dmrsUlCfg->choice.setup->transformPrecodingDisabled,
5046                               sizeof(struct DMRS_UplinkConfig__transformPrecodingDisabled));
5047                      }
5048                      DU_FREE(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition,
5049                            sizeof(long));
5050                   }
5051                   DU_FREE(dmrsUlCfg->choice.setup,sizeof(DMRS_UplinkConfig_t));
5052                }
5053                DU_FREE(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA, \
5054                      sizeof(struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA));
5055             }
5056             DU_FREE(puschCfg->dataScramblingIdentityPUSCH, sizeof(long));
5057          }
5058          DU_FREE(ulBwp->pusch_Config->choice.setup, sizeof(PUSCH_Config_t));
5059       }
5060       DU_FREE(ulBwp->pusch_Config, sizeof(struct BWP_UplinkDedicated__pusch_Config));
5061
5062       /* Free SRS-Config */
5063       if(ulBwp->srs_Config)
5064       {
5065          if(ulBwp->srs_Config->choice.setup)
5066          {
5067             srsCfg = ulBwp->srs_Config->choice.setup;
5068
5069             /* Free Resource Set to add/mod list */
5070             if(srsCfg->srs_ResourceSetToAddModList)
5071             {
5072                rsrcSetList = srsCfg->srs_ResourceSetToAddModList;
5073                if(rsrcSetList->list.array)
5074                {
5075                   rSetIdx = 0;
5076
5077                   /* Free SRS resource Id list in this SRS resource set */
5078                   if(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList)
5079                   {
5080                      rsrcIdList = rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList;
5081
5082                      if(rsrcIdList->list.array)
5083                      {
5084                         for(rsrcIdx = 0; rsrcIdx < rsrcIdList->list.count; rsrcIdx++)
5085                         {
5086                            DU_FREE(rsrcIdList->list.array[rsrcIdx], sizeof(SRS_ResourceId_t));
5087                         }
5088                         DU_FREE(rsrcIdList->list.array, rsrcIdList->list.size);
5089                      }
5090                      DU_FREE(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList,\
5091                            sizeof(struct SRS_ResourceSet__srs_ResourceIdList));
5092                   }
5093
5094                   /* Free resource type info for this SRS resource set */
5095                   DU_FREE(rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic, \
5096                         sizeof(struct SRS_ResourceSet__resourceType__aperiodic));
5097
5098                   /* Free memory for each resource set */
5099                   for(rSetIdx = 0; rSetIdx < rsrcSetList->list.count; rSetIdx++)
5100                   {
5101                      DU_FREE(rsrcSetList->list.array[rSetIdx], sizeof(SRS_ResourceSet_t));
5102                   }
5103                   DU_FREE(rsrcSetList->list.array, rsrcSetList->list.size);
5104                }
5105                DU_FREE(srsCfg->srs_ResourceSetToAddModList, \
5106                      sizeof(struct SRS_Config__srs_ResourceSetToAddModList));
5107             }
5108
5109             /* Free resource to add/modd list */
5110             if(srsCfg->srs_ResourceToAddModList)
5111             {
5112                resourceList = srsCfg->srs_ResourceToAddModList;
5113                if(resourceList->list.array)
5114                {
5115                   rsrcIdx = 0;
5116                   DU_FREE(resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2,\
5117                         sizeof(struct SRS_Resource__transmissionComb__n2));
5118                   DU_FREE(resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic,\
5119                         sizeof(struct SRS_Resource__resourceType__aperiodic));
5120
5121                   for(rsrcIdx = 0; rsrcIdx < resourceList->list.count; rsrcIdx++)
5122                   {
5123                      DU_FREE(resourceList->list.array[rsrcIdx], sizeof(SRS_Resource_t));
5124                   }
5125                   DU_FREE(resourceList->list.array, resourceList->list.size);
5126                }
5127                DU_FREE(srsCfg->srs_ResourceToAddModList, \
5128                      sizeof(struct SRS_Config__srs_ResourceToAddModList));
5129             }
5130
5131             DU_FREE(ulBwp->srs_Config->choice.setup, sizeof(SRS_Config_t));
5132          }
5133          DU_FREE(ulBwp->srs_Config, sizeof(struct BWP_UplinkDedicated__srs_Config));
5134       }
5135    }
5136 }
5137 /*******************************************************************
5138  *
5139  * @brief Frees memory allocated for initialUplinkBWP
5140  *
5141  * @details
5142  *
5143  *    Function : FreeinitialUplinkBWP
5144  *
5145  *    Functionality: Deallocating memory of initialUplinkBWP
5146  *
5147  * @params[in] UplinkConfig_t *ulCfg
5148  *
5149  * @return void
5150  *
5151  *
5152  * ****************************************************************/
5153 void FreeinitialUplinkBWP(UplinkConfig_t *ulCfg)
5154 {
5155    BWP_UplinkDedicated_t *ulBwp=NULLP;
5156    struct UplinkConfig__pusch_ServingCellConfig *puschCfg=NULLP;
5157
5158    if(ulCfg->initialUplinkBWP)
5159    {
5160       ulBwp=ulCfg->initialUplinkBWP;
5161       if(ulCfg->firstActiveUplinkBWP_Id)
5162       {
5163          if(ulCfg->pusch_ServingCellConfig)
5164          {
5165             puschCfg=ulCfg->pusch_ServingCellConfig;
5166             if(puschCfg->choice.setup)
5167             {
5168                if(puschCfg->choice.setup->ext1)
5169                {
5170                   DU_FREE(puschCfg->choice.setup->ext1->\
5171                         processingType2Enabled,sizeof(BOOLEAN_t));
5172                   DU_FREE(puschCfg->choice.setup->ext1->\
5173                         maxMIMO_Layers,sizeof(long));
5174                   DU_FREE(puschCfg->choice.setup->ext1, \
5175                         sizeof(struct PUSCH_ServingCellConfig__ext1));
5176                }
5177                DU_FREE(puschCfg->choice.setup, sizeof(struct PUSCH_ServingCellConfig));
5178             }
5179             DU_FREE(ulCfg->pusch_ServingCellConfig, sizeof(struct UplinkConfig__pusch_ServingCellConfig));
5180          }
5181          DU_FREE(ulCfg->firstActiveUplinkBWP_Id, sizeof(BWP_Id_t));
5182       }
5183       FreeInitialUlBWP(ulBwp);
5184       DU_FREE(ulCfg->initialUplinkBWP, sizeof(BWP_UplinkDedicated_t));
5185    }
5186 }
5187 /*******************************************************************
5188  *
5189  * @brief Frees emmory allocated for BWPDlDedPdschCfg
5190  *
5191  * @details
5192  *
5193  *    Function : FreeBWPDlDedPdschCfg
5194  *
5195  *    Functionality: Deallocating memory of BWPDlDedPdschCfg
5196  *
5197  * @params[in] BWP_DownlinkDedicated_t *dlBwp
5198  *
5199  * @return void
5200  *
5201  *
5202  * ****************************************************************/
5203 void FreeBWPDlDedPdschCfg(BWP_DownlinkDedicated_t *dlBwp)
5204 {
5205    struct PDSCH_Config *pdschCfg=NULLP;
5206    struct PDSCH_Config__prb_BundlingType *prbBndlType=NULLP;
5207    struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList=NULLP;
5208    struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA *dmrsDlCfg=NULLP;
5209
5210    if(dlBwp->pdsch_Config->choice.setup)
5211    {
5212       pdschCfg=dlBwp->pdsch_Config->choice.setup;
5213       if(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA)
5214       {
5215          if(pdschCfg->pdsch_TimeDomainAllocationList)
5216          {
5217             timeDomAllocList=pdschCfg->pdsch_TimeDomainAllocationList;
5218             if(pdschCfg->maxNrofCodeWordsScheduledByDCI)
5219             {
5220                prbBndlType=&pdschCfg->prb_BundlingType;
5221                DU_FREE(prbBndlType->choice.staticBundling,\
5222                      sizeof(struct PDSCH_Config__prb_BundlingType__staticBundling));
5223                DU_FREE(pdschCfg->maxNrofCodeWordsScheduledByDCI, sizeof(long));
5224             }
5225             FreePdschTimeDomAllocList(timeDomAllocList);
5226             DU_FREE(pdschCfg->pdsch_TimeDomainAllocationList, \
5227                   sizeof(struct PDSCH_Config__pdsch_TimeDomainAllocationList));
5228          }
5229          dmrsDlCfg=pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA;
5230          if(dmrsDlCfg->choice.setup)
5231          {
5232             DU_FREE(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition,
5233                   sizeof(long));
5234             DU_FREE(dmrsDlCfg->choice.setup, sizeof(struct DMRS_DownlinkConfig));
5235          }
5236          DU_FREE(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA, \
5237                sizeof(struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA));
5238       }
5239       DU_FREE(dlBwp->pdsch_Config->choice.setup, sizeof(struct PDSCH_Config));
5240    }
5241 }
5242 /*******************************************************************
5243  *
5244  * @brief Frees emmory allocated for BWPDlDedPdcchCfg
5245  *
5246  * @details
5247  *
5248  *    Function : FreeBWPDlDedPdcchCfg
5249  *
5250  *    Functionality: Deallocating memory of BWPDlDedPdcchCfg
5251  *
5252  * @params[in] BWP_DownlinkDedicated_t *dlBwp
5253  *
5254  * @return void
5255  *
5256  *
5257  * ****************************************************************/
5258 void FreeBWPDlDedPdcchCfg(BWP_DownlinkDedicated_t *dlBwp)
5259 {
5260    uint8_t idx1=0;
5261    uint8_t idx2=0;
5262    struct PDCCH_Config *pdcchCfg=NULLP;
5263    struct ControlResourceSet *controlRSet=NULLP;
5264    struct PDCCH_Config__controlResourceSetToAddModList *controlRSetList=NULLP;
5265
5266    if(dlBwp->pdcch_Config->choice.setup)
5267    {
5268       pdcchCfg=dlBwp->pdcch_Config->choice.setup;
5269       if(pdcchCfg->controlResourceSetToAddModList)
5270       {
5271          controlRSetList = pdcchCfg->controlResourceSetToAddModList;
5272          if(controlRSetList->list.array)
5273          {
5274             controlRSet = controlRSetList->list.array[idx2];
5275             if(controlRSet)
5276             {
5277                if(controlRSet->frequencyDomainResources.buf)
5278                {
5279                   if(controlRSet->pdcch_DMRS_ScramblingID)
5280                   {
5281                      if(pdcchCfg->searchSpacesToAddModList)
5282                      {
5283                         FreeSearchSpcToAddModList(pdcchCfg->searchSpacesToAddModList);
5284                         DU_FREE(pdcchCfg->searchSpacesToAddModList, \
5285                               sizeof(struct PDCCH_Config__searchSpacesToAddModList));
5286                      }
5287                      DU_FREE(controlRSet->pdcch_DMRS_ScramblingID, sizeof(long));
5288                   }
5289                   DU_FREE(controlRSet->frequencyDomainResources.buf, \
5290                         controlRSet->frequencyDomainResources.size);
5291                }
5292             }
5293             for(idx1 = 0; idx1 <controlRSetList->list.count; idx1++)
5294             {
5295                DU_FREE(controlRSetList->list.array[idx1], sizeof(struct ControlResourceSet));
5296             }
5297             DU_FREE(controlRSetList->list.array, controlRSetList->list.size);
5298          }
5299          DU_FREE(pdcchCfg->controlResourceSetToAddModList, \
5300                sizeof(struct PDCCH_Config__controlResourceSetToAddModList));
5301       }
5302       DU_FREE(dlBwp->pdcch_Config->choice.setup, sizeof(struct PDCCH_Config));
5303    }
5304 }
5305
5306 /*******************************************************************
5307  *
5308  * @brief Frees emmory allocated for DUToCURRCContainer
5309  *
5310  * @details
5311  *
5312  *    Function : FreeMemDuToCuRrcCont
5313  *
5314  *    Functionality: Deallocating memory of DuToCuRrcContainer
5315  *
5316  * @params[in] DuToCuRRCContainer, DuToCuRRCContainer
5317  *
5318  * @return ROK     - success
5319  *         RFAILED - failure
5320  *
5321  * ****************************************************************/
5322 uint8_t FreeMemDuToCuRrcCont(CellGroupConfigRrc_t *cellGrpCfg)
5323 {
5324    uint8_t idx=0;
5325    SpCellConfig_t *spCellCfg=NULLP;
5326    ServingCellConfig_t *srvCellCfg=NULLP;
5327    BWP_DownlinkDedicated_t *dlBwp=NULLP;
5328    MAC_CellGroupConfig_t *macCellGrpCfg=NULLP;
5329    PhysicalCellGroupConfig_t *phyCellGrpCfg=NULLP;
5330    struct CellGroupConfigRrc__rlc_BearerToAddModList *rlcBearerList=NULLP;
5331    struct RLC_Config *rlcConfig=NULLP;
5332    struct LogicalChannelConfig *macLcConfig=NULLP;
5333    struct SchedulingRequestConfig *schedulingRequestConfig=NULLP;
5334    struct SchedulingRequestConfig__schedulingRequestToAddModList *schReqList=NULLP;
5335    struct TAG_Config *tagConfig=NULLP;
5336    struct TAG_Config__tag_ToAddModList *tagList=NULLP;
5337    struct MAC_CellGroupConfig__phr_Config *phrConfig=NULLP;
5338    struct ServingCellConfig__pdsch_ServingCellConfig *pdschCfg=NULLP;
5339
5340    rlcBearerList = cellGrpCfg->rlc_BearerToAddModList;
5341    if(rlcBearerList)
5342    {
5343       if(rlcBearerList->list.array)
5344       {
5345          for(idx=0; idx<rlcBearerList->list.count; idx++)
5346          {
5347             if(rlcBearerList->list.array[idx])
5348             {
5349                rlcConfig   = rlcBearerList->list.array[idx]->rlc_Config;
5350                macLcConfig = rlcBearerList->list.array[idx]->mac_LogicalChannelConfig;
5351                if(rlcConfig)
5352                {
5353                   if(rlcConfig->choice.am)
5354                   {
5355                      DU_FREE(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
5356                      DU_FREE(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
5357                      DU_FREE(rlcConfig->choice.am, sizeof(struct RLC_Config__am));
5358                   }
5359                   DU_FREE(rlcConfig, sizeof(struct RLC_Config));
5360                }
5361                DU_FREE(rlcBearerList->list.array[idx]->servedRadioBearer, sizeof(struct RLC_BearerConfig__servedRadioBearer));
5362                if(macLcConfig)
5363                {
5364                   if(macLcConfig->ul_SpecificParameters)
5365                   {
5366                      DU_FREE(macLcConfig->ul_SpecificParameters->schedulingRequestID,   sizeof(SchedulingRequestId_t));
5367                      DU_FREE(macLcConfig->ul_SpecificParameters->logicalChannelGroup,   sizeof(long));
5368                      DU_FREE(macLcConfig->ul_SpecificParameters, sizeof(struct LogicalChannelConfig__ul_SpecificParameters));
5369                   }
5370                   DU_FREE(rlcBearerList->list.array[idx]->mac_LogicalChannelConfig, sizeof(struct LogicalChannelConfig));
5371                }
5372                DU_FREE(rlcBearerList->list.array[idx], sizeof(struct RLC_BearerConfig));
5373             }
5374          }
5375          DU_FREE(rlcBearerList->list.array, rlcBearerList->list.size);
5376       }
5377       DU_FREE(cellGrpCfg->rlc_BearerToAddModList, sizeof(struct CellGroupConfigRrc__rlc_BearerToAddModList));
5378    }
5379
5380    macCellGrpCfg = cellGrpCfg->mac_CellGroupConfig;
5381    if(macCellGrpCfg)
5382    {
5383       schedulingRequestConfig = macCellGrpCfg->schedulingRequestConfig;
5384       if(schedulingRequestConfig)
5385       {
5386          schReqList = schedulingRequestConfig->schedulingRequestToAddModList;
5387          if(schReqList)
5388          {
5389             if(schReqList->list.array)
5390             {
5391                for(idx=0;idx<schReqList->list.count; idx++)
5392                {
5393                   if(schReqList->list.array[idx])
5394                   {
5395                      DU_FREE(schReqList->list.array[idx]->sr_ProhibitTimer, sizeof(long));
5396                      DU_FREE(schReqList->list.array[idx], sizeof(struct SchedulingRequestToAddMod));
5397                   }
5398                }
5399                DU_FREE(schReqList->list.array, schReqList->list.size);
5400             }
5401             DU_FREE(schedulingRequestConfig->schedulingRequestToAddModList,\
5402                   sizeof(struct SchedulingRequestConfig__schedulingRequestToAddModList));    }
5403             DU_FREE(macCellGrpCfg->schedulingRequestConfig, sizeof(struct SchedulingRequestConfig));
5404       }
5405       if(macCellGrpCfg->bsr_Config)
5406       {
5407          DU_FREE(macCellGrpCfg->bsr_Config, sizeof(struct BSR_Config));
5408       }
5409       tagConfig = macCellGrpCfg->tag_Config;
5410       if(tagConfig)
5411       {
5412          tagList = tagConfig->tag_ToAddModList;
5413          if(tagList)
5414          {
5415             if(tagList->list.array)
5416             {
5417                for(idx=0; idx<tagList->list.count; idx++)
5418                {
5419                   DU_FREE(tagList->list.array[idx], sizeof(struct TAG));
5420                }
5421                DU_FREE(tagList->list.array, tagList->list.size);
5422             }
5423             DU_FREE(tagConfig->tag_ToAddModList, sizeof(struct TAG_Config__tag_ToAddModList));
5424          }
5425          DU_FREE(tagConfig, sizeof(struct TAG_Config));
5426       }
5427
5428       phrConfig = macCellGrpCfg->phr_Config;
5429       if(phrConfig)
5430       {
5431          DU_FREE(phrConfig->choice.setup, sizeof(struct PHR_Config));
5432          DU_FREE(phrConfig, sizeof(struct MAC_CellGroupConfig__phr_Config));
5433       }
5434
5435       DU_FREE(macCellGrpCfg, sizeof(MAC_CellGroupConfig_t));
5436    }
5437
5438    phyCellGrpCfg = cellGrpCfg->physicalCellGroupConfig;
5439    if(phyCellGrpCfg)
5440    {
5441       DU_FREE(phyCellGrpCfg->p_NR_FR1, sizeof(long));
5442       DU_FREE(phyCellGrpCfg, sizeof(PhysicalCellGroupConfig_t));
5443    }
5444
5445    spCellCfg = cellGrpCfg->spCellConfig;
5446    if(spCellCfg)
5447    {
5448       if(spCellCfg->servCellIndex)
5449       {
5450          if(spCellCfg->rlmInSyncOutOfSyncThreshold)
5451          {
5452             if(spCellCfg->spCellConfigDedicated)
5453             {
5454                srvCellCfg = spCellCfg->spCellConfigDedicated;
5455                if(srvCellCfg->tdd_UL_DL_ConfigurationDedicated)
5456                {
5457                   if(srvCellCfg->initialDownlinkBWP)
5458                   {
5459                      dlBwp = srvCellCfg->initialDownlinkBWP;
5460                      if(srvCellCfg->firstActiveDownlinkBWP_Id)
5461                      {
5462                         if(srvCellCfg->defaultDownlinkBWP_Id)
5463                         {
5464                            if(srvCellCfg->uplinkConfig)
5465                            {
5466                               if(srvCellCfg->pdsch_ServingCellConfig)
5467                               {
5468                                  pdschCfg= srvCellCfg->pdsch_ServingCellConfig;
5469                                  if(pdschCfg->choice.setup)
5470                                  {
5471                                     DU_FREE(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH,sizeof(long));
5472                                     DU_FREE(pdschCfg->choice.setup, sizeof( struct PDSCH_ServingCellConfig));
5473                                  }
5474                                  DU_FREE(srvCellCfg->pdsch_ServingCellConfig, sizeof(struct
5475                                        ServingCellConfig__pdsch_ServingCellConfig));
5476                               }
5477                               FreeinitialUplinkBWP(srvCellCfg->uplinkConfig);
5478                               DU_FREE(srvCellCfg->uplinkConfig, sizeof(UplinkConfig_t));
5479                            }
5480                            DU_FREE(srvCellCfg->defaultDownlinkBWP_Id, sizeof(long));
5481                         }
5482                         DU_FREE(srvCellCfg->firstActiveDownlinkBWP_Id, sizeof(long));
5483                      }
5484                      if(dlBwp->pdcch_Config)
5485                      {
5486                         if(dlBwp->pdsch_Config)
5487                         {
5488                            FreeBWPDlDedPdschCfg(dlBwp);
5489                            DU_FREE(dlBwp->pdsch_Config, sizeof(struct BWP_DownlinkDedicated__pdsch_Config));
5490                         }
5491                         FreeBWPDlDedPdcchCfg(dlBwp);
5492                         DU_FREE(dlBwp->pdcch_Config, sizeof(struct BWP_DownlinkDedicated__pdcch_Config));
5493                     }
5494                     DU_FREE(srvCellCfg->initialDownlinkBWP, sizeof(BWP_DownlinkDedicated_t));
5495                   }
5496                   DU_FREE(srvCellCfg->tdd_UL_DL_ConfigurationDedicated, sizeof(TDD_UL_DL_ConfigDedicated_t));
5497                }
5498                DU_FREE(spCellCfg->spCellConfigDedicated, sizeof(ServingCellConfig_t));
5499             }
5500             DU_FREE(spCellCfg->rlmInSyncOutOfSyncThreshold, sizeof(long));
5501          }
5502          DU_FREE(spCellCfg->servCellIndex, sizeof(long));
5503       }
5504       DU_FREE(spCellCfg,sizeof(SpCellConfig_t));
5505    }
5506    return ROK;
5507 }
5508 /*******************************************************************
5509  *
5510  * @brief Builds DU To CU RRC Container
5511  *
5512  * @details
5513  *
5514  *    Function : BuildDuToCuRrcContainer
5515  *
5516  *    Functionality: Builds DuToCuRrcContainer
5517  *
5518  * @params[in] idx, index in F1AP msg
5519  *             DuToCuRRCContainer, DuToCuRRCContainer
5520  *
5521  * @return ROK     - success
5522  *         RFAILED - failure
5523  *
5524  * ****************************************************************/
5525 uint8_t BuildDuToCuRrcContainer(DUtoCURRCContainer_t *duToCuRrcContainer)
5526 {
5527    uint8_t  ret = ROK;
5528    CellGroupConfigRrc_t  cellGrpCfg;
5529    asn_enc_rval_t        encRetVal;
5530    memset(&cellGrpCfg, 0, sizeof(CellGroupConfigRrc_t));
5531    memset(&encRetVal, 0, sizeof(asn_enc_rval_t));
5532
5533    while(true)
5534    {
5535       cellGrpCfg.cellGroupId = CELL_GRP_ID;
5536
5537       cellGrpCfg.rlc_BearerToAddModList = NULLP;
5538       DU_ALLOC(cellGrpCfg.rlc_BearerToAddModList, sizeof(struct CellGroupConfigRrc__rlc_BearerToAddModList));
5539       if(!cellGrpCfg.rlc_BearerToAddModList)
5540       {
5541          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildDuToCuRrcContainer");
5542          ret = RFAILED;
5543          break;
5544       }
5545       if(BuildRlcBearerToAddModList(cellGrpCfg.rlc_BearerToAddModList) != ROK)
5546       {
5547          DU_LOG("\nERROR  -->  F1AP : BuildRlcBearerToAddModList failed");
5548          ret = RFAILED;
5549          break;
5550       }
5551
5552       cellGrpCfg.rlc_BearerToReleaseList = NULLP;
5553       cellGrpCfg.mac_CellGroupConfig = NULLP;
5554       DU_ALLOC(cellGrpCfg.mac_CellGroupConfig, sizeof(MAC_CellGroupConfig_t));
5555       if(!cellGrpCfg.mac_CellGroupConfig)
5556       {
5557          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildDuToCuRrcContainer");
5558          ret = RFAILED;
5559          break;
5560       }
5561       if(BuildMacCellGrpCfg(cellGrpCfg.mac_CellGroupConfig) != ROK)
5562       {
5563          DU_LOG("\nERROR  -->  F1AP : BuildMacCellGrpCfg failed");
5564          ret = RFAILED;
5565          break;
5566       }
5567
5568       cellGrpCfg.physicalCellGroupConfig = NULLP;
5569       DU_ALLOC(cellGrpCfg.physicalCellGroupConfig, sizeof(PhysicalCellGroupConfig_t));
5570       if(!cellGrpCfg.physicalCellGroupConfig)
5571       {
5572          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildDuToCuRrcContainer");
5573          ret = RFAILED;
5574          break;
5575       }
5576       if(BuildPhyCellGrpCfg(cellGrpCfg.physicalCellGroupConfig) != ROK)
5577       {
5578          DU_LOG("\nERROR  -->  F1AP : BuildPhyCellGrpCfg failed");
5579          ret = RFAILED;
5580          break;
5581       }
5582
5583       cellGrpCfg.spCellConfig = NULLP;
5584       DU_ALLOC(cellGrpCfg.spCellConfig, sizeof(SpCellConfig_t));
5585       if(!cellGrpCfg.spCellConfig)
5586       {
5587          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildDuToCuRrcContainer");
5588          ret = RFAILED;
5589          break;
5590       }
5591       if(BuildSpCellCfg(cellGrpCfg.spCellConfig) != ROK)
5592       {
5593          DU_LOG("\nERROR  -->  F1AP : BuildSpCellCfg failed");
5594          ret = RFAILED;
5595          break;
5596       }
5597
5598       cellGrpCfg.sCellToAddModList = NULLP;
5599       cellGrpCfg.sCellToReleaseList = NULLP;
5600       cellGrpCfg.ext1 = NULLP;
5601
5602       /* encode cellGrpCfg into duToCuRrcContainer */
5603       xer_fprint(stdout, &asn_DEF_CellGroupConfigRrc, &cellGrpCfg);
5604       memset(encBuf, 0, ENC_BUF_MAX_LEN);
5605       encBufSize = 0;
5606       encRetVal = aper_encode(&asn_DEF_CellGroupConfigRrc, 0, &cellGrpCfg, PrepFinalEncBuf, encBuf);
5607       /* Encode results */
5608       if(encRetVal.encoded == ENCODE_FAIL)
5609       {
5610          DU_LOG( "\nERROR  --> F1AP : Could not encode DuToCuRrcContainer (at %s)\n",\
5611                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
5612          ret = RFAILED;
5613          break;
5614       }
5615       else
5616       {
5617          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for DuToCuRrcContainer\n");
5618          for(int i=0; i< encBufSize; i++)
5619          {
5620             printf("%x",encBuf[i]);
5621          }
5622       }
5623
5624       duToCuRrcContainer->size = encBufSize;
5625       DU_ALLOC(duToCuRrcContainer->buf, duToCuRrcContainer->size);
5626       if(!duToCuRrcContainer->buf)
5627       {
5628          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDuToCuRrcContainer");
5629          ret = RFAILED;
5630          break;
5631       }
5632       if(ret == ROK)
5633       {
5634          memcpy(duToCuRrcContainer->buf, encBuf, duToCuRrcContainer->size);
5635       }
5636       break;
5637    }
5638    FreeMemDuToCuRrcCont(&cellGrpCfg);
5639    return ret;
5640 }
5641
5642 /*******************************************************************
5643  *
5644  * @brief Free memory allocated in InitialULRRCMessage
5645  *
5646  * @details
5647  *
5648  *    Function : freeInitUlRrcMsgTransfer
5649  *
5650  *    Functionality: Free memory allocated in InitialULRRCMessage
5651  *
5652  * @params[in]F1AP_PDU_t  *f1apMsg)
5653  *
5654  * @return ROK     - success
5655  *         RFAILED - failure
5656  *
5657  * ****************************************************************/
5658
5659 uint8_t freeInitUlRrcMsgTransfer(F1AP_PDU_t  *f1apMsg)
5660 {
5661    uint8_t ieIdx, arrIdx;
5662    InitialULRRCMessageTransfer_t *initULRRCMsg=NULLP;
5663
5664    if(f1apMsg)
5665    {
5666       if(f1apMsg->choice.initiatingMessage)
5667       {
5668          initULRRCMsg = &f1apMsg->choice.initiatingMessage->value.\
5669             choice.InitialULRRCMessageTransfer;
5670          if(initULRRCMsg->protocolIEs.list.array)
5671          {
5672             for(ieIdx = 0; ieIdx < initULRRCMsg->protocolIEs.list.count; ieIdx++)
5673             {
5674                switch(initULRRCMsg->protocolIEs.list.array[ieIdx]->id)
5675                {
5676                   case ProtocolIE_ID_id_NRCGI:
5677                   {
5678                      if(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.pLMN_Identity.buf)
5679                      {
5680                         if(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.nRCellIdentity.buf)
5681                         {
5682                            DU_FREE(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.nRCellIdentity.buf,\
5683                            initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.nRCellIdentity.size);
5684                         }
5685                         DU_FREE(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.pLMN_Identity.buf,\
5686                         initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.pLMN_Identity.size);
5687                      }
5688                      break;
5689                   }
5690                   case ProtocolIE_ID_id_RRCContainer:
5691                   {
5692                      if(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf)
5693                      {
5694                         DU_FREE(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf,\
5695                         initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.size);
5696                      }
5697                      break;
5698                   }
5699                   case ProtocolIE_ID_id_DUtoCURRCContainer:
5700                   {
5701                      if(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.DUtoCURRCContainer.buf)
5702                      {
5703                         DU_FREE(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.DUtoCURRCContainer.buf,
5704                         initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.DUtoCURRCContainer.size);
5705                      }
5706                      break;
5707                   }
5708                   default:
5709                      break;
5710                }
5711              }
5712              for(arrIdx = 0; arrIdx < ieIdx; arrIdx++)
5713              {
5714                 if(initULRRCMsg->protocolIEs.list.array[arrIdx])
5715                 {
5716                    DU_FREE(initULRRCMsg->protocolIEs.list.array[arrIdx],\
5717                       sizeof(InitialULRRCMessageTransferIEs_t));
5718                 }
5719              }
5720              DU_FREE(initULRRCMsg->protocolIEs.list.array, initULRRCMsg->protocolIEs.list.size);
5721           }
5722          DU_FREE(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
5723       }
5724       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
5725    }
5726    else
5727    {
5728       DU_LOG("\nERROR  -->  DU_APP : Recevied F1ap Pdu is null at freeInitUlRrcMsgTransfer()");
5729       return RFAILED;
5730    }
5731    return ROK;
5732 }
5733
5734 /*******************************************************************
5735  *
5736  * @brief Builds and sends the InitialULRRCMessage
5737  *
5738  * @details
5739  *
5740  *    Function : BuildAndSendInitialRrcMsgTransfer
5741  *
5742  *    Functionality: Constructs the Initial UL RRC Message Transfer and sends
5743  *                   it to the CU through SCTP.
5744  *
5745  * @params[in]
5746  *
5747  * @return ROK     - success
5748  *         RFAILED - failure
5749  *
5750  * ****************************************************************/
5751 uint8_t BuildAndSendInitialRrcMsgTransfer(uint32_t gnbDuUeF1apId, uint16_t crnti,
5752       uint16_t rrcContSize, uint8_t *rrcContainer)
5753 {
5754    uint8_t   ret;
5755    uint8_t   elementCnt;
5756    uint8_t   ieIdx;
5757    asn_enc_rval_t  encRetVal;
5758    F1AP_PDU_t  *f1apMsg = NULLP;
5759    InitialULRRCMessageTransfer_t *initULRRCMsg = NULLP;
5760    memset(&encRetVal, 0, sizeof(asn_enc_rval_t));
5761
5762    while(true)
5763    {
5764       DU_LOG("\n INFO   -->  F1AP : Building RRC Setup Request\n");
5765       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
5766       if(f1apMsg == NULLP)
5767       {
5768          DU_LOG(" ERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
5769          break;
5770       }
5771       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
5772       DU_ALLOC(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
5773       if(f1apMsg->choice.initiatingMessage == NULLP)
5774       {
5775          DU_LOG(" ERROR  -->  F1AP : Memory allocation for  F1AP-PDU failed");
5776          break;
5777       }
5778       f1apMsg->choice.initiatingMessage->procedureCode =\
5779                                                         ProcedureCode_id_InitialULRRCMessageTransfer;
5780       f1apMsg->choice.initiatingMessage->criticality = Criticality_ignore;
5781       f1apMsg->choice.initiatingMessage->value.present = \
5782                                                          InitiatingMessage__value_PR_InitialULRRCMessageTransfer;
5783       initULRRCMsg =\
5784                     &f1apMsg->choice.initiatingMessage->value.choice.InitialULRRCMessageTransfer;
5785       elementCnt = 5;
5786       initULRRCMsg->protocolIEs.list.count = elementCnt;
5787       initULRRCMsg->protocolIEs.list.size = \
5788                                             elementCnt * sizeof(InitialULRRCMessageTransferIEs_t *);
5789       /* Initialize the F1Setup members */
5790       DU_ALLOC(initULRRCMsg->protocolIEs.list.array,initULRRCMsg->protocolIEs.list.size);
5791       if(initULRRCMsg->protocolIEs.list.array == NULLP)
5792       {
5793          DU_LOG(" ERROR  -->  F1AP : Memory allocation for\
5794                RRCSetupRequestMessageTransferIEs failed");
5795          break;
5796       }
5797       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
5798       {
5799          DU_ALLOC(initULRRCMsg->protocolIEs.list.array[ieIdx],\
5800                sizeof(InitialULRRCMessageTransferIEs_t));
5801          if(initULRRCMsg->protocolIEs.list.array[ieIdx] == NULLP)
5802          {
5803             break;
5804          }
5805       }
5806       ieIdx = 0;
5807       /*GNB DU UE F1AP ID*/
5808       initULRRCMsg->protocolIEs.list.array[ieIdx]->id  = \
5809                                                         ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
5810       initULRRCMsg->protocolIEs.list.array[ieIdx]->criticality  = Criticality_reject;
5811       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.present = \
5812                                                                   InitialULRRCMessageTransferIEs__value_PR_GNB_DU_UE_F1AP_ID;
5813       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID = gnbDuUeF1apId;
5814
5815
5816       /*NRCGI*/
5817       ieIdx++;
5818       initULRRCMsg->protocolIEs.list.array[ieIdx]->id  = \
5819                                                         ProtocolIE_ID_id_NRCGI;
5820       initULRRCMsg->protocolIEs.list.array[ieIdx]->criticality  =Criticality_reject;
5821       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.present = \
5822                                                                   InitialULRRCMessageTransferIEs__value_PR_NRCGI;
5823
5824       ret =\
5825            BuildNrcgi(&initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI);
5826       if(ret!=ROK)
5827       {
5828          break;
5829       }
5830
5831       /*CRNTI*/
5832       ieIdx++;
5833       initULRRCMsg->protocolIEs.list.array[ieIdx]->id  = \
5834                                                         ProtocolIE_ID_id_C_RNTI;
5835       initULRRCMsg->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
5836       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.present =\
5837                                                                  InitialULRRCMessageTransferIEs__value_PR_C_RNTI;
5838       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.C_RNTI = crnti;
5839
5840       /*RRCContainer*/
5841       ieIdx++;
5842       initULRRCMsg->protocolIEs.list.array[ieIdx]->id  = \
5843                                                         ProtocolIE_ID_id_RRCContainer;
5844       initULRRCMsg->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
5845       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.present =\
5846                                                                  InitialULRRCMessageTransferIEs__value_PR_RRCContainer;
5847
5848       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.size = rrcContSize;
5849       DU_ALLOC(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf,
5850             initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.size)
5851       if(!initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf)
5852       {
5853          DU_LOG(" ERROR  -->  F1AP : Memory allocation for RRCSetupRequestMessageTransferIEs failed");
5854          break;
5855
5856       }
5857       memcpy(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf, rrcContainer,
5858             initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.size);
5859
5860
5861       /*DUtoCURRCContainer*/
5862       ieIdx++;
5863       initULRRCMsg->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_DUtoCURRCContainer;
5864       initULRRCMsg->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
5865       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.present =\
5866                                                                  InitialULRRCMessageTransferIEs__value_PR_DUtoCURRCContainer;
5867
5868       ret = BuildDuToCuRrcContainer(&initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.DUtoCURRCContainer);
5869       if(ret != ROK)
5870       {
5871          break;
5872       }
5873
5874       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
5875
5876       /* Encode the F1SetupRequest type as APER */
5877       memset(encBuf, 0, ENC_BUF_MAX_LEN);
5878       encBufSize = 0;
5879       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
5880       /* Encode results */
5881       if(encRetVal.encoded == ENCODE_FAIL)
5882       {
5883          DU_LOG( "\nERROR  --> F1AP : Could not encode Initial UL RRC Message Transfer\
5884                structure (at %s)\n",encRetVal.failed_type ? \
5885                encRetVal.failed_type->name : "unknown");
5886          ret = RFAILED;
5887          break;
5888       }
5889       else
5890       {
5891
5892          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for Initial UL RRC\
5893                Message transfer\n");
5894          for(int i=0; i< encBufSize; i++)
5895          {
5896             printf("%x",encBuf[i]);
5897          }
5898       }
5899       /* Sending  msg  */
5900       if(sendF1APMsg() != ROK)
5901       {
5902          DU_LOG("\nERROR  -->  F1AP : Sending Initial UL RRC Message Transfer Failed");
5903          ret = RFAILED;
5904          break;
5905       }
5906       break;
5907    }
5908    freeInitUlRrcMsgTransfer(f1apMsg);
5909    return ret;
5910 }/* End of BuildAndSendInitialRrcMsgTransfer*/
5911
5912 /*****  UE SETUP REQUEST *****/
5913
5914 /*******************************************************************
5915  *
5916  * @brief Free Qos And Snssai Drb Info
5917  *
5918  * @details
5919  *
5920  *    Function : freeDrbQosAndSnssaiInfo
5921  *
5922  *    Functionality: Free Qos And Snssai Drb Info
5923  *
5924  * @params[in] LcCfg *lcCfg,
5925  * @return void
5926  *
5927  * ****************************************************************/
5928 void freeDrbQosAndSnssaiInfo(LcCfg *lcCfg)
5929 {
5930    if(lcCfg->snssai)
5931    {
5932       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->snssai, sizeof(Snssai));
5933    }
5934    if(lcCfg->drbQos)
5935    {
5936       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->drbQos, sizeof(DrbQosInfo));
5937    }
5938 }
5939
5940 /******************************************************************
5941 *
5942 * @brief Function to delete the RLC Lc cfg from UE APP DB
5943 *
5944 * @details
5945 *
5946 *  Function : freeRlcLcCfg
5947 *
5948 *  Functionality: Function to delete the RLC Lc cfg from UE APP DB
5949 *
5950 *
5951  *****************************************************************/
5952
5953 void freeRlcLcCfg(RlcBearerCfg *lcCfg)
5954 {
5955    switch(lcCfg->rlcMode)
5956    {
5957       case RLC_AM :
5958       {
5959          if(lcCfg->u.amCfg)
5960          {
5961             DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->u.amCfg, sizeof(AmBearerCfg));
5962             lcCfg->u.amCfg = NULLP;
5963          }
5964          break;
5965       }
5966       case RLC_UM_BI_DIRECTIONAL :
5967       {
5968          if(lcCfg->u.umBiDirCfg)
5969          {
5970             DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->u.umBiDirCfg, sizeof(UmBiDirBearerCfg));
5971             lcCfg->u.umBiDirCfg = NULLP;
5972          }
5973          break;
5974       }
5975       case RLC_UM_UNI_DIRECTIONAL_UL :
5976       {
5977          if(lcCfg->u.umUniDirUlCfg)
5978          {
5979             DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->u.umUniDirUlCfg, sizeof(UmUniDirUlBearerCfg));
5980             lcCfg->u.umUniDirUlCfg = NULLP;
5981          }
5982          break;
5983
5984       }
5985       case RLC_UM_UNI_DIRECTIONAL_DL :
5986       {
5987          if(lcCfg->u.umUniDirDlCfg)
5988          {
5989             DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->u.umUniDirDlCfg, sizeof(UmUniDirDlBearerCfg));
5990             lcCfg->u.umUniDirDlCfg = NULLP;
5991          }
5992          break;
5993       }
5994       default:
5995          DU_LOG("\nERROR  -->  DU_APP: Invalid Rlc Mode %d at freeRlcLcCfg()", lcCfg->rlcMode);
5996          break;
5997    }
5998    memset(lcCfg, 0, sizeof(LcCfg));
5999 }
6000 /*******************************************************************
6001  *
6002  * @brief Function to free MacLcCfg
6003  *
6004  * @details
6005  *
6006  *    Function : freeMacLcCfg
6007  *
6008  *    Functionality: Function to free MacLcCfg
6009  *
6010  * @params[in] LcCfg *lcCfg,
6011  * @return void
6012  *
6013  * ****************************************************************/
6014
6015 void  freeMacLcCfg(LcCfg *lcCfg)
6016 {
6017     /* Deleting DRBQOS */
6018    if(lcCfg->drbQos)
6019    {
6020       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->drbQos, sizeof(DrbQosInfo));
6021       lcCfg->drbQos = NULLP;
6022    }
6023    /* Deleting SNSSAI */
6024    if(lcCfg->snssai)
6025    {
6026       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->snssai, sizeof(Snssai));
6027       lcCfg->snssai = NULLP;
6028    }
6029    memset(lcCfg, 0, sizeof(LcCfg));
6030 }
6031 /*******************************************************************
6032  *
6033  * @brief Free UE NR Capability received in UE Context setup request
6034  *
6035  * @details
6036  *
6037  *    Function : freeAperDecodeUeNrCapability
6038  *
6039  *    Functionality:
6040  *       Free UE NR Capability received in UE Context setup request
6041  *
6042  * @params[in]
6043  * @return ROK     - success
6044  *         RFAILED - failure
6045  *
6046  * ****************************************************************/
6047 void freeAperDecodeUeNrCapability(void *ueNrCapability)
6048 {
6049    uint8_t arrIdx =0;
6050    FeatureSets_t *featureSets =NULLP;
6051    UE_NR_Capability_t *ueNrCap = (UE_NR_Capability_t *)ueNrCapability;
6052
6053    if(ueNrCap->rf_Parameters.supportedBandListNR.list.array)
6054    {
6055       for(arrIdx = 0; arrIdx < ueNrCap->rf_Parameters.supportedBandListNR.list.count; arrIdx++)
6056       {
6057          if(ueNrCap->rf_Parameters.supportedBandListNR.list.array[arrIdx])
6058             free(ueNrCap->rf_Parameters.supportedBandListNR.list.array[arrIdx]);
6059       }
6060       free(ueNrCap->rf_Parameters.supportedBandListNR.list.array);
6061    }
6062
6063    if(ueNrCap->featureSets)
6064    {
6065       featureSets = ueNrCap->featureSets;
6066       if(featureSets->featureSetsDownlinkPerCC)
6067       {
6068          if(featureSets->featureSetsDownlinkPerCC->list.array)
6069          {
6070             for(arrIdx = 0; arrIdx < featureSets->featureSetsDownlinkPerCC->list.count; arrIdx++)
6071             {
6072                if(featureSets->featureSetsDownlinkPerCC->list.array[arrIdx])
6073                {
6074                   if(featureSets->featureSetsDownlinkPerCC->list.array[arrIdx]->supportedModulationOrderDL)
6075                      free(featureSets->featureSetsDownlinkPerCC->list.array[arrIdx]->supportedModulationOrderDL);
6076                   free(featureSets->featureSetsDownlinkPerCC->list.array[arrIdx]);
6077                }
6078             }
6079             free(featureSets->featureSetsDownlinkPerCC->list.array);
6080          }
6081          free(featureSets->featureSetsDownlinkPerCC);
6082       }
6083       if(featureSets->featureSetsUplinkPerCC)
6084       {
6085          if(featureSets->featureSetsUplinkPerCC->list.array)
6086          {
6087             for(arrIdx = 0; arrIdx < featureSets->featureSetsUplinkPerCC->list.count; arrIdx++)
6088             {
6089                if(featureSets->featureSetsUplinkPerCC->list.array[arrIdx])
6090                {
6091                   if(featureSets->featureSetsUplinkPerCC->list.array[arrIdx]->supportedModulationOrderUL)
6092                      free(featureSets->featureSetsUplinkPerCC->list.array[arrIdx]->supportedModulationOrderUL);
6093                   free(featureSets->featureSetsUplinkPerCC->list.array[arrIdx]);
6094                }
6095             }
6096             free(featureSets->featureSetsUplinkPerCC->list.array);
6097          }
6098          free(featureSets->featureSetsUplinkPerCC);
6099       }
6100       free(ueNrCap->featureSets);
6101    }
6102 }
6103
6104 /*******************************************************************
6105 *
6106 * @brief Function to free PdcchSearchSpcToAddModList
6107          where memory allocated by aper_decoder
6108 *
6109 * @details
6110 *
6111 *    Function : freeAperDecodePdcchSearchSpcToAddModList
6112 *
6113 *    Functionality: Function to free PdcchSearchSpcToAddModList
6114 *
6115 * @params[in] struct PDCCH_Config__searchSpacesToAddModList *searchSpcList
6116 * @return void
6117 *
6118 * ****************************************************************/
6119
6120 void freeAperDecodePdcchSearchSpcToAddModList(struct PDCCH_Config__searchSpacesToAddModList *searchSpcList)
6121 {
6122    uint8_t searchSpcArrIdx=0;
6123    uint8_t searchSpcArrIdx1=0;
6124    struct  SearchSpace *searchSpc=NULLP;
6125
6126
6127    if(searchSpcList->list.array)
6128    {
6129       if(searchSpcList->list.array[searchSpcArrIdx1])
6130       {
6131          searchSpc = searchSpcList->list.array[searchSpcArrIdx1];
6132          if(searchSpc->controlResourceSetId)
6133          {
6134             if(searchSpc->monitoringSlotPeriodicityAndOffset)
6135             {
6136                if(searchSpc->monitoringSymbolsWithinSlot)
6137                {
6138                   if(searchSpc->monitoringSymbolsWithinSlot->buf)
6139                   {
6140                      if(searchSpc->nrofCandidates)
6141                      {
6142                         if(searchSpc->searchSpaceType)
6143                         {
6144                            free(searchSpc->searchSpaceType->choice.ue_Specific);
6145                            free(searchSpc->searchSpaceType);
6146                         }
6147                         free(searchSpc->nrofCandidates);
6148                      }
6149                      free(searchSpc->monitoringSymbolsWithinSlot->buf);
6150                   }
6151                   free(searchSpc->monitoringSymbolsWithinSlot);
6152                }
6153                free(searchSpc->monitoringSlotPeriodicityAndOffset);
6154             }
6155             free(searchSpc->controlResourceSetId);
6156          }
6157       }
6158       for(searchSpcArrIdx = 0; searchSpcArrIdx < searchSpcList->list.count; searchSpcArrIdx++)
6159       {
6160          free(searchSpcList->list.array[searchSpcArrIdx]);
6161       }
6162       free(searchSpcList->list.array);
6163    }
6164 }
6165 /*******************************************************************
6166 *
6167 * @brief Function for free part for the memory allocated by aper_decoder
6168 *
6169 * @details
6170 *
6171 *    Function : freeAperDecodeBWPDlDedPdcchConfig
6172 *
6173 *    Functionality: Function to free BWPDlDedPdcchConfig
6174 *
6175 * @params[in]
6176 * @return void
6177 *
6178 * ****************************************************************/
6179
6180
6181 void freeAperDecodeBWPDlDedPdcchConfig(BWP_DownlinkDedicated_t *dlBwp)
6182 {
6183    uint8_t arrIdx1=0;
6184    uint8_t arrIdx2=0;
6185    struct PDCCH_Config *pdcchCfg=NULLP;
6186    struct ControlResourceSet *controlRSet=NULLP;
6187    struct PDCCH_Config__controlResourceSetToAddModList *controlRSetList=NULLP;
6188
6189    if(dlBwp->pdcch_Config->choice.setup)
6190    {
6191       pdcchCfg=dlBwp->pdcch_Config->choice.setup;
6192       if(pdcchCfg->controlResourceSetToAddModList)
6193       {
6194          controlRSetList = pdcchCfg->controlResourceSetToAddModList;
6195          if(controlRSetList->list.array)
6196          {
6197             controlRSet = controlRSetList->list.array[arrIdx2];
6198             if(controlRSet)
6199             {
6200                if(controlRSet->frequencyDomainResources.buf)
6201                {
6202                   if(controlRSet->pdcch_DMRS_ScramblingID)
6203                   {
6204                      if(pdcchCfg->searchSpacesToAddModList)
6205                      {
6206                         freeAperDecodePdcchSearchSpcToAddModList(pdcchCfg->searchSpacesToAddModList);
6207                         free(pdcchCfg->searchSpacesToAddModList);
6208                      }
6209                      free(controlRSet->pdcch_DMRS_ScramblingID);
6210                   }
6211                   free(controlRSet->frequencyDomainResources.buf);
6212                }
6213             }
6214             for(arrIdx1 = 0; arrIdx1 <controlRSetList->list.count; arrIdx1++)
6215             {
6216                free(controlRSetList->list.array[arrIdx1]);
6217             }
6218             free(controlRSetList->list.array);
6219          }
6220          free(pdcchCfg->controlResourceSetToAddModList);
6221       }
6222       free(dlBwp->pdcch_Config->choice.setup);
6223    }
6224 }
6225 /*******************************************************************
6226 *
6227 * @brief Function to free PdschTimeDomAllocationList
6228 *     where the memory allocated by aper_decoder
6229 *
6230 * @details
6231 *
6232 *    Function : freeAperDecodePdschTimeDomAllocationList
6233 *
6234 *    Functionality: Function to free PdschTimeDomAllocationList
6235 *
6236 * @params[in] struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList
6237 * @return void
6238 *
6239 * ****************************************************************/
6240
6241
6242 void freeAperDecodePdschTimeDomAllocationList( struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList)
6243 {
6244    uint8_t arrIdx=0;
6245
6246    if(timeDomAllocList->choice.setup)
6247    {
6248       if(timeDomAllocList->choice.setup->list.array)
6249       {
6250          for(arrIdx = 0; arrIdx <timeDomAllocList->choice.setup->list.count ; arrIdx++)
6251          {
6252             free(timeDomAllocList->choice.setup->list.array[arrIdx]);
6253          }
6254          free(timeDomAllocList->choice.setup->list.array);
6255       }
6256       free(timeDomAllocList->choice.setup);
6257    }
6258 }
6259
6260 /*******************************************************************
6261 *
6262 * @brief Function to free BWPDlDedPdschConfig
6263 *        where the memory allocated by aper_decoder
6264 *
6265 * @details
6266 *
6267 *    Function : freeAperDecodeBWPDlDedPdschConfig
6268 *
6269 *    Functionality: Function to free BWPDlDedPdschConfig
6270 *
6271 * @params[in] BWP_DownlinkDedicated_t *dlBwp
6272 * @return void
6273 *
6274 * ****************************************************************/
6275
6276
6277 void freeAperDecodeBWPDlDedPdschConfig(BWP_DownlinkDedicated_t *dlBwp)
6278 {
6279    struct PDSCH_Config *pdschCfg=NULLP;
6280    struct PDSCH_Config__prb_BundlingType *prbBndlType=NULLP;
6281    struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList=NULLP;
6282    struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA *dmrsDlCfg=NULLP;
6283
6284    if(dlBwp->pdsch_Config->choice.setup)
6285    {
6286       pdschCfg=dlBwp->pdsch_Config->choice.setup;
6287       if(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA)
6288       {
6289          if(pdschCfg->pdsch_TimeDomainAllocationList)
6290          {
6291             timeDomAllocList=pdschCfg->pdsch_TimeDomainAllocationList;
6292             if(pdschCfg->maxNrofCodeWordsScheduledByDCI)
6293             {
6294                prbBndlType=&pdschCfg->prb_BundlingType;
6295                free(prbBndlType->choice.staticBundling);
6296                free(pdschCfg->maxNrofCodeWordsScheduledByDCI);
6297             }
6298             freeAperDecodePdschTimeDomAllocationList(timeDomAllocList);
6299             free(pdschCfg->pdsch_TimeDomainAllocationList);
6300          }
6301          dmrsDlCfg=pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA;
6302          if(dmrsDlCfg->choice.setup)
6303          {
6304             free(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition);
6305             free(dmrsDlCfg->choice.setup);
6306          }
6307          free(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA);
6308       }
6309       free(dlBwp->pdsch_Config->choice.setup);
6310    }
6311 }
6312 /*******************************************************************
6313 *
6314 * @brief Function to free PuschTimeDomAllocListCfg
6315                  where the memory allocated by aper_decoder
6316 *
6317 * @details
6318 *
6319 *    Function : freeAperDecodePuschTimeDomAllocListCfg
6320 *
6321 *    Functionality: Function to free PuschTimeDomAllocListCfg
6322 *
6323 * @params[in] PUSCH_Config_t *puschCfg
6324 * @return void
6325 *
6326 * ****************************************************************/
6327
6328
6329 void freeAperDecodePuschTimeDomAllocListCfg(PUSCH_Config_t *puschCfg)
6330 {
6331    uint8_t arrIdx=0;
6332    uint8_t arrIdx1=0;
6333    struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList_t=NULLP;
6334
6335    if(puschCfg->pusch_TimeDomainAllocationList)
6336    {
6337       timeDomAllocList_t=puschCfg->pusch_TimeDomainAllocationList;
6338       if(timeDomAllocList_t->choice.setup)
6339       {
6340          if(timeDomAllocList_t->choice.setup->list.array)
6341          {
6342             free(timeDomAllocList_t->choice.setup->list.array[arrIdx1]->k2);
6343             for(arrIdx = 0; arrIdx<timeDomAllocList_t->choice.setup->list.count; arrIdx++)
6344             {
6345                free(timeDomAllocList_t->choice.setup->list.array[arrIdx]);
6346             }
6347             free(timeDomAllocList_t->choice.setup->list.array);
6348          }
6349          free(timeDomAllocList_t->choice.setup);
6350       }
6351       free(puschCfg->transformPrecoder);
6352       free(puschCfg->pusch_TimeDomainAllocationList);
6353    }
6354 }
6355 /*******************************************************************
6356 *
6357 * @brief Function to free InitialUlBWPConfig where memory allocated by aper_decoder
6358 *
6359 * @details
6360 *
6361 *    Function : freeAperDecodeInitialUlBWPConfig
6362 *
6363 *    Functionality: Function to free InitialUlBWPConfig
6364 *
6365 * @params[in]  BWP_UplinkDedicated_t *ulBwp
6366 * @return void
6367 *
6368 * ****************************************************************/
6369
6370
6371 void freeAperDecodeInitialUlBWPConfig(BWP_UplinkDedicated_t *ulBwp)
6372 {
6373    uint8_t  rSetIdx =0;
6374    uint8_t  rsrcIdx =0;
6375    SRS_Config_t   *srsCfg = NULLP;
6376    PUSCH_Config_t *puschCfg = NULLP;
6377    struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA *dmrsUlCfg = NULLP;
6378    struct SRS_Config__srs_ResourceSetToAddModList *rsrcSetList = NULLP;
6379    struct SRS_ResourceSet__srs_ResourceIdList *rsrcIdList = NULLP;
6380    struct SRS_Config__srs_ResourceToAddModList *resourceList = NULLP;
6381
6382    if(ulBwp->pusch_Config)
6383    {
6384       if(ulBwp->pusch_Config->choice.setup)
6385       {
6386          puschCfg=ulBwp->pusch_Config->choice.setup;
6387          if(puschCfg->dataScramblingIdentityPUSCH)
6388          {
6389             if(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA)
6390             {
6391                freeAperDecodePuschTimeDomAllocListCfg(puschCfg);
6392                dmrsUlCfg=puschCfg->dmrs_UplinkForPUSCH_MappingTypeA;
6393                if(dmrsUlCfg->choice.setup)
6394                {
6395                   if(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition)
6396                   {
6397                      if(dmrsUlCfg->choice.setup->transformPrecodingDisabled)
6398                      {
6399                         free(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0);
6400                         free(dmrsUlCfg->choice.setup->transformPrecodingDisabled);
6401                      }
6402                      free(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition);
6403                   }
6404                   free(dmrsUlCfg->choice.setup);
6405                }
6406                free(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA);
6407             }
6408             free(puschCfg->dataScramblingIdentityPUSCH);
6409          }
6410          free(ulBwp->pusch_Config->choice.setup);
6411       }
6412       free(ulBwp->pusch_Config);
6413
6414       /* Free SRS-Config */
6415       if(ulBwp->srs_Config)
6416       {
6417          if(ulBwp->srs_Config->choice.setup)
6418          {
6419             srsCfg = ulBwp->srs_Config->choice.setup;
6420
6421             /* Free Resource Set to add/mod list */
6422             if(srsCfg->srs_ResourceSetToAddModList)
6423             {
6424                rsrcSetList = srsCfg->srs_ResourceSetToAddModList;
6425                if(rsrcSetList->list.array)
6426                {
6427                   rSetIdx = 0;
6428
6429                   /* Free SRS resource Id list in this SRS resource set */
6430                   if(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList)
6431                   {
6432                      rsrcIdList =
6433                         rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList;
6434
6435                      if(rsrcIdList->list.array)
6436                      {
6437                         for(rsrcIdx = 0; rsrcIdx < rsrcIdList->list.count;
6438                               rsrcIdx++)
6439                         {
6440                            free(rsrcIdList->list.array[rsrcIdx]);
6441                         }
6442                         free(rsrcIdList->list.array);
6443                      }
6444                      free(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList);
6445                   }
6446
6447                   /* Free resource type info for this SRS resource set */
6448
6449                   free(rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic);
6450
6451                   /* Free memory for each resource set */
6452                   for(rSetIdx = 0; rSetIdx < rsrcSetList->list.count; rSetIdx++)
6453                   {
6454                      free(rsrcSetList->list.array[rSetIdx]);
6455                   }
6456                   free(rsrcSetList->list.array);
6457                }
6458                free(srsCfg->srs_ResourceSetToAddModList);
6459             }
6460
6461             /* Free resource to add/modd list */
6462             if(srsCfg->srs_ResourceToAddModList)
6463             {
6464                resourceList = srsCfg->srs_ResourceToAddModList;
6465                if(resourceList->list.array)
6466                {
6467                   rsrcIdx = 0;
6468
6469                   free(resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2);
6470                   free(resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic);
6471
6472                   for(rsrcIdx = 0; rsrcIdx < resourceList->list.count; rsrcIdx++)
6473                   {
6474                      free(resourceList->list.array[rsrcIdx]);
6475                   }
6476                   free(resourceList->list.array);
6477                }
6478                free(srsCfg->srs_ResourceToAddModList);
6479             }
6480
6481             free(ulBwp->srs_Config->choice.setup);
6482          }
6483          free(ulBwp->srs_Config);
6484       }
6485    }
6486 }
6487 /*******************************************************************
6488 *
6489 * @brief Function to free initialUplinkBWPConfig where memory allocated by aper_decoder
6490 *
6491 * @details
6492 *
6493 *    Function : freeAperDecodeinitialUplinkBWPConfig
6494 *
6495 *    Functionality: Function to free initialUplinkBWPConfig
6496 *
6497 * @params[in] UplinkConfig_t *ulCfg
6498 * @return void
6499 *
6500 * ****************************************************************/
6501
6502
6503 void freeAperDecodeinitialUplinkBWPConfig(UplinkConfig_t *ulCfg)
6504 {
6505    BWP_UplinkDedicated_t *ulBwp=NULLP;
6506    struct UplinkConfig__pusch_ServingCellConfig *puschCfg=NULLP;
6507
6508    if(ulCfg->initialUplinkBWP)
6509    {
6510       ulBwp=ulCfg->initialUplinkBWP;
6511       if(ulCfg->firstActiveUplinkBWP_Id)
6512       {
6513          if(ulCfg->pusch_ServingCellConfig)
6514          {
6515             puschCfg=ulCfg->pusch_ServingCellConfig;
6516             if(puschCfg->choice.setup)
6517             {
6518                if(puschCfg->choice.setup->ext1)
6519                {
6520                   free(puschCfg->choice.setup->ext1->processingType2Enabled);
6521                   free(puschCfg->choice.setup->ext1->maxMIMO_Layers);
6522                   free(puschCfg->choice.setup->ext1);
6523                }
6524                free(puschCfg->choice.setup);
6525             }
6526             free(ulCfg->pusch_ServingCellConfig);
6527          }
6528          free(ulCfg->firstActiveUplinkBWP_Id);
6529       }
6530       freeAperDecodeInitialUlBWPConfig(ulBwp);
6531       free(ulCfg->initialUplinkBWP);
6532    }
6533 }
6534
6535 /*******************************************************************
6536  *
6537  * @brief Function to free DuUeCfg
6538  *
6539  * @details
6540  *
6541  *    Function : freeDuUeCfg
6542  *
6543  *    Functionality: Function to free DuUeCfg
6544  *
6545  * @params[in] DuUeCfg *ueCfg
6546  * @return void
6547  *
6548  * ****************************************************************/
6549 void freeDuUeCfg(DuUeCfg *ueCfg)
6550 {
6551    uint8_t lcIdx = 0;
6552    uint8_t arrIdx = 0;
6553    SpCellConfig_t *spCellCfg = NULLP;
6554    ServingCellConfig_t *srvCellCfg = NULLP;
6555    BWP_DownlinkDedicated_t *dlBwp = NULLP;
6556    MAC_CellGroupConfig_t *macCellGrpCfg = NULLP;
6557    PhysicalCellGroupConfig_t *phyCellGrpCfg = NULLP;
6558    struct CellGroupConfigRrc__rlc_BearerToAddModList *rlcBearerList = NULLP;
6559    struct RLC_Config *rlcConfig = NULLP;
6560    struct LogicalChannelConfig *macLcConfig = NULLP;
6561    struct SchedulingRequestConfig *schedulingRequestConfig = NULLP;
6562    struct SchedulingRequestConfig__schedulingRequestToAddModList *schReqList = NULLP;
6563    struct TAG_Config *tagConfig = NULLP;
6564    struct TAG_Config__tag_ToAddModList *tagList = NULLP;
6565    struct MAC_CellGroupConfig__phr_Config *phrConfig = NULLP;
6566    struct ServingCellConfig__pdsch_ServingCellConfig *pdschCfg = NULLP;
6567    CellGroupConfigRrc_t *cellGrpCfg = ueCfg->cellGrpCfg;
6568
6569    if(ueCfg->ueNrCapability)
6570    {
6571       freeAperDecodeUeNrCapability(ueCfg->ueNrCapability);
6572       DU_FREE(ueCfg->ueNrCapability, sizeof(UE_NR_Capability_t));
6573       ueCfg->ueNrCapability = NULLP;
6574    }
6575
6576    if(ueCfg->cellGrpCfg)
6577    {
6578
6579       rlcBearerList = cellGrpCfg->rlc_BearerToAddModList;
6580       if(rlcBearerList)
6581       {
6582          if(rlcBearerList->list.array)
6583          {
6584             for(arrIdx=0; arrIdx<rlcBearerList->list.count; arrIdx++)
6585             {
6586                if(rlcBearerList->list.array[arrIdx])
6587                {
6588                   rlcConfig   = rlcBearerList->list.array[arrIdx]->rlc_Config;
6589                   macLcConfig = rlcBearerList->list.array[arrIdx]->mac_LogicalChannelConfig;
6590
6591                   if(rlcBearerList->list.array[arrIdx]->servedRadioBearer)
6592                   {
6593                      free(rlcBearerList->list.array[arrIdx]->servedRadioBearer);
6594                   }
6595                   if(rlcConfig)
6596                   {
6597                      if(rlcConfig->choice.am)
6598                      {
6599                         free(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength);
6600                         free(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength);
6601                         free(rlcConfig->choice.am);
6602                      }
6603                      free(rlcBearerList->list.array[arrIdx]->rlc_Config);
6604                   }
6605                   if(macLcConfig)
6606                   {
6607                      if(macLcConfig->ul_SpecificParameters)
6608                      {
6609                         free(macLcConfig->ul_SpecificParameters->schedulingRequestID);
6610                         free(macLcConfig->ul_SpecificParameters->logicalChannelGroup);
6611                         free(macLcConfig->ul_SpecificParameters);
6612                      }
6613                      free(rlcBearerList->list.array[arrIdx]->mac_LogicalChannelConfig);
6614                   }
6615                   free(rlcBearerList->list.array[arrIdx]);
6616                }
6617             }
6618             free(rlcBearerList->list.array);
6619          }
6620          free(cellGrpCfg->rlc_BearerToAddModList);
6621       }
6622
6623       macCellGrpCfg = cellGrpCfg->mac_CellGroupConfig;
6624       if(macCellGrpCfg)
6625       {
6626          schedulingRequestConfig = macCellGrpCfg->schedulingRequestConfig;
6627          if(schedulingRequestConfig)
6628          {
6629             schReqList = schedulingRequestConfig->schedulingRequestToAddModList;
6630             if(schReqList)
6631             {
6632                if(schReqList->list.array)
6633                {
6634                   for(arrIdx=0;arrIdx<schReqList->list.count; arrIdx++)
6635                   {
6636                      if(schReqList->list.array[arrIdx])
6637                      {
6638                         free(schReqList->list.array[arrIdx]->sr_ProhibitTimer);
6639                         free(schReqList->list.array[arrIdx]);
6640                      }
6641                   }
6642                   free(schReqList->list.array);
6643                }
6644                free(schedulingRequestConfig->schedulingRequestToAddModList);
6645             }
6646             free(macCellGrpCfg->schedulingRequestConfig);
6647          }
6648          if(macCellGrpCfg->bsr_Config)
6649          {
6650             free(macCellGrpCfg->bsr_Config);
6651          }
6652          tagConfig = macCellGrpCfg->tag_Config;
6653          if(tagConfig)
6654          {
6655             tagList = tagConfig->tag_ToAddModList;
6656             if(tagList)
6657             {
6658                if(tagList->list.array)
6659                {
6660                   for(arrIdx=0; arrIdx<tagList->list.count; arrIdx++)
6661                   {
6662                      free(tagList->list.array[arrIdx]);
6663                   }
6664                   free(tagList->list.array);
6665                }
6666                free(tagConfig->tag_ToAddModList);
6667             }
6668             free(tagConfig);
6669          }
6670
6671          phrConfig = macCellGrpCfg->phr_Config;
6672          if(phrConfig)
6673          {
6674             free(phrConfig->choice.setup);
6675             free(phrConfig);
6676          }
6677
6678          free(macCellGrpCfg);
6679       }
6680
6681       phyCellGrpCfg = cellGrpCfg->physicalCellGroupConfig;
6682       if(phyCellGrpCfg)
6683       {
6684          free(phyCellGrpCfg->p_NR_FR1);
6685          free(phyCellGrpCfg);
6686       }
6687
6688       spCellCfg = cellGrpCfg->spCellConfig;
6689       if(spCellCfg)
6690       {
6691          if(spCellCfg->servCellIndex)
6692          {
6693             if(spCellCfg->rlmInSyncOutOfSyncThreshold)
6694             {
6695                if(spCellCfg->spCellConfigDedicated)
6696                {
6697                   srvCellCfg = spCellCfg->spCellConfigDedicated;
6698                   if(srvCellCfg->initialDownlinkBWP)
6699                   {
6700                      dlBwp = srvCellCfg->initialDownlinkBWP;
6701                      if(srvCellCfg->firstActiveDownlinkBWP_Id)
6702                      {
6703                         if(srvCellCfg->defaultDownlinkBWP_Id)
6704                         {
6705                            if(srvCellCfg->uplinkConfig)
6706                            {
6707
6708                               if(srvCellCfg->pdsch_ServingCellConfig)
6709                               {
6710                                  pdschCfg=
6711                                     srvCellCfg->pdsch_ServingCellConfig;
6712                                  if(pdschCfg->choice.setup)
6713                                  {
6714
6715                                     free(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH);
6716                                     free(pdschCfg->choice.setup);
6717                                  }
6718
6719                                  free(srvCellCfg->pdsch_ServingCellConfig);
6720                               }
6721
6722                               freeAperDecodeinitialUplinkBWPConfig(srvCellCfg->uplinkConfig);
6723                               free(srvCellCfg->uplinkConfig);
6724                            }
6725                            free(srvCellCfg->defaultDownlinkBWP_Id);
6726                         }
6727
6728                         free(srvCellCfg->firstActiveDownlinkBWP_Id);
6729                      }
6730                      if(dlBwp->pdcch_Config)
6731                      {
6732                         if(dlBwp->pdsch_Config)
6733                         {
6734                            freeAperDecodeBWPDlDedPdschConfig(dlBwp);
6735                            free(dlBwp->pdsch_Config);
6736                         }
6737                         freeAperDecodeBWPDlDedPdcchConfig(dlBwp);
6738                         free(dlBwp->pdcch_Config);
6739                      }
6740                      free(srvCellCfg->initialDownlinkBWP);
6741                   }
6742
6743                   free(spCellCfg->spCellConfigDedicated);
6744                }
6745                free(spCellCfg->rlmInSyncOutOfSyncThreshold);
6746             }
6747             free(spCellCfg->servCellIndex);
6748          }
6749          free(spCellCfg);
6750       }
6751       DU_FREE(ueCfg->cellGrpCfg, sizeof(CellGroupConfigRrc_t));
6752       ueCfg->cellGrpCfg = NULLP;
6753    }
6754    if(ueCfg->ambrCfg)
6755    {
6756       memset(ueCfg->ambrCfg, 0, sizeof(AmbrCfg));
6757       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, ueCfg->ambrCfg, sizeof(AmbrCfg));
6758    }
6759    for(lcIdx = 0; lcIdx < ueCfg->numRlcLcs; lcIdx++)
6760    {
6761       freeRlcLcCfg(&ueCfg->rlcLcCfg[lcIdx]);
6762    }
6763    for(lcIdx = 0; lcIdx < ueCfg->numMacLcs; lcIdx++)
6764    {
6765       freeMacLcCfg(&ueCfg->macLcCfg[lcIdx]);
6766    }
6767    for(lcIdx = 0; lcIdx < ueCfg->numDrb; lcIdx++)
6768    {
6769       DU_FREE(ueCfg->upTnlInfo[lcIdx].tnlCfg1, sizeof(GtpTnlCfg));
6770       memset(&ueCfg->upTnlInfo[lcIdx], 0, sizeof(UpTnlCfg));
6771    }
6772 }
6773
6774 /*******************************************************************
6775  *
6776  * @brief Function to free UecontextSetupDb
6777  *
6778  * @details
6779  *
6780  *    Function : freeF1UeDb
6781  *
6782  *    Functionality: Function to free UecontextSetupDb
6783  *
6784  * @params[in] UecontextSetupDb *
6785  * @return void
6786  *
6787  * ****************************************************************/
6788
6789 void freeF1UeDb(F1UeContextSetupDb *f1UeDb)
6790 {
6791
6792    if(f1UeDb->dlRrcMsg)
6793    {
6794       if(f1UeDb->dlRrcMsg->rrcMsgPdu)
6795       {
6796          DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL,\
6797             f1UeDb->dlRrcMsg->rrcMsgPdu, f1UeDb->dlRrcMsg->rrcMsgSize);
6798       }
6799       memset(f1UeDb->dlRrcMsg, 0, sizeof(F1DlRrcMsg));
6800    }
6801    freeDuUeCfg(&f1UeDb->duUeCfg);
6802    memset(f1UeDb, 0, sizeof(F1UeContextSetupDb));
6803    DU_FREE(f1UeDb, sizeof(F1UeContextSetupDb));
6804 }
6805
6806 /*******************************************************************
6807  *
6808  * @brief Function to build Am cfg Info
6809  *
6810  * @details
6811  *
6812  *    Function : extractRlcAmCfg
6813  *
6814  *    Functionality: Function to build Am cfg Info
6815  *
6816  * @params[in] AmBearerCfg *
6817  *             void *
6818  *
6819  * @return ROK/RFAILED
6820  *
6821  * ****************************************************************/
6822
6823 void extractRlcAmCfg(AmBearerCfg *amCfgToSet, struct RLC_Config__am *rlcAmCfg)
6824 {
6825    if(rlcAmCfg)
6826    {
6827       /* UL AM */
6828       if(rlcAmCfg->dl_AM_RLC.sn_FieldLength)
6829       {
6830          amCfgToSet->ulAmCfg.snLenUl = *(rlcAmCfg->dl_AM_RLC.sn_FieldLength);
6831          /*TODO: Check the timer value when sent by real CU */
6832          amCfgToSet->ulAmCfg.reAssemTmr = rlcAmCfg->dl_AM_RLC.t_Reassembly;
6833          amCfgToSet->ulAmCfg.statProhTmr = rlcAmCfg->dl_AM_RLC.t_StatusProhibit;
6834       }
6835
6836       /* DL AM */
6837       if(rlcAmCfg->ul_AM_RLC.sn_FieldLength)
6838       {
6839          amCfgToSet->dlAmCfg.snLenDl = *(rlcAmCfg->ul_AM_RLC.sn_FieldLength);
6840          amCfgToSet->dlAmCfg.pollRetxTmr = rlcAmCfg->ul_AM_RLC.t_PollRetransmit;
6841          amCfgToSet->dlAmCfg.pollPdu   = rlcAmCfg->ul_AM_RLC.pollPDU;
6842          amCfgToSet->dlAmCfg.pollByte  = rlcAmCfg->ul_AM_RLC.pollByte;
6843          amCfgToSet->dlAmCfg.maxRetxTh = rlcAmCfg->ul_AM_RLC.maxRetxThreshold;
6844       }
6845    }
6846 }
6847
6848 /*******************************************************************
6849  *
6850  * @brief Function to build Um Bi Info
6851  *
6852  * @details
6853  *
6854  *    Function : extractRlcUmBiCfg
6855  *
6856  *    Functionality: Function to build Um Bi Info
6857  *
6858  * @params[in] UmBiDirBearerCfg *
6859  *             void *
6860  *
6861  * @return ROK/RFAILED
6862  *
6863  * ****************************************************************/
6864
6865 void extractRlcUmBiCfg(UmBiDirBearerCfg *umBiCfgToSet, struct RLC_Config__um_Bi_Directional *rlcBiCfg)
6866 {
6867    if(rlcBiCfg)
6868    {
6869       /* UL UM BI DIR Cfg */
6870       if(rlcBiCfg->dl_UM_RLC.sn_FieldLength)
6871       {
6872          umBiCfgToSet->ulUmCfg.snLenUlUm  = *(rlcBiCfg->dl_UM_RLC.sn_FieldLength);
6873          umBiCfgToSet->ulUmCfg.reAssemTmr = rlcBiCfg->dl_UM_RLC.t_Reassembly;
6874       }
6875
6876       /* DL UM BI DIR Cfg */
6877       if(rlcBiCfg->ul_UM_RLC.sn_FieldLength)
6878          umBiCfgToSet->dlUmCfg.snLenDlUm  = *(rlcBiCfg->ul_UM_RLC.sn_FieldLength);
6879    }
6880 }
6881
6882 /*******************************************************************
6883  *
6884  * @brief Function to build Um Ul Info
6885  *
6886  * @details
6887  *
6888  *    Function : extractRlcUmUlCfg
6889  *
6890  *    Functionality: Function to build Um Ul Info
6891  *
6892  * @params[in] UmUniDirUlBearerCfg *
6893  *             void *
6894  *
6895  * @return ROK/RFAILED
6896  *
6897  * ****************************************************************/
6898
6899 void extractRlcUmUlCfg(UmUniDirUlBearerCfg *umUlCfgToSet, struct RLC_Config__um_Uni_Directional_DL *umUlCfg)
6900 {
6901    if(umUlCfg)
6902    {
6903       if(umUlCfg->dl_UM_RLC.sn_FieldLength)
6904       {
6905          umUlCfgToSet->ulUmCfg.snLenUlUm  = *(umUlCfg->dl_UM_RLC.sn_FieldLength);
6906          umUlCfgToSet->ulUmCfg.reAssemTmr = umUlCfg->dl_UM_RLC.t_Reassembly;
6907       }
6908    }
6909 }
6910
6911 /*******************************************************************
6912  *
6913  * @brief Function to build Um Uni Dl Info
6914  *
6915  * @details
6916  *
6917  *    Function : extractRlcUmDlCfg
6918  *
6919  *    Functionality: Function to build Um Uni Dl Info
6920  *
6921  * @params[in] UmUniDirDlBearerCfg *
6922  *             void *
6923  *
6924  * @return ROK/RFAILED
6925  *
6926  * ****************************************************************/
6927 void extractRlcUmDlCfg(UmUniDirDlBearerCfg *umDlCfgToSet, struct RLC_Config__um_Uni_Directional_UL *umDlCfg)
6928 {
6929    if(umDlCfg)
6930    {
6931       if(umDlCfg->ul_UM_RLC.sn_FieldLength)
6932          umDlCfgToSet->dlUmCfg.snLenDlUm  = *(umDlCfg->ul_UM_RLC.sn_FieldLength);
6933    }
6934 }
6935
6936 /*******************************************************************
6937  *
6938  * @brief Function to extractRlcModeCfg
6939  *
6940  * @details
6941  *
6942  *    Function : extractRlcModeCfg
6943  *
6944  *    Functionality: Function to extractRlcModeCfg
6945  *
6946  * @params[in] RLC_Config_t *
6947  *             RlcBearerCfg *
6948  *             void  *
6949  * @return ROK/RFAILED
6950  *
6951  * ****************************************************************/
6952 void extractRlcModeCfg(uint8_t rlcMode, RlcBearerCfg *rlcDbCfg, RLC_Config_t *lcCfg)
6953 {
6954    if(lcCfg)
6955    {
6956       switch(rlcMode)
6957       {
6958          case RLC_AM :
6959             {
6960                if(lcCfg->choice.am)
6961                {
6962                   DU_ALLOC_SHRABL_BUF(rlcDbCfg->u.amCfg, sizeof(AmBearerCfg));
6963                   if(rlcDbCfg->u.amCfg)
6964                      extractRlcAmCfg(rlcDbCfg->u.amCfg, lcCfg->choice.am);
6965                }
6966                break;
6967             }
6968          case RLC_UM_BI_DIRECTIONAL :
6969             {
6970                if(lcCfg->choice.um_Bi_Directional)
6971                {
6972                   DU_ALLOC_SHRABL_BUF(rlcDbCfg->u.umBiDirCfg, sizeof(UmBiDirBearerCfg));
6973                   if(rlcDbCfg->u.umBiDirCfg)
6974                      extractRlcUmBiCfg(rlcDbCfg->u.umBiDirCfg, lcCfg->choice.um_Bi_Directional);
6975                }
6976                break;
6977             }
6978          case RLC_UM_UNI_DIRECTIONAL_UL :
6979             {
6980                if(lcCfg->choice.um_Uni_Directional_DL)
6981                {
6982                   DU_ALLOC_SHRABL_BUF(rlcDbCfg->u.umUniDirUlCfg, sizeof(UmUniDirUlBearerCfg));
6983                   if(rlcDbCfg->u.umUniDirUlCfg)
6984                      extractRlcUmUlCfg(rlcDbCfg->u.umUniDirUlCfg, lcCfg->choice.um_Uni_Directional_DL);
6985                }
6986                break;
6987             }
6988          case RLC_UM_UNI_DIRECTIONAL_DL :
6989             {
6990                if(lcCfg->choice.um_Uni_Directional_UL)
6991                {
6992                   DU_ALLOC_SHRABL_BUF(rlcDbCfg->u.umUniDirDlCfg, sizeof(UmUniDirDlBearerCfg));
6993                   if(rlcDbCfg->u.umUniDirDlCfg)
6994                      extractRlcUmDlCfg(rlcDbCfg->u.umUniDirDlCfg, lcCfg->choice.um_Uni_Directional_UL);
6995                }
6996                break;
6997             }
6998          default:
6999             DU_LOG("\nERROR  -->  DUAPP: Invalid rlcMode %d at extractRlcCfgToAddMod()", rlcMode);
7000             break;
7001       }
7002    }
7003 }
7004
7005 /*******************************************************************
7006  *
7007  * @brief Function to extract extractUlLcCfg
7008  *
7009  * @details
7010  *
7011  *    Function : extractUlLcCfg
7012  *
7013  *    Functionality: Function to extract extractUlLcCfg
7014  *
7015  * @params[in] UlLcCfg *f1UlLcCfg, LogicalChannelConfig_t *ulLcCfg
7016  * @return void
7017  *
7018  * ****************************************************************/
7019
7020 void extractUlLcCfg(UlLcCfg *f1UlLcCfg, LogicalChannelConfig_t *ulLcCfg)
7021 {
7022    if(ulLcCfg)
7023    {
7024       if(ulLcCfg->ul_SpecificParameters)
7025       {
7026          f1UlLcCfg->priority = \
7027             ulLcCfg->ul_SpecificParameters->priority;
7028       if(ulLcCfg->ul_SpecificParameters->logicalChannelGroup)
7029       {
7030          f1UlLcCfg->lcGroup = \
7031            *(ulLcCfg->ul_SpecificParameters->logicalChannelGroup);
7032       }
7033       if(ulLcCfg->ul_SpecificParameters->schedulingRequestID)
7034       {
7035          f1UlLcCfg->schReqId = \
7036            *(ulLcCfg->ul_SpecificParameters->schedulingRequestID);
7037       }
7038       f1UlLcCfg->pbr = \
7039          ulLcCfg->ul_SpecificParameters->prioritisedBitRate;
7040       f1UlLcCfg->bsd = \
7041          ulLcCfg->ul_SpecificParameters->bucketSizeDuration;
7042       }
7043    }
7044 }
7045
7046 /*******************************************************************
7047  *
7048  * @brief Function to procRlcLcCfg
7049  *
7050  * @details
7051  *
7052  *    Function : procRlcLcCfg
7053  *
7054  *    Functionality: Function to procRlcLcCfg
7055  *
7056  * @params[in] rbId, lcId, rbType, rlcMod
7057  *             RLC_Config_t *, RlcBearerCfg * ,
7058  * @return void
7059  *
7060  * ****************************************************************/
7061
7062 void procRlcLcCfg(uint8_t rbId, uint8_t lcId, uint8_t rbType, uint8_t rlcMode,\
7063    uint8_t configType, RLC_Config_t *f1RlcCfg, RlcBearerCfg *lcCfg)
7064 {
7065
7066    lcCfg->rbId   = rbId;
7067    lcCfg->configType = configType;
7068
7069    if(rbType == RB_TYPE_SRB)
7070    {
7071       lcCfg->rbType = RB_TYPE_SRB;
7072       lcCfg->lcId   = rbId;
7073       lcCfg->lcType = LCH_DCCH;
7074       lcCfg->rlcMode = RLC_AM;
7075    }
7076    else if(rbType == RB_TYPE_DRB)
7077    {
7078       lcCfg->rbType = RB_TYPE_DRB;
7079       lcCfg->lcId   = lcId;
7080       lcCfg->lcType = LCH_DTCH;
7081       lcCfg->rlcMode = rlcMode;
7082    }
7083    if(f1RlcCfg) /* rlc mode config recived */
7084    {
7085       extractRlcModeCfg(lcCfg->rlcMode, lcCfg, f1RlcCfg);
7086    }
7087 }
7088
7089
7090
7091 /*******************************************************************
7092  *
7093  * @brief Fills DrbQos Info received by CU
7094  *
7095  * @details
7096  *
7097  *    Function : extractQosInfo
7098  *
7099  *    Functionality: Fills DrbQos Info received  by CU
7100  *
7101  * @params[in] DrbQosInfo *qosToAdd,
7102  *             QoSFlowLevelQoSParameters_t *qosFlowCfg
7103  * @return void
7104  *
7105  * ****************************************************************/
7106
7107 void extractQosInfo(DrbQosInfo *qosToAdd, QoSFlowLevelQoSParameters_t *qosFlowCfg)
7108 {
7109    qosToAdd->fiveQiType = qosFlowCfg->qoS_Characteristics.present;
7110    qosToAdd->u.nonDyn5Qi.fiveQi     =\
7111          qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->fiveQI;
7112    if(qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow)
7113    {
7114       qosToAdd->u.nonDyn5Qi.avgWindow = \
7115         *(qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow);
7116    }
7117    qosToAdd->u.nonDyn5Qi.maxDataBurstVol = \
7118       *(qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume);
7119    if(qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->qoSPriorityLevel)
7120    {
7121       qosToAdd->u.nonDyn5Qi.priorLevel = \
7122          *(qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->qoSPriorityLevel);
7123    }
7124    qosToAdd->ngRanRetPri.priorityLevel = \
7125       qosFlowCfg->nGRANallocationRetentionPriority.priorityLevel;
7126    qosToAdd->ngRanRetPri.preEmptionCap = \
7127       qosFlowCfg->nGRANallocationRetentionPriority.pre_emptionCapability;
7128    qosToAdd->ngRanRetPri.preEmptionVul = \
7129       qosFlowCfg->nGRANallocationRetentionPriority.pre_emptionVulnerability;
7130    if(qosFlowCfg->gBR_QoS_Flow_Information)
7131    {
7132       memcpy(&qosToAdd->grbQosInfo.maxFlowBitRateDl, \
7133          qosFlowCfg->gBR_QoS_Flow_Information->maxFlowBitRateDownlink.buf, \
7134          qosFlowCfg->gBR_QoS_Flow_Information->maxFlowBitRateDownlink.size);
7135       memcpy(&qosToAdd->grbQosInfo.maxFlowBitRateUl, \
7136          qosFlowCfg->gBR_QoS_Flow_Information->maxFlowBitRateUplink.buf, \
7137          qosFlowCfg->gBR_QoS_Flow_Information->maxFlowBitRateUplink.size);
7138       memcpy(&qosToAdd->grbQosInfo.guarFlowBitRateDl,\
7139          qosFlowCfg->gBR_QoS_Flow_Information->guaranteedFlowBitRateDownlink.buf, \
7140          qosFlowCfg->gBR_QoS_Flow_Information->guaranteedFlowBitRateDownlink.size);
7141       memcpy(&qosToAdd->grbQosInfo.guarFlowBitRateUl,\
7142          qosFlowCfg->gBR_QoS_Flow_Information->guaranteedFlowBitRateUplink.buf, \
7143          qosFlowCfg->gBR_QoS_Flow_Information->guaranteedFlowBitRateUplink.size);
7144    }
7145    qosToAdd->pduSessionId = 0;
7146    qosToAdd->ulPduSessAggMaxBitRate = 0;
7147 }
7148
7149 /*******************************************************************
7150  *
7151  * @brief Function to extract GTP Tunnel Info from CU
7152  *
7153  * @details
7154  *
7155  *    Function : extractUpTnlInfo
7156  *
7157  *    Functionality: Function to extract GTP Tunnel Info from CU
7158  *
7159  * @params[in] F1AP message
7160  * @return ROK/RFAILED
7161  *
7162  * ****************************************************************/
7163
7164 uint8_t extractUpTnlInfo(uint8_t drbId, uint8_t configType,\
7165    ULUPTNLInformation_ToBeSetup_List_t *tnlInfo, UpTnlCfg *upTnlInfo)
7166 {
7167    uint8_t tnlIdx;
7168    uint32_t ipv4_du = 0;
7169    GTPTunnel_t *gtpTunnel = NULLP;
7170
7171    upTnlInfo->drbId = drbId;
7172    upTnlInfo->configType = configType;
7173 #ifdef O1_ENABLE
7174    cmInetAddr((S8*)g_cfg.DU_IPV4_Addr, &ipv4_du);
7175 #else
7176    cmInetAddr((char *)DU_IP_V4_ADDR, &ipv4_du);
7177 #endif
7178
7179    for(tnlIdx=0; tnlIdx < tnlInfo->list.count; tnlIdx++)
7180    {
7181       if(tnlInfo->list.array[tnlIdx]->uLUPTNLInformation.present == UPTransportLayerInformation_PR_gTPTunnel)
7182       {
7183          if(tnlInfo->list.array[tnlIdx]->uLUPTNLInformation.choice.gTPTunnel)
7184          {
7185             gtpTunnel = tnlInfo->list.array[tnlIdx]->uLUPTNLInformation.choice.gTPTunnel;
7186             DU_ALLOC(upTnlInfo->tnlCfg1, sizeof(GtpTnlCfg));
7187             if(upTnlInfo->tnlCfg1 == NULLP)
7188             {
7189                DU_LOG("\nERROR  -->  F1AP : extractUpTnlInfo: Failed to allocate mmeory for tunnel cfg 1");
7190                return RFAILED;
7191             }
7192             bitStringToInt(&gtpTunnel->transportLayerAddress, &upTnlInfo->tnlCfg1->ulTnlAddress);
7193             upTnlInfo->tnlCfg1->dlTnlAddress = ipv4_du;
7194             if(gtpTunnel->gTP_TEID.size > 0)
7195             {
7196                teIdStringToInt(gtpTunnel->gTP_TEID.buf, &upTnlInfo->tnlCfg1->teId);
7197             }
7198          }
7199          break;
7200       }
7201    }
7202    return ROK;
7203 }
7204 /*******************************************************************
7205 *
7206 * @brief Function to extract Drb Qos Cfg Info from CU
7207 *
7208 * @details
7209 *
7210 *    Function : extractDrbQosCfg
7211 *
7212 *    Functionality: Function to extract Drb Qos Cfg Info from CU
7213 *
7214 * @params[in] DRB_Information_t *drbInfo, LcCfg *macLcToAdd
7215 * @return ROK/RFAILED
7216 *
7217 * ****************************************************************/
7218
7219 uint8_t extractDrbQosCfg(DRB_Information_t *drbInfo, LcCfg *macLcToAdd )
7220 {
7221    if(!macLcToAdd->drbQos)
7222    {
7223       DU_ALLOC_SHRABL_BUF(macLcToAdd->drbQos, sizeof(DrbQosInfo));
7224       if(macLcToAdd->drbQos == NULLP)
7225       {
7226          DU_LOG("\nERROR  -->  DUAPP:Memory failed at allocating DrbQos at extractDrbCfg()");
7227          return RFAILED;
7228       }
7229
7230    }
7231    if(drbInfo->dRB_QoS.qoS_Characteristics.present == QoS_Characteristics_PR_non_Dynamic_5QI)
7232    {
7233       extractQosInfo(macLcToAdd->drbQos, &drbInfo->dRB_QoS);
7234       macLcToAdd->dlLcCfg.lcp = macLcToAdd->drbQos->ngRanRetPri.priorityLevel;
7235    }
7236    if(!macLcToAdd->snssai)
7237    {
7238       DU_ALLOC_SHRABL_BUF(macLcToAdd->snssai, sizeof(Snssai));
7239       if(macLcToAdd->snssai == NULLP)
7240       {
7241          DU_LOG("\nERROR  -->  DUAPP : Memory failed at allocating SNSSAI at extractDrbCfg()");
7242          return RFAILED;
7243       }
7244    }
7245    memcpy(&macLcToAdd->snssai->sst, drbInfo->sNSSAI.sST.buf, \
7246          drbInfo->sNSSAI.sST.size);
7247    if(drbInfo->sNSSAI.sD)
7248    {
7249       memcpy(macLcToAdd->snssai->sd, drbInfo->sNSSAI.sD->buf, \
7250             drbInfo->sNSSAI.sD->size);
7251    }
7252    return ROK;
7253 }
7254 /*******************************************************************
7255  *
7256  * @brief Function to extract DRB info received from CU
7257  *
7258  * @details
7259  *
7260  *    Function : extractDrbCfg
7261  *
7262  *    Functionality: Function to extract DRB info received from CU
7263  *
7264  * @params[in] F1AP message
7265  * @return void
7266  *
7267  * ****************************************************************/
7268 uint8_t extractDrbCfg(DRBs_ToBeSetup_Item_t *drbItem,DRBs_ToBeSetupMod_Item_t *drbSetupModItem,\
7269 LcCfg *macLcToAdd, UpTnlCfg *upTnlInfo)
7270 {
7271    DRB_Information_t *drbInfo = NULLP;
7272
7273    if(drbItem != NULLP)
7274    {
7275       if(extractUpTnlInfo(drbItem->dRBID, CONFIG_ADD, &drbItem->uLUPTNLInformation_ToBeSetup_List, upTnlInfo) != ROK)
7276       {
7277          DU_LOG("\nERROR  -->  DUAPP : Failed to extract tunnel Cfg at extractDrbCfg()");
7278          return RFAILED;
7279       }
7280       if(drbItem->qoSInformation.present == QoSInformation_PR_choice_extension)
7281       {
7282          if(drbItem->qoSInformation.choice.choice_extension->value.present == QoSInformation_ExtIEs__value_PR_DRB_Information)
7283          {
7284             drbInfo = &drbItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information;
7285             if(extractDrbQosCfg(drbInfo , macLcToAdd) != ROK)
7286             {
7287                DU_LOG("\nERROR  -->  DUAPP : Failed to extract qos Cfg at extractDrbCfg()");
7288                return RFAILED;
7289             }
7290          }
7291       }
7292    }
7293    else if(drbSetupModItem != NULLP)
7294    {
7295       if(extractUpTnlInfo(drbSetupModItem->dRBID, CONFIG_ADD, &drbSetupModItem->uLUPTNLInformation_ToBeSetup_List,\
7296       upTnlInfo) != ROK)
7297       {
7298          DU_LOG("\nERROR  -->  DUAPP : Failed to extract tunnel Cfg at extractDrbCfg()");
7299          return RFAILED;
7300       }
7301       if(drbSetupModItem->qoSInformation.present == QoSInformation_PR_choice_extension)
7302       {
7303          if(drbSetupModItem->qoSInformation.choice.choice_extension->value.present ==\
7304          QoSInformation_ExtIEs__value_PR_DRB_Information)
7305          {
7306             drbInfo = &drbSetupModItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information;
7307             if(extractDrbQosCfg(drbInfo , macLcToAdd) != ROK)
7308             {
7309                DU_LOG("\nERROR  -->  DUAPP : Failed to extract qos Cfg at extractDrbCfg()");
7310                return RFAILED;
7311             }
7312
7313          }
7314       }
7315    }
7316
7317    return ROK;
7318 }
7319
7320 /*******************************************************************
7321  *
7322  * @brief Function to extract RB info received from CU
7323  *
7324  * @details
7325  *
7326  *    Function : extractMacRbCfg
7327  *
7328  *    Functionality: Function to extract RB info received from CU
7329  *
7330  * @params[in] F1AP message
7331  * @return ROK/RFAILED
7332  *
7333  * ****************************************************************/
7334
7335 uint8_t extractMacRbCfg(uint8_t lcId, DRBs_ToBeSetup_Item_t *drbCfg,\
7336 DRBs_ToBeSetupMod_Item_t *drbSetupModCfg,  LogicalChannelConfig_t *ulLcCfg, LcCfg *lcCfg, UpTnlCfg *upTnlInfo)
7337 {
7338    if(drbCfg != NULLP)
7339    {
7340       if(extractDrbCfg(drbCfg, NULL, lcCfg, upTnlInfo) != ROK)
7341       {
7342          DU_LOG("ERROR  -->  F1AP : Failed to build Drb Qos at extractMacRbCfg()");
7343          return RFAILED;
7344       }
7345    }
7346    else if(drbSetupModCfg != NULLP)
7347    {
7348       if(extractDrbCfg(NULL, drbSetupModCfg, lcCfg, upTnlInfo) != ROK)
7349       {
7350          DU_LOG("ERROR  -->  F1AP : Failed to build Drb Qos at extractMacRbCfg()");
7351          return RFAILED;
7352       }
7353    }
7354    else
7355    {
7356       lcCfg->drbQos = NULLP;
7357       lcCfg->snssai = NULLP;
7358       if(lcCfg->lcId == SRB2_LCID)
7359          lcCfg->dlLcCfg.lcp = LC_PRIORITY_3;
7360       else
7361          lcCfg->dlLcCfg.lcp = LC_PRIORITY_1;
7362    }
7363    if(ulLcCfg)
7364    {
7365       lcCfg->ulLcCfgPres = true;
7366       extractUlLcCfg(&lcCfg->ulLcCfg, ulLcCfg);
7367    }
7368    else
7369       lcCfg->ulLcCfgPres = false;
7370    return ROK;
7371 }
7372
7373 /*******************************************************************
7374  *
7375  * @brief Function processing LC config info received from CU
7376  *
7377  * @details
7378  *
7379  *    Function : procMacLcCfg
7380  *
7381  *    Functionality: Function processing LC config info received from CU
7382  *
7383  * @params[in] F1AP message
7384  * @return ROK/RFAILED
7385  *
7386  * ****************************************************************/
7387
7388 uint8_t procMacLcCfg(uint8_t lcId, uint8_t rbType, uint8_t configType,\
7389 DRBs_ToBeSetup_Item_t *drbItem, DRBs_ToBeSetupMod_Item_t *drbSetupModItem, LogicalChannelConfig_t *ulLcCfg,\
7390 LcCfg *lcCfg, UpTnlCfg *upTnlInfo)
7391 {
7392    uint8_t ret = ROK;
7393
7394    lcCfg->lcId = lcId;
7395    lcCfg->configType = configType;
7396    if(rbType == RB_TYPE_SRB)
7397    {
7398       ret = extractMacRbCfg(lcId, NULL,NULL, ulLcCfg, lcCfg, NULL);
7399    }
7400    else if(rbType == RB_TYPE_DRB)
7401    {
7402       if(drbItem != NULL)
7403         ret = extractMacRbCfg(lcId, drbItem, NULL, ulLcCfg, lcCfg, upTnlInfo);
7404       else if(drbSetupModItem != NULL)
7405         ret = extractMacRbCfg(lcId, NULL, drbSetupModItem, ulLcCfg, lcCfg, upTnlInfo);
7406    }
7407    return ret;
7408 }
7409
7410 /*******************************************************************
7411  *
7412  * @brief Function to extract Rlc cfg To Add/Mod in CellGrp Info
7413  *
7414  * @details
7415  *
7416  *    Function : extractRlcCfgToAddMod
7417  *
7418  *    Functionality: Function to extract Rlc cfg To Add/Mod in CellGrp Info
7419  *
7420  * @params[in] CellGroupConfigRrc__rlc_BearerTo pointer
7421  *             DuUeCfg Pointer
7422  * @return ROK/RFAILED
7423  *
7424  * ****************************************************************/
7425
7426 uint8_t extractRlcCfgToAddMod(struct CellGroupConfigRrc__rlc_BearerToAddModList *lcCfg, DuUeCfg *ueCfgDb)
7427 {
7428   uint8_t idx, rbId, lcId, rlcMode, rbType;
7429   RLC_Config_t *f1RlcCfg = NULLP;
7430   LogicalChannelConfig_t *macUlLcCfg = NULLP;
7431
7432   for(idx = 0; idx < lcCfg->list.count; idx++)
7433   {
7434      lcId = lcCfg->list.array[idx]->logicalChannelIdentity;
7435      if(lcCfg->list.array[idx]->servedRadioBearer)
7436      {
7437         /* RadioBearer for SRB/DRB */
7438         if(lcCfg->list.array[idx]->servedRadioBearer->present ==\
7439         RLC_BearerConfig__servedRadioBearer_PR_srb_Identity)
7440         {
7441            rbId = lcCfg->list.array[idx]->servedRadioBearer->choice.srb_Identity;
7442            rbType = RB_TYPE_SRB;
7443         }
7444         else if(lcCfg->list.array[idx]->servedRadioBearer->present ==\
7445         RLC_BearerConfig__servedRadioBearer_PR_drb_Identity)
7446         {
7447            rbId = lcCfg->list.array[idx]->servedRadioBearer->choice.drb_Identity;
7448            rbType = RB_TYPE_DRB;
7449         }
7450         else
7451         {
7452            DU_LOG("\nERROR  -->  No components present in Bearer config to ADD/MOD");
7453            return RFAILED;
7454         }
7455         /* MAC UL LC Config */
7456         if(lcCfg->list.array[idx]->mac_LogicalChannelConfig)
7457         {
7458            macUlLcCfg = lcCfg->list.array[idx]->mac_LogicalChannelConfig;
7459         }
7460      }
7461      else
7462      {
7463         DU_LOG("\nERROR  -->  DUAPP: Received RadioBearer config is NULL");
7464         return RFAILED;
7465      }
7466      /* RLC Mode Config */
7467      if(lcCfg->list.array[idx]->rlc_Config)
7468      {
7469         rlcMode  = lcCfg->list.array[idx]->rlc_Config->present;
7470         f1RlcCfg = lcCfg->list.array[idx]->rlc_Config;
7471      }
7472
7473      /* Filling RLC/MAC Config*/
7474      memset(&ueCfgDb->macLcCfg[idx], 0, sizeof(LcCfg));
7475      memset(&ueCfgDb->rlcLcCfg[idx], 0, sizeof(RlcBearerCfg));
7476      procRlcLcCfg(rbId, lcId, rbType, rlcMode, CONFIG_UNKNOWN, f1RlcCfg, &(ueCfgDb->rlcLcCfg[idx]));
7477      if(procMacLcCfg(lcId, rbType, CONFIG_UNKNOWN, NULL, NULL, macUlLcCfg, &ueCfgDb->macLcCfg[idx], NULL) != ROK)
7478      {
7479         DU_LOG("\nERROR  -->  DU APP : Failed while filling MAC LC config at extractRlcCfgToAddMod()");
7480         return RFAILED;
7481      }
7482      (ueCfgDb->numRlcLcs)++;
7483      (ueCfgDb->numMacLcs)++;
7484   }
7485   //TODO: To send the failure cause in UeContextSetupRsp
7486   return ROK;
7487 }
7488
7489 /*******************************************************************
7490  *
7491  * @brief DeAlloc pdsch serv cell config info
7492  *
7493  * @details
7494  *
7495  *    Function : freeMacPdschServCellInfo
7496  *
7497  *    Functionality: DeAlloc pdsch serv cell config info
7498  *
7499  * @params[in] PdschServCellCfg pointer
7500  * @return void
7501  *
7502  * ****************************************************************/
7503
7504 void freeMacPdschServCellInfo(PdschServCellCfg *pdsch)
7505 {
7506    if(pdsch->xOverhead)
7507    {
7508       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, pdsch->xOverhead, sizeof(uint8_t));
7509    }
7510    if(pdsch->codeBlkGrpFlushInd)
7511    {
7512       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, pdsch->codeBlkGrpFlushInd, sizeof(bool));
7513    }
7514    if(pdsch->maxCodeBlkGrpPerTb)
7515    {
7516       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, pdsch->maxCodeBlkGrpPerTb, sizeof(uint8_t));
7517    }
7518    if(pdsch->maxMimoLayers)
7519    {
7520       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, pdsch->maxMimoLayers, sizeof(uint8_t));
7521    }
7522 }
7523
7524 /*******************************************************************
7525  *
7526  * @brief Free Serving cell Info
7527  *
7528  * @details
7529  *
7530  *    Function : freeMacServingCellInfo
7531  *
7532  *    Functionality: Free Serving cell Info
7533  *
7534  * @params[in] ServCellCfgInfo *srvCellCfg
7535  * @return void
7536  *
7537  * ****************************************************************/
7538 void freeMacServingCellInfo(ServCellCfgInfo *srvCellCfg)
7539 {
7540    freeMacPdschServCellInfo(&srvCellCfg->pdschServCellCfg);
7541    if(srvCellCfg->bwpInactivityTmr)
7542    {
7543       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, srvCellCfg->bwpInactivityTmr, sizeof(uint8_t));
7544    }
7545 }
7546
7547 /*******************************************************************
7548  *
7549  * @brief Free cell Grp Cfg Info
7550  *
7551  * @details
7552  *
7553  *    Function : freeUeReCfgCellGrpInfo
7554  *
7555  *    Functionality: Free cell Grp Cfg Info
7556  *
7557  * @params[in] MacUeCfg*  duUeCfg
7558  * @return void
7559  *
7560  * ****************************************************************/
7561
7562 void freeUeReCfgCellGrpInfo(MacUeCfg *macUeCfg)
7563 {
7564    freeMacServingCellInfo(&macUeCfg->spCellCfg.servCellCfg);
7565 }
7566
7567 /*******************************************************************
7568  *
7569  * @brief Fills Reconfig SchReqReConfig
7570  *
7571  * @details
7572  *
7573  *    Function : extractSchReqReConfig
7574  *
7575  *    Functionality: Fills Reconfig SchReqReConfig
7576  *
7577  * @params[in] SchedulingRequestConfig_t *cuSchedReq
7578  *             SchedReqCfg*  macSchedReq
7579  * @return void
7580  *
7581  * ****************************************************************/
7582 void extractSchReqReConfig(SchedulingRequestConfig_t *cuSchedReq, SchedReqCfg *macSchedReq)
7583 {
7584    uint8_t schReqIdx = 0;
7585    struct SchedulingRequestConfig__schedulingRequestToAddModList *schReqListToAdd = NULLP;
7586    struct SchedulingRequestConfig__schedulingRequestToReleaseList *schReqListToRel = NULLP;
7587
7588    if(cuSchedReq->schedulingRequestToAddModList)
7589    {
7590       schReqListToAdd = cuSchedReq->schedulingRequestToAddModList;
7591       if(schReqListToAdd->list.count)
7592       {
7593          macSchedReq->addModListCount = schReqListToAdd->list.count;
7594          for(schReqIdx = 0; schReqIdx < schReqListToAdd->list.count; schReqIdx++)
7595          {
7596             macSchedReq->addModList[schReqIdx].schedReqId = \
7597                schReqListToAdd->list.array[schReqIdx]->schedulingRequestId;
7598             macSchedReq->addModList[schReqIdx].srProhibitTmr = \
7599                *(schReqListToAdd->list.array[schReqIdx]->sr_ProhibitTimer);
7600             macSchedReq->addModList[schReqIdx].srTransMax    =\
7601                schReqListToAdd->list.array[schReqIdx]->sr_TransMax;
7602          }
7603       }
7604    }
7605    /* Scheduling Req To release */
7606    if(cuSchedReq->schedulingRequestToReleaseList)
7607    {
7608       schReqListToRel = cuSchedReq->schedulingRequestToReleaseList;
7609       if(schReqListToRel->list.count)
7610       {
7611          macSchedReq->relListCount = schReqListToRel->list.count;
7612          for(schReqIdx = 0; schReqIdx < schReqListToRel->list.count; schReqIdx++)
7613          {
7614             macSchedReq->relList[schReqIdx] = \
7615                *schReqListToRel->list.array[schReqIdx];
7616          }
7617       }
7618    }
7619 }
7620
7621 /*******************************************************************
7622  *
7623  * @brief Fills TagReconfig
7624  *
7625  * @details
7626  *
7627  *    Function : extractTagReconfig
7628  *
7629  *    Functionality: Fills extractTagReconfig
7630  *
7631  * @params[in] TAG_Config_t *cuTagCfg
7632  *             TagCfg *macTagCfg
7633  * @return void
7634  *
7635  * ****************************************************************/
7636
7637 void extractTagReconfig(TAG_Config_t *cuTagCfg, TagCfg *macTagCfg)
7638 {
7639   uint8_t tagIdx = 0;
7640   struct TAG_Config__tag_ToAddModList  *tagListToAddMod = NULLP;
7641   struct TAG_Config__tag_ToReleaseList *tagListToRel = NULLP;
7642
7643   /* Tag config to AddMod */
7644   if(cuTagCfg->tag_ToAddModList)
7645   {
7646      tagListToAddMod = cuTagCfg->tag_ToAddModList;
7647      if(tagListToAddMod->list.count)
7648      {
7649         macTagCfg->addModListCount = tagListToAddMod->list.count;
7650         for(tagIdx = 0; tagIdx < tagListToAddMod->list.count; tagIdx++)
7651         {
7652            macTagCfg->addModList[tagIdx].tagId =\
7653               tagListToAddMod->list.array[tagIdx]->tag_Id;
7654            macTagCfg->addModList[tagIdx].timeAlignTimer = \
7655
7656               tagListToAddMod->list.array[tagIdx]->timeAlignmentTimer;
7657         }
7658      }
7659   }
7660   /* Tag config to release */
7661   if(cuTagCfg->tag_ToReleaseList)
7662   {
7663      tagListToRel = cuTagCfg->tag_ToReleaseList;
7664      if(tagListToRel->list.count)
7665      {
7666         macTagCfg->relListCount = tagListToRel->list.count;
7667         for(tagIdx = 0; tagIdx < tagListToRel->list.count; tagIdx++)
7668         {
7669            macTagCfg->relList[tagIdx] = *tagListToRel->list.array[tagIdx];
7670         }
7671      }
7672   }
7673 }
7674
7675 /*******************************************************************
7676  *
7677  * @brief Fills PdcchCfg received by CU
7678  *
7679  * @details
7680  *
7681  *    Function : extractPdcchCfg
7682  *
7683  *    Functionality: Fills PdcchCfg received  by CU
7684  *
7685  * @params[in] PDCCH_Config_t *cuPdcchCfg,
7686  *             PdcchConfig *duPdcchCfg
7687  * @return void
7688  *
7689  * ****************************************************************/
7690
7691 void extractPdcchCfg(PDCCH_Config_t *cuPdcchCfg, PdcchConfig *macPdcchCfg)
7692 {
7693    uint8_t cRsetIdx = 0;
7694    uint8_t srchSpcIdx = 0;
7695
7696    struct PDCCH_Config__controlResourceSetToAddModList *cRsetToAddModList = NULLP;
7697    struct PDCCH_Config__controlResourceSetToReleaseList *cRsetToRelList = NULLP;
7698    struct PDCCH_Config__searchSpacesToAddModList *srchSpcToAddModList = NULLP;
7699    struct PDCCH_Config__searchSpacesToReleaseList *srchSpcToRelList = NULLP;
7700
7701
7702    /* Control Resource Set To Add/Mod List */
7703    if(cuPdcchCfg->controlResourceSetToAddModList)
7704    {
7705       cRsetToAddModList = cuPdcchCfg->controlResourceSetToAddModList;
7706       if(cRsetToAddModList->list.count)
7707       {
7708          macPdcchCfg->numCRsetToAddMod = cRsetToAddModList->list.count;
7709          for(cRsetIdx = 0; cRsetIdx < cRsetToAddModList->list.count; cRsetIdx++)
7710          {
7711             macPdcchCfg->cRSetToAddModList[cRsetIdx].cRSetId = \
7712               cRsetToAddModList->list.array[cRsetIdx]->controlResourceSetId;
7713             bitStringToInt(&cRsetToAddModList->list.array[cRsetIdx]->frequencyDomainResources,\
7714                macPdcchCfg->cRSetToAddModList[cRsetIdx].freqDomainRsrc);
7715             macPdcchCfg->cRSetToAddModList[cRsetIdx].duration = \
7716               cRsetToAddModList->list.array[cRsetIdx]->duration;
7717
7718             macPdcchCfg->cRSetToAddModList[cRsetIdx].cceRegMappingType = \
7719               cRsetToAddModList->list.array[cRsetIdx]->cce_REG_MappingType.present;
7720             if(macPdcchCfg->cRSetToAddModList[cRsetIdx].cceRegMappingType == CCE_REG_MAPPINGTYPE_PR_INTERLEAVED)
7721             {
7722                //TODO: handle the case for Interleaved
7723             }
7724             macPdcchCfg->cRSetToAddModList[cRsetIdx].precoderGranularity = \
7725               cRsetToAddModList->list.array[cRsetIdx]->precoderGranularity;
7726             if(cRsetToAddModList->list.array[cRsetIdx]->pdcch_DMRS_ScramblingID)
7727             {
7728                macPdcchCfg->cRSetToAddModList[cRsetIdx].dmrsScramblingId= \
7729                   *(cRsetToAddModList->list.array[cRsetIdx]->pdcch_DMRS_ScramblingID);
7730             }
7731          }
7732       }
7733
7734    }
7735    /* Control Resource Set To Release List */
7736    if(cuPdcchCfg->controlResourceSetToReleaseList)
7737    {
7738       cRsetToRelList = cuPdcchCfg->controlResourceSetToReleaseList;
7739       if(cRsetToRelList->list.count)
7740       {
7741          macPdcchCfg->numCRsetToRel = cRsetToRelList->list.count;
7742          for(cRsetIdx = 0; cRsetIdx < cRsetToRelList->list.count; cRsetIdx++)
7743          {
7744             macPdcchCfg->cRSetToRelList[cRsetIdx] = *(cRsetToRelList->list.array[cRsetIdx]);
7745          }
7746       }
7747    }
7748
7749    /* Search space To Add/Mod List */
7750    if(cuPdcchCfg->searchSpacesToAddModList)
7751    {
7752       srchSpcToAddModList = cuPdcchCfg->searchSpacesToAddModList;
7753       if(srchSpcToAddModList->list.count)
7754       {
7755          macPdcchCfg->numSearchSpcToAddMod = srchSpcToAddModList->list.count;
7756          for(srchSpcIdx = 0; srchSpcIdx < srchSpcToAddModList->list.count; srchSpcIdx++)
7757          {
7758             macPdcchCfg->searchSpcToAddModList[srchSpcIdx].searchSpaceId =\
7759                srchSpcToAddModList->list.array[srchSpcIdx]->searchSpaceId;
7760             macPdcchCfg->searchSpcToAddModList[srchSpcIdx].cRSetId =\
7761                *(srchSpcToAddModList->list.array[srchSpcIdx]->controlResourceSetId);
7762             if(srchSpcToAddModList->list.array[srchSpcIdx]->monitoringSlotPeriodicityAndOffset)
7763             {
7764                macPdcchCfg->searchSpcToAddModList[srchSpcIdx].mSlotPeriodicityAndOffset =\
7765                   srchSpcToAddModList->list.array[srchSpcIdx]->monitoringSlotPeriodicityAndOffset->present;
7766             }
7767             if(srchSpcToAddModList->list.array[srchSpcIdx]->monitoringSymbolsWithinSlot)
7768             {
7769                bitStringToInt(srchSpcToAddModList->list.array[srchSpcIdx]->monitoringSymbolsWithinSlot,\
7770                   macPdcchCfg->searchSpcToAddModList[srchSpcIdx].mSymbolsWithinSlot);
7771             }
7772             if(srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates)
7773             {
7774               macPdcchCfg->searchSpcToAddModList[srchSpcIdx].numCandidatesAggLevel1 = \
7775                   srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates->aggregationLevel1;
7776               macPdcchCfg->searchSpcToAddModList[srchSpcIdx].numCandidatesAggLevel2 = \
7777                   srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates->aggregationLevel2;
7778               macPdcchCfg->searchSpcToAddModList[srchSpcIdx].numCandidatesAggLevel4 = \
7779                   srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates->aggregationLevel4;
7780
7781               macPdcchCfg->searchSpcToAddModList[srchSpcIdx].numCandidatesAggLevel8 = \
7782                   srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates->aggregationLevel8;
7783
7784               macPdcchCfg->searchSpcToAddModList[srchSpcIdx].numCandidatesAggLevel16 = \
7785                   srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates->aggregationLevel16;
7786             }
7787             if(srchSpcToAddModList->list.array[srchSpcIdx]->searchSpaceType)
7788             {
7789                macPdcchCfg->searchSpcToAddModList[srchSpcIdx].searchSpaceType =\
7790                   srchSpcToAddModList->list.array[srchSpcIdx]->searchSpaceType->present;
7791                if(macPdcchCfg->searchSpcToAddModList[srchSpcIdx].searchSpaceType == SEARCHSPACETYPE_PR_UE_SPECIFIC)
7792                {
7793                   macPdcchCfg->searchSpcToAddModList[srchSpcIdx].ueSpecificDciFormat =\
7794                      srchSpcToAddModList->list.array[srchSpcIdx]->searchSpaceType->choice.ue_Specific->dci_Formats;
7795                }
7796
7797             }
7798          }
7799       }
7800    }
7801    /* Search space To Rel List */
7802    if(cuPdcchCfg->searchSpacesToReleaseList)
7803    {
7804       srchSpcToRelList = cuPdcchCfg->searchSpacesToReleaseList;
7805       if(srchSpcToRelList->list.count)
7806       {
7807          macPdcchCfg->numSearchSpcToRel = srchSpcToRelList->list.count;
7808          for(srchSpcIdx = 0; srchSpcIdx < srchSpcToRelList->list.count; srchSpcIdx++)
7809          {
7810             macPdcchCfg->searchSpcToRelList[srchSpcIdx] =\
7811                *(srchSpcToRelList->list.array[srchSpcIdx]);
7812          }
7813       }
7814    }
7815 }
7816
7817 /*******************************************************************
7818  *
7819  * @brief Fills PdschCfg received by CU
7820  *
7821  * @details
7822  *
7823  *    Function : extractPdschCfg
7824  *
7825  *    Functionality: Fills PdschCfg received  by CU
7826  *
7827  * @params[in] PDSCH_Config_t *cuPdschCfg,
7828  *             PdschConfig *macPdschCfg
7829  * @return void
7830  *
7831  * ****************************************************************/
7832
7833 void extractPdschCfg(PDSCH_Config_t *cuPdschCfg, PdschConfig *macPdschCfg)
7834 {
7835    uint8_t timeDomIdx;
7836    struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAlloc = NULLP;
7837
7838    if(cuPdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA)
7839    {
7840       if(cuPdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA->present == \
7841          PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA_PR_setup)
7842       {
7843          if(cuPdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA->choice.setup)
7844          {
7845             macPdschCfg->dmrsDlCfgForPdschMapTypeA.addPos = \
7846                *(cuPdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA->choice.setup->dmrs_AdditionalPosition);
7847          }
7848       }
7849    }
7850    macPdschCfg->resourceAllocType = cuPdschCfg->resourceAllocation;
7851    if(cuPdschCfg->pdsch_TimeDomainAllocationList)
7852    {
7853       timeDomAlloc = cuPdschCfg->pdsch_TimeDomainAllocationList;
7854       if(timeDomAlloc->present ==\
7855          PDSCH_Config__pdsch_TimeDomainAllocationList_PR_setup)
7856       {
7857          if(timeDomAlloc->choice.setup)
7858          {
7859             macPdschCfg->numTimeDomRsrcAlloc  = timeDomAlloc->choice.setup->list.count;
7860             for(timeDomIdx = 0; timeDomIdx < timeDomAlloc->choice.setup->list.count; timeDomIdx++)
7861             {
7862                macPdschCfg->timeDomRsrcAllociList[timeDomIdx].mappingType = \
7863                   timeDomAlloc->choice.setup->list.array[timeDomIdx]->mappingType;
7864                macPdschCfg->timeDomRsrcAllociList[timeDomIdx].startSymbolAndLength = \
7865                   timeDomAlloc->choice.setup->list.array[timeDomIdx]->startSymbolAndLength;
7866             }
7867          }
7868       }
7869    }
7870    macPdschCfg->rbgSize = cuPdschCfg->rbg_Size;
7871    if(cuPdschCfg->maxNrofCodeWordsScheduledByDCI)
7872       macPdschCfg->numCodeWordsSchByDci = *(cuPdschCfg->maxNrofCodeWordsScheduledByDCI);
7873    if(cuPdschCfg->prb_BundlingType.present == PDSCH_Config__prb_BundlingType_PR_staticBundling)
7874    {
7875       macPdschCfg->bundlingType = cuPdschCfg->prb_BundlingType.present;
7876       if(cuPdschCfg->prb_BundlingType.choice.staticBundling)
7877       {
7878          if(cuPdschCfg->prb_BundlingType.choice.staticBundling->bundleSize)
7879          {
7880             macPdschCfg->bundlingInfo.StaticBundling.size = \
7881                *(cuPdschCfg->prb_BundlingType.choice.staticBundling->bundleSize);
7882          }
7883       }
7884    }
7885    else if(cuPdschCfg->prb_BundlingType.present == PDSCH_Config__prb_BundlingType_PR_dynamicBundling)
7886    {
7887       macPdschCfg->bundlingType = cuPdschCfg->prb_BundlingType.present;
7888    }
7889
7890 }
7891
7892 /*******************************************************************
7893  *
7894  * @brief Fills PdschServingCellCfg received by CU
7895  *
7896  * @details
7897  *
7898  *    Function : extractPdschServingCellCfg
7899  *
7900  *    Functionality: Fills PdschCfg received  by CU
7901  *
7902  * @params[in] PDSCH_ServingCellConfig_t *cuPdschSrvCellCfg,
7903  *             PdschServCellCfg *macUePdschSrvCellCfg
7904  * @return ROK/RFAILED
7905  *
7906  * ****************************************************************/
7907
7908 uint8_t extractPdschServingCellCfg(PDSCH_ServingCellConfig_t *cuPdschSrvCellCfg, PdschServCellCfg *macUePdschSrvCellCfg)
7909 {
7910    if(cuPdschSrvCellCfg->codeBlockGroupTransmission)
7911    {
7912       if(cuPdschSrvCellCfg->codeBlockGroupTransmission->choice.setup)
7913       {
7914          if(macUePdschSrvCellCfg->maxCodeBlkGrpPerTb)
7915          {
7916             *(macUePdschSrvCellCfg->maxCodeBlkGrpPerTb)  = \
7917                cuPdschSrvCellCfg->codeBlockGroupTransmission->choice.setup->maxCodeBlockGroupsPerTransportBlock;
7918          }
7919          else
7920          {
7921             DU_ALLOC_SHRABL_BUF(macUePdschSrvCellCfg->maxCodeBlkGrpPerTb, sizeof(uint8_t));
7922             if(macUePdschSrvCellCfg->maxCodeBlkGrpPerTb)
7923             {
7924                *(macUePdschSrvCellCfg->maxCodeBlkGrpPerTb)  = \
7925                   cuPdschSrvCellCfg->codeBlockGroupTransmission->choice.setup->maxCodeBlockGroupsPerTransportBlock;
7926             }
7927             else
7928             {
7929                DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for maxCodeBlkGrpPerTb at extractPdschServingCellCfg()");
7930                return RFAILED;
7931             }
7932          }
7933          if(macUePdschSrvCellCfg->codeBlkGrpFlushInd)
7934          {
7935             *(macUePdschSrvCellCfg->codeBlkGrpFlushInd)  = \
7936                cuPdschSrvCellCfg->codeBlockGroupTransmission->choice.setup->codeBlockGroupFlushIndicator;
7937          }
7938          else
7939          {
7940             DU_ALLOC_SHRABL_BUF(macUePdschSrvCellCfg->maxCodeBlkGrpPerTb, sizeof(bool));
7941             if(macUePdschSrvCellCfg->codeBlkGrpFlushInd)
7942             {
7943                *(macUePdschSrvCellCfg->codeBlkGrpFlushInd)  = \
7944                   cuPdschSrvCellCfg->codeBlockGroupTransmission->choice.setup->codeBlockGroupFlushIndicator;
7945             }
7946             else
7947             {
7948                DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for codeBlkGrpFlushInd at extractPdschServingCellCfg()");
7949                return RFAILED;
7950             }
7951          }
7952       }
7953    }
7954    if(cuPdschSrvCellCfg->nrofHARQ_ProcessesForPDSCH)
7955    {
7956       macUePdschSrvCellCfg->numHarqProcForPdsch = *(cuPdschSrvCellCfg->nrofHARQ_ProcessesForPDSCH);
7957    }
7958    if(cuPdschSrvCellCfg->ext1)
7959    {
7960       if(cuPdschSrvCellCfg->ext1->maxMIMO_Layers)
7961       {
7962         if(macUePdschSrvCellCfg->maxMimoLayers)
7963         {
7964            *(macUePdschSrvCellCfg->maxMimoLayers)  = *(cuPdschSrvCellCfg->ext1->maxMIMO_Layers);
7965         }
7966         else
7967         {
7968            DU_ALLOC_SHRABL_BUF(macUePdschSrvCellCfg->maxMimoLayers, sizeof(uint8_t));
7969            if(macUePdschSrvCellCfg->maxMimoLayers)
7970            {
7971               *(macUePdschSrvCellCfg->maxMimoLayers)  = *(cuPdschSrvCellCfg->ext1->maxMIMO_Layers);
7972            }
7973            else
7974            {
7975               DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for maxMimoLayers at extractPdschServingCellCfg()");
7976               return RFAILED;
7977            }
7978         }
7979       }
7980    }
7981    if(cuPdschSrvCellCfg->xOverhead)
7982    {
7983       if(macUePdschSrvCellCfg->xOverhead)
7984       {
7985          *(macUePdschSrvCellCfg->xOverhead)  = *(cuPdschSrvCellCfg->xOverhead);
7986       }
7987       else
7988       {
7989          DU_ALLOC_SHRABL_BUF(macUePdschSrvCellCfg->xOverhead, sizeof(uint8_t));
7990          if(macUePdschSrvCellCfg->xOverhead)
7991          {
7992             *(macUePdschSrvCellCfg->xOverhead)  = *(cuPdschSrvCellCfg->xOverhead);
7993          }
7994          else
7995          {
7996             DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for xOverhead at extractPdschServingCellCfg()");
7997             return RFAILED;
7998          }
7999       }
8000    }
8001    return ROK;
8002 }
8003
8004 /*******************************************************************
8005  *
8006  * @brief Fills PuschCfg received by CU
8007  *
8008  * @details
8009  *
8010  *    Function : extractPuschCfg
8011  *
8012  *    Functionality: Fills PuschCfg received  by CU
8013  *
8014  * @params[in] BWP_UplinkDedicated__pusch_Config *cuPuschCfg,
8015  *             PuschCfg *macPuschCfg
8016  * @return void
8017  *
8018  * ****************************************************************/
8019
8020 void extractPuschCfg(struct BWP_UplinkDedicated__pusch_Config *cuPuschCfg, PuschCfg *macPuschCfg)
8021 {
8022    uint8_t timeDomIdx = 0;
8023    DMRS_UplinkConfig_t *dmrsUlCfg = NULLP;
8024    struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList = NULLP;
8025
8026    if(cuPuschCfg->present == BWP_UplinkDedicated__pusch_Config_PR_setup)
8027    {
8028       if(cuPuschCfg->choice.setup)
8029       {
8030          if(cuPuschCfg->choice.setup->dataScramblingIdentityPUSCH)
8031          {
8032              macPuschCfg->dataScramblingId = \
8033                 *(cuPuschCfg->choice.setup->dataScramblingIdentityPUSCH);
8034          }
8035          if(cuPuschCfg->choice.setup->dmrs_UplinkForPUSCH_MappingTypeA)
8036          {
8037             if(cuPuschCfg->choice.setup->dmrs_UplinkForPUSCH_MappingTypeA->present == PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA_PR_setup)
8038             {
8039                if(cuPuschCfg->choice.setup->dmrs_UplinkForPUSCH_MappingTypeA->choice.setup)
8040                {
8041                   dmrsUlCfg = (cuPuschCfg->choice.setup->dmrs_UplinkForPUSCH_MappingTypeA->choice.setup);
8042                   if(dmrsUlCfg->dmrs_AdditionalPosition)
8043                   {
8044                      macPuschCfg->dmrsUlCfgForPuschMapTypeA.addPos =\
8045                         *(dmrsUlCfg->dmrs_AdditionalPosition);
8046                   }
8047                   if(dmrsUlCfg->transformPrecodingDisabled)
8048                   {
8049                      if(dmrsUlCfg->transformPrecodingDisabled->scramblingID0)
8050                      {
8051                         macPuschCfg->dmrsUlCfgForPuschMapTypeA.transPrecodDisabled.scramblingId0 = \
8052                            *(dmrsUlCfg->transformPrecodingDisabled->scramblingID0);
8053                      }
8054                   }
8055                }
8056             }
8057          }
8058          /*Res Alloc Type for UL */
8059          if(cuPuschCfg->choice.setup->resourceAllocation)
8060          {
8061             macPuschCfg->resourceAllocType = \
8062                cuPuschCfg->choice.setup->resourceAllocation;
8063          }
8064          if(cuPuschCfg->choice.setup->pusch_TimeDomainAllocationList)
8065          {
8066             timeDomAllocList = cuPuschCfg->choice.setup->pusch_TimeDomainAllocationList;
8067             if(timeDomAllocList->present == PUSCH_Config__pusch_TimeDomainAllocationList_PR_setup)
8068             {
8069                if(timeDomAllocList->choice.setup)
8070                {
8071                   macPuschCfg->numTimeDomRsrcAlloc = timeDomAllocList->choice.setup->list.count;
8072                   for(timeDomIdx = 0; timeDomIdx <timeDomAllocList->choice.setup->list.count; timeDomIdx++)
8073                   {
8074                      macPuschCfg->timeDomRsrcAllocList[timeDomIdx].k2 = \
8075                         *(timeDomAllocList->choice.setup->list.array[timeDomIdx]->k2);
8076                      macPuschCfg->timeDomRsrcAllocList[timeDomIdx].mappingType = \
8077                         timeDomAllocList->choice.setup->list.array[timeDomIdx]->mappingType;
8078                      macPuschCfg->timeDomRsrcAllocList[timeDomIdx].startSymbolAndLength = \
8079                         timeDomAllocList->choice.setup->list.array[timeDomIdx]->startSymbolAndLength;
8080                   }
8081                }
8082             }
8083          }
8084          if(cuPuschCfg->choice.setup->transformPrecoder)
8085             macPuschCfg->transformPrecoder = *(cuPuschCfg->choice.setup->transformPrecoder);
8086       }
8087    }
8088 }
8089
8090 /*******************************************************************
8091  *
8092  * @brief Function to fill pucch Power Control
8093  *
8094  * @details
8095  *
8096  *    Function : extractPucchPowerControl
8097  *
8098  *    Functionality: Function to fill pucch Power Control
8099  *
8100  * @params[in] PucchPowerControl *pwrCtrl,
8101  *             struct PUCCH_PowerControl *cuPwrCtrlCfg
8102  * @return void
8103  *
8104  * ****************************************************************/
8105
8106 void extractPucchPowerControl(PucchPowerControl *pwrCtrl, struct PUCCH_PowerControl *cuPwrCtrlCfg)
8107 {
8108    uint8_t arrIdx;
8109
8110    if(cuPwrCtrlCfg->deltaF_PUCCH_f0)
8111       pwrCtrl->deltaF_Format0 = *cuPwrCtrlCfg->deltaF_PUCCH_f0;
8112    if(cuPwrCtrlCfg->deltaF_PUCCH_f1)
8113       pwrCtrl->deltaF_Format1 = *cuPwrCtrlCfg->deltaF_PUCCH_f1;
8114    if(cuPwrCtrlCfg->deltaF_PUCCH_f2)
8115       pwrCtrl->deltaF_Format2 = *cuPwrCtrlCfg->deltaF_PUCCH_f2;
8116    if(cuPwrCtrlCfg->deltaF_PUCCH_f3)
8117       pwrCtrl->deltaF_Format3 = *cuPwrCtrlCfg->deltaF_PUCCH_f3;
8118    if(cuPwrCtrlCfg->deltaF_PUCCH_f4)
8119       pwrCtrl->deltaF_Format4 = *cuPwrCtrlCfg->deltaF_PUCCH_f4;
8120    if(cuPwrCtrlCfg->p0_Set)
8121    {
8122       pwrCtrl->p0SetCount = cuPwrCtrlCfg->p0_Set->list.count;
8123       for(arrIdx=0; arrIdx < pwrCtrl->p0SetCount; arrIdx++)
8124       {
8125          pwrCtrl->p0Set[arrIdx].p0PucchId =\
8126             cuPwrCtrlCfg->p0_Set->list.array[arrIdx]->p0_PUCCH_Id;
8127          pwrCtrl->p0Set[arrIdx].p0PucchVal =\
8128             cuPwrCtrlCfg->p0_Set->list.array[arrIdx]->p0_PUCCH_Value;
8129       }
8130    }
8131    if(cuPwrCtrlCfg->pathlossReferenceRSs)
8132    {
8133       pwrCtrl->pathLossRefRSListCount = cuPwrCtrlCfg->pathlossReferenceRSs->list.count;
8134       for(arrIdx = 0; arrIdx < pwrCtrl->pathLossRefRSListCount; arrIdx++)
8135       {
8136          pwrCtrl->pathLossRefRSList[arrIdx].pathLossRefRSId =\
8137             cuPwrCtrlCfg->pathlossReferenceRSs->list.array[arrIdx]->pucch_PathlossReferenceRS_Id;
8138       }
8139    }
8140 }
8141
8142  /*******************************************************************
8143  *
8144  * @brief Function to extractResrcSetToAddModList sent by CU
8145  *
8146  * @details
8147  *
8148  *    Function : extractResrcSetToAddModList
8149  *
8150  *    Functionality: Fucntion to extractResrcSetToAddModList
8151  *
8152  * @params[in] PucchResrcSetCfg pointer,
8153  *             struct PUCCH_Config__resourceSetToAddModList pointer
8154  * @return void
8155  *
8156  * ****************************************************************/
8157
8158 void extractResrcSetToAddModList(PucchResrcSetCfg *macRsrcSetList, struct PUCCH_Config__resourceSetToAddModList *cuRsrcSetList)
8159 {
8160    uint8_t arrIdx, rsrcListIdx;
8161
8162    macRsrcSetList->resrcSetToAddModListCount = cuRsrcSetList->list.count;
8163    for(arrIdx = 0; arrIdx < macRsrcSetList->resrcSetToAddModListCount; arrIdx++)
8164    {
8165       macRsrcSetList->resrcSetToAddModList[arrIdx].resrcSetId     =\
8166          cuRsrcSetList->list.array[arrIdx]->pucch_ResourceSetId;
8167       macRsrcSetList->resrcSetToAddModList[arrIdx].resrcListCount =\
8168          cuRsrcSetList->list.array[arrIdx]->resourceList.list.count;
8169       for(rsrcListIdx = 0; rsrcListIdx < macRsrcSetList->resrcSetToAddModList[arrIdx].resrcListCount; rsrcListIdx++)
8170       {
8171          macRsrcSetList->resrcSetToAddModList[arrIdx].resrcList[rsrcListIdx] =\
8172             *cuRsrcSetList->list.array[arrIdx]->resourceList.list.array[rsrcListIdx];
8173       }
8174       macRsrcSetList->resrcSetToAddModList[arrIdx].maxPayLoadSize =\
8175          *cuRsrcSetList->list.array[arrIdx]->maxPayloadMinus1;
8176    }
8177 }/* End of extractResrcSetToAddModList */
8178
8179 /*******************************************************************
8180  *
8181  * @brief Fills extractResrcToAddModList sent by CU
8182  *
8183  * @details
8184  *
8185  *    Function : extractResrcToAddModList
8186  *
8187  *    Functionality: Fills extractResrcToAddModList
8188  *
8189  * @params[in] PucchResrcCfg pointer,
8190  *             struct PUCCH_Config__resourceToAddModList pointer
8191  * @return ROk/RFAILED
8192  *
8193  * ****************************************************************/
8194
8195 uint8_t extractResrcToAddModList(PucchResrcCfg *macResrcList, struct PUCCH_Config__resourceToAddModList *cuResrcList)
8196 {
8197    uint8_t arrIdx;
8198
8199    macResrcList->resrcToAddModListCount = cuResrcList->list.count;
8200    for(arrIdx = 0; arrIdx < macResrcList->resrcToAddModListCount; arrIdx++)
8201    {
8202       macResrcList->resrcToAddModList[arrIdx].resrcId      =\
8203         cuResrcList->list.array[arrIdx]->pucch_ResourceId;
8204       macResrcList->resrcToAddModList[arrIdx].startPrb     =\
8205         cuResrcList->list.array[arrIdx]->startingPRB;
8206       if(cuResrcList->list.array[arrIdx]->intraSlotFrequencyHopping)
8207       {
8208          macResrcList->resrcToAddModList[arrIdx].intraFreqHop =\
8209            *cuResrcList->list.array[arrIdx]->intraSlotFrequencyHopping;
8210       }
8211       if(cuResrcList->list.array[arrIdx]->secondHopPRB)
8212       {
8213          macResrcList->resrcToAddModList[arrIdx].secondPrbHop =\
8214            *cuResrcList->list.array[arrIdx]->secondHopPRB;
8215       }
8216       /* PUCCH RSRC FORMAT */
8217       if(cuResrcList->list.array[arrIdx]->format.present == PUCCH_Resource__format_PR_format0)
8218       {
8219          macResrcList->resrcToAddModList[arrIdx].pucchFormat = PUCCH_FORMAT_0;
8220          if(cuResrcList->list.array[arrIdx]->format.choice.format0)
8221          {
8222             DU_ALLOC_SHRABL_BUF(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format0, sizeof(PucchFormat0));
8223             if(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format0 == NULLP)
8224             {
8225                DU_LOG("\nERROR  --> F1AP : Failed to allocate memory for Format0 in extractResrcToAddModList()");
8226                return RFAILED;
8227             }
8228             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format0->initialCyclicShift =\
8229                cuResrcList->list.array[arrIdx]->format.choice.format0->initialCyclicShift;
8230             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format0->numSymbols =\
8231                cuResrcList->list.array[arrIdx]->format.choice.format0->nrofSymbols;
8232             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format0->startSymbolIdx =\
8233                cuResrcList->list.array[arrIdx]->format.choice.format0->startingSymbolIndex;
8234          }
8235       }
8236       else if(cuResrcList->list.array[arrIdx]->format.present == PUCCH_Resource__format_PR_format1)
8237       {
8238          macResrcList->resrcToAddModList[arrIdx].pucchFormat = PUCCH_FORMAT_1;
8239          if(cuResrcList->list.array[arrIdx]->format.choice.format1)
8240          {
8241             DU_ALLOC_SHRABL_BUF(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1, sizeof(PucchFormat1));
8242             if(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1 == NULLP)
8243             {
8244                DU_LOG("\nERROR  --> F1AP : Failed to allocate memory for Format1 in extractResrcToAddModList()");
8245                return RFAILED;
8246             }
8247             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1->initialCyclicShift =\
8248                 cuResrcList->list.array[arrIdx]->format.choice.format1->initialCyclicShift;
8249             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1->numSymbols =\
8250                 cuResrcList->list.array[arrIdx]->format.choice.format1->nrofSymbols;
8251             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1->startSymbolIdx =\
8252                 cuResrcList->list.array[arrIdx]->format.choice.format1->startingSymbolIndex;
8253             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1->timeDomOCC =\
8254                 cuResrcList->list.array[arrIdx]->format.choice.format1->timeDomainOCC;
8255          }
8256       }
8257       else if(cuResrcList->list.array[arrIdx]->format.present == PUCCH_Resource__format_PR_format2)
8258       {
8259          macResrcList->resrcToAddModList[arrIdx].pucchFormat = PUCCH_FORMAT_2;
8260          if(cuResrcList->list.array[arrIdx]->format.choice.format2)
8261          {
8262             DU_ALLOC_SHRABL_BUF(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format2, sizeof(PucchFormat2_3));
8263             if(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format2 == NULLP)
8264             {
8265                DU_LOG("\nERROR  --> F1AP : Failed to allocate memory for Format2 in extractResrcToAddModList()");
8266                return RFAILED;
8267             }
8268             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format2->numPrbs =\
8269                 cuResrcList->list.array[arrIdx]->format.choice.format2->nrofPRBs;
8270             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format2->numSymbols =\
8271                 cuResrcList->list.array[arrIdx]->format.choice.format2->nrofSymbols;
8272             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format2->startSymbolIdx =\
8273                 cuResrcList->list.array[arrIdx]->format.choice.format2->startingSymbolIndex;
8274          }
8275       }
8276       else if(cuResrcList->list.array[arrIdx]->format.present == PUCCH_Resource__format_PR_format3)
8277       {
8278          macResrcList->resrcToAddModList[arrIdx].pucchFormat = PUCCH_FORMAT_3;
8279          if(cuResrcList->list.array[arrIdx]->format.choice.format3)
8280          {
8281             DU_ALLOC_SHRABL_BUF(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format3, sizeof(PucchFormat2_3));
8282             if(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format3 == NULLP)
8283             {
8284                DU_LOG("\nERROR  --> F1AP : Failed to allocate memory for Format3 in extractResrcToAddModList()");
8285                return RFAILED;
8286             }
8287             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format3->numPrbs =\
8288                 cuResrcList->list.array[arrIdx]->format.choice.format3->nrofPRBs;
8289             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format3->numSymbols =\
8290                 cuResrcList->list.array[arrIdx]->format.choice.format3->nrofSymbols;
8291             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format3->startSymbolIdx =\
8292                 cuResrcList->list.array[arrIdx]->format.choice.format3->startingSymbolIndex;
8293          }
8294       }
8295       else if(cuResrcList->list.array[arrIdx]->format.present == PUCCH_Resource__format_PR_format4)
8296       {
8297          macResrcList->resrcToAddModList[arrIdx].pucchFormat = PUCCH_FORMAT_4;
8298          if(cuResrcList->list.array[arrIdx]->format.choice.format4)
8299          {
8300             DU_ALLOC_SHRABL_BUF(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4, sizeof(PucchFormat4));
8301             if(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4 == NULLP)
8302             {
8303                DU_LOG("\nERROR  --> F1AP : Failed to allocate memory for Format4 in extractResrcToAddModList()");
8304                return RFAILED;
8305             }
8306             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4->numSymbols =\
8307                 cuResrcList->list.array[arrIdx]->format.choice.format4->nrofSymbols;
8308             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4->occLen =\
8309                 cuResrcList->list.array[arrIdx]->format.choice.format4->occ_Length;
8310             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4->occIdx =\
8311                 cuResrcList->list.array[arrIdx]->format.choice.format4->occ_Index;
8312             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4->startSymbolIdx =\
8313                 cuResrcList->list.array[arrIdx]->format.choice.format4->startingSymbolIndex;
8314          }
8315       }
8316    }
8317    return ROK;
8318
8319 }/* End of extractResrcToAddModList */
8320
8321 /*******************************************************************
8322  *
8323  * @brief Fills fillPucchSchedReqPeriodAndOffset sent by CU
8324  *
8325  * @details
8326  *
8327  *    Function : fillPucchSchedReqPeriodAndOffset
8328  *
8329  *    Functionality: To fillPucchSchedReqPeriodAndOffset
8330  *
8331  * @params[in] macPeriodicty,
8332  *     SchedulingRequestResourceConfig__periodicityAndOffset pointer
8333  * @return void
8334  *
8335  * ****************************************************************/
8336
8337 void fillPucchSchedReqPeriodAndOffset(uint8_t macPeriodicty, uint16_t  macOffset,\
8338    struct SchedulingRequestResourceConfig__periodicityAndOffset *cuPeriodicty)
8339 {
8340    macPeriodicty = cuPeriodicty->present;
8341    switch(macPeriodicty)
8342    {
8343       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sym2:
8344          {
8345             macOffset     = cuPeriodicty->choice.sym2;
8346             break;
8347          }
8348       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sym6or7:
8349          {
8350             macOffset     = cuPeriodicty->choice.sym6or7;
8351             break;
8352          }
8353       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl1:
8354          {
8355             macOffset     = cuPeriodicty->choice.sl1;
8356             break;
8357          }
8358       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl2:
8359          {
8360             macOffset = cuPeriodicty->choice.sl2;
8361             break;
8362          }
8363       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl4:
8364          {
8365             macOffset = cuPeriodicty->choice.sl4;
8366             break;
8367          }
8368       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl5:
8369          {
8370             macOffset = cuPeriodicty->choice.sl5;
8371             break;
8372          }
8373       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl8:
8374          {
8375             macOffset = cuPeriodicty->choice.sl8;
8376             break;
8377          }
8378       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl10:
8379          {
8380             macOffset = cuPeriodicty->choice.sl10;
8381             break;
8382          }
8383       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl16:
8384          {
8385             macOffset = cuPeriodicty->choice.sl16;
8386             break;
8387          }
8388       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl20:
8389          {
8390             macOffset = cuPeriodicty->choice.sl20;
8391             break;
8392          }
8393       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl40:
8394          {
8395             macOffset = cuPeriodicty->choice.sl40;
8396             break;
8397          }
8398       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl80:
8399          {
8400             macOffset = cuPeriodicty->choice.sl80;
8401             break;
8402          }
8403       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl160:
8404          {
8405             macOffset = cuPeriodicty->choice.sl160;
8406             break;
8407          }
8408       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl320:
8409          {
8410             macOffset = cuPeriodicty->choice.sl320;
8411             break;
8412          }
8413       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl640:
8414          {
8415             macOffset = cuPeriodicty->choice.sl640;
8416             break;
8417          }
8418       default :
8419          DU_LOG("\nERROR  -->  F1AP : Invalid periodicity %d", macPeriodicty);
8420    }
8421 }
8422
8423 /*******************************************************************
8424  *
8425  * @brief Function to extractPucchFormatCfg sent by CU
8426  *
8427  * @details
8428  *
8429  *    Function : extractPucchFormatCfg
8430  *
8431  *    Functionality: Function to extractPucchFormatCfg
8432  *
8433  * @params[in] PucchFormatCfg pointer,
8434  *             PUCCH_FormatConfig_t pointer
8435  * @return void
8436  *
8437  * ****************************************************************/
8438
8439 void extractPucchFormatCfg(PucchFormatCfg *macFormatCfg, PUCCH_FormatConfig_t *cuFormatCfg)
8440  {
8441     if(cuFormatCfg->interslotFrequencyHopping)
8442        macFormatCfg->interSlotFreqHop = *cuFormatCfg->interslotFrequencyHopping;
8443     if(cuFormatCfg->additionalDMRS)
8444        macFormatCfg->addDmrs = *cuFormatCfg->additionalDMRS;
8445     if(cuFormatCfg->maxCodeRate)
8446        macFormatCfg->maxCodeRate = *cuFormatCfg->maxCodeRate;
8447     if(cuFormatCfg->nrofSlots)
8448        macFormatCfg->numSlots = *cuFormatCfg->nrofSlots;
8449     if(cuFormatCfg->pi2BPSK)
8450        macFormatCfg->pi2BPSK = *cuFormatCfg->pi2BPSK;
8451     if(cuFormatCfg->simultaneousHARQ_ACK_CSI)
8452        macFormatCfg->harqAckCSI = *cuFormatCfg->simultaneousHARQ_ACK_CSI;
8453  }/* End of extractPucchFormatCfg */
8454
8455 /*******************************************************************
8456  *
8457  * @brief Function to extractSchedReqCfgToAddMod sent by CU
8458  *
8459  * @details
8460  *
8461  *    Function : extractSchedReqCfgToAddMod
8462  *
8463  *    Functionality: Function to extractSchedReqCfgToAddMod
8464  *
8465  * @params[in] PucchSchedReqCfg pointer,
8466  *      PUCCH_Config__schedulingRequestResourceToAddModList pointer
8467  * @return void
8468  *
8469  * ****************************************************************/
8470
8471 void extractSchedReqCfgToAddMod(PucchSchedReqCfg *macSchedReqCfg, struct PUCCH_Config__schedulingRequestResourceToAddModList *cuSchedReqList)
8472 {
8473    uint8_t arrIdx;
8474
8475    macSchedReqCfg->schedAddModListCount = cuSchedReqList->list.count;
8476    for(arrIdx = 0; arrIdx <  macSchedReqCfg->schedAddModListCount; arrIdx++)
8477    {
8478       macSchedReqCfg->schedAddModList[arrIdx].resrcId =\
8479          cuSchedReqList->list.array[arrIdx]->schedulingRequestResourceId;
8480       macSchedReqCfg->schedAddModList[arrIdx].requestId =\
8481          cuSchedReqList->list.array[arrIdx]->schedulingRequestID;
8482       if(cuSchedReqList->list.array[arrIdx]->periodicityAndOffset)
8483       {
8484          fillPucchSchedReqPeriodAndOffset(macSchedReqCfg->schedAddModList[arrIdx].periodicity,\
8485             macSchedReqCfg->schedAddModList[arrIdx].offset, cuSchedReqList->list.array[arrIdx]->periodicityAndOffset);
8486       }
8487       if(cuSchedReqList->list.array[arrIdx]->resource)
8488       {
8489          macSchedReqCfg->schedAddModList[arrIdx].resrc =\
8490             *cuSchedReqList->list.array[arrIdx]->resource;
8491       }
8492    }
8493
8494 }/* End of extractSchedReqCfgToAddMod */
8495
8496  /*******************************************************************
8497  *
8498  * @brief Fills PucchCfg received by CU
8499  *
8500  * @details
8501  *
8502  *    Function : extractPucchCfg
8503  *
8504  *    Functionality: Fills PucchCfg received  by CU
8505  *
8506  * @params[in] BWP_UplinkDedicated__pucch_Config *cuPucchCfg,
8507  *             PucchCfg *macPucchCfg
8508  * @return ROK/RFAILED
8509  *
8510  * ****************************************************************/
8511
8512 uint8_t extractPucchCfg(struct BWP_UplinkDedicated__pucch_Config *cuPucchCfg, PucchCfg *macPucchCfg)
8513 {
8514    uint8_t arrIdx;
8515
8516    if(cuPucchCfg->present == BWP_UplinkDedicated__pucch_Config_PR_setup)
8517    {
8518       if(cuPucchCfg->choice.setup)
8519       {
8520          /* Resource Set Cfg */
8521          if(cuPucchCfg->choice.setup->resourceSetToAddModList)
8522          {
8523             DU_ALLOC_SHRABL_BUF(macPucchCfg->resrcSet, sizeof(PucchResrcSetCfg));
8524             if(macPucchCfg->resrcSet == NULLP)
8525             {
8526                DU_LOG("\nERROR --> F1AP : Failed to extract Resrc set List in extractPucchCfg()");
8527                return RFAILED;
8528             }
8529             memset(macPucchCfg->resrcSet, 0, sizeof(PucchResrcSetCfg));
8530             extractResrcSetToAddModList(macPucchCfg->resrcSet, cuPucchCfg->choice.setup->resourceSetToAddModList);
8531          }
8532
8533          /* Resource Cfg */
8534          if(cuPucchCfg->choice.setup->resourceToAddModList)
8535          {
8536             DU_ALLOC_SHRABL_BUF(macPucchCfg->resrc, sizeof(PucchResrcCfg));
8537             if(macPucchCfg->resrc == NULLP)
8538             {
8539                DU_LOG("\nERROR --> F1AP : Failed to extract Resrc List in extractPucchCfg()");
8540                return RFAILED;
8541             }
8542             memset(macPucchCfg->resrc, 0, sizeof(PucchResrcCfg));
8543             extractResrcToAddModList(macPucchCfg->resrc, cuPucchCfg->choice.setup->resourceToAddModList);
8544          }
8545
8546          /* Format 1 Cfg */
8547          if(cuPucchCfg->choice.setup->format1)
8548          {
8549             DU_ALLOC_SHRABL_BUF(macPucchCfg->format1, sizeof(PucchFormatCfg));
8550             if(macPucchCfg->format1 == NULLP)
8551             {
8552                DU_LOG("\nERROR --> F1AP : Failed to extract format 1 Cfg in  extractPucchCfg()");
8553                return RFAILED;
8554             }
8555             memset(macPucchCfg->format1, 0, sizeof(PucchFormatCfg));
8556             extractPucchFormatCfg(macPucchCfg->format1,\
8557                cuPucchCfg->choice.setup->format1->choice.setup);
8558          }
8559
8560          /* Format 2 Cfg */
8561          if(cuPucchCfg->choice.setup->format2)
8562          {
8563             DU_ALLOC_SHRABL_BUF(macPucchCfg->format2, sizeof(PucchFormatCfg));
8564             if(macPucchCfg->format2 == NULLP)
8565             {
8566                DU_LOG("\nERROR --> F1AP : Failed to extract format 2 Cfg in  extractPucchCfg()");
8567                return RFAILED;
8568             }
8569             memset(macPucchCfg->format2, 0, sizeof(PucchFormatCfg));
8570             extractPucchFormatCfg(macPucchCfg->format2,\
8571                cuPucchCfg->choice.setup->format2->choice.setup);
8572          }
8573
8574          /* Format 3 Cfg */
8575          if(cuPucchCfg->choice.setup->format3)
8576          {
8577             DU_ALLOC_SHRABL_BUF(macPucchCfg->format3, sizeof(PucchFormatCfg));
8578             if(macPucchCfg->format3 == NULLP)
8579             {
8580                DU_LOG("\nERROR --> F1AP : Failed to extract format 3 Cfg in  extractPucchCfg()");
8581                return RFAILED;
8582             }
8583             memset(macPucchCfg->format3, 0, sizeof(PucchFormatCfg));
8584             extractPucchFormatCfg(macPucchCfg->format3,\
8585                cuPucchCfg->choice.setup->format3->choice.setup);
8586          }
8587
8588          /* Format 4 Cfg */
8589          if(cuPucchCfg->choice.setup->format4)
8590          {
8591             DU_ALLOC_SHRABL_BUF(macPucchCfg->format4, sizeof(PucchFormatCfg));
8592             if(macPucchCfg->format4 == NULLP)
8593             {
8594                DU_LOG("\nERROR --> F1AP : Failed to extract format 4 Cfg in  extractPucchCfg()");
8595                return RFAILED;
8596             }
8597             memset(macPucchCfg->format4, 0, sizeof(PucchFormatCfg));
8598             extractPucchFormatCfg(macPucchCfg->format4,\
8599                cuPucchCfg->choice.setup->format4->choice.setup);
8600          }
8601
8602          /* Sched Req List */
8603          if(cuPucchCfg->choice.setup->schedulingRequestResourceToAddModList)
8604          {
8605             DU_ALLOC_SHRABL_BUF(macPucchCfg->schedReq, sizeof(PucchSchedReqCfg));
8606             if(macPucchCfg->schedReq == NULLP)
8607             {
8608                DU_LOG("\nERROR --> F1AP : Failed to extract schedReqCfg in  extractPucchCfg()");
8609                return RFAILED;
8610             }
8611             memset(macPucchCfg->schedReq, 0, sizeof(PucchSchedReqCfg));
8612             extractSchedReqCfgToAddMod(macPucchCfg->schedReq,\
8613             cuPucchCfg->choice.setup->schedulingRequestResourceToAddModList);
8614          }
8615
8616          /*TODO: Add support for  Spatial Info */
8617
8618          /* MultiCsiCfg */
8619          if(cuPucchCfg->choice.setup->multi_CSI_PUCCH_ResourceList)
8620          {
8621             DU_ALLOC_SHRABL_BUF(macPucchCfg->multiCsiCfg, sizeof(PucchMultiCsiCfg));
8622             if(macPucchCfg->multiCsiCfg == NULLP)
8623             {
8624                DU_LOG("\nERROR --> F1AP : Failed to extract multiCsiCfg in  extractPucchCfg()");
8625                return RFAILED;
8626             }
8627             memset(macPucchCfg->multiCsiCfg, 0, sizeof(PucchMultiCsiCfg));
8628             macPucchCfg->multiCsiCfg->multiCsiResrcListCount = cuPucchCfg->choice.setup->multi_CSI_PUCCH_ResourceList->list.count;
8629             for(arrIdx =0; arrIdx < macPucchCfg->multiCsiCfg->multiCsiResrcListCount; arrIdx++)
8630             {
8631                macPucchCfg->multiCsiCfg->multiCsiResrcList[arrIdx] =\
8632                  *cuPucchCfg->choice.setup->multi_CSI_PUCCH_ResourceList->list.array[arrIdx];
8633             }
8634          }
8635
8636          /* Dl_DataToUL_ACK */
8637          if(cuPucchCfg->choice.setup->dl_DataToUL_ACK)
8638          {
8639             DU_ALLOC_SHRABL_BUF(macPucchCfg->dlDataToUlAck, sizeof(PucchDlDataToUlAck));
8640             if(macPucchCfg->dlDataToUlAck == NULLP)
8641             {
8642                DU_LOG("\nERROR --> F1AP : Failed to extract Dl_DataToUL_ACK in extractPucchCfg()");
8643                return RFAILED;
8644             }
8645             memset(macPucchCfg->dlDataToUlAck, 0, sizeof(PucchDlDataToUlAck));
8646             macPucchCfg->dlDataToUlAck->dlDataToUlAckListCount = cuPucchCfg->choice.setup->dl_DataToUL_ACK->list.count;
8647             for(arrIdx = 0; arrIdx < macPucchCfg->dlDataToUlAck->dlDataToUlAckListCount; arrIdx++)
8648             {
8649                macPucchCfg->dlDataToUlAck->dlDataToUlAckList[arrIdx] =\
8650                   *cuPucchCfg->choice.setup->dl_DataToUL_ACK->list.array[arrIdx];
8651             }
8652          }
8653
8654          /* Power Control */
8655          if(cuPucchCfg->choice.setup->pucch_PowerControl)
8656          {
8657             DU_ALLOC_SHRABL_BUF(macPucchCfg->powerControl, sizeof(PucchPowerControl));
8658             if(macPucchCfg->powerControl == NULLP)
8659             {
8660                DU_LOG("\nERROR --> F1AP : Failed to extract power control in extractPucchCfg()");
8661                return RFAILED;
8662             }
8663             extractPucchPowerControl(macPucchCfg->powerControl,\
8664                cuPucchCfg->choice.setup->pucch_PowerControl);
8665          }
8666       }
8667    }
8668    return ROK;
8669 }
8670
8671 /*******************************************************************
8672  *
8673  * @brief Fills ServingCellReconfig received by CU
8674  *
8675  * @details
8676  *
8677  *    Function : extractSpCellDedicatedCfg
8678  *
8679  *    Functionality: Fills ServingCellReconfig received  by CU
8680  *
8681  * @params[in] ServingCellConfig_t *cuSrvCellCfg
8682  *             ServCellCfgInfo *macSrvCellCfg
8683  * @return ROK/RFAILD
8684  *
8685  * ****************************************************************/
8686 uint8_t extractSpCellDedicatedCfg(ServingCellConfig_t *cuSrvCellCfg, ServCellCfgInfo *macSrvCellCfg)
8687 {
8688    uint8_t ret = ROK;
8689    BWP_DownlinkDedicated_t *dlBwp = NULLP;
8690    BWP_UplinkDedicated_t   *ulBwp = NULLP;
8691
8692    if(cuSrvCellCfg->initialDownlinkBWP)
8693    {
8694       dlBwp = ((BWP_DownlinkDedicated_t *)(cuSrvCellCfg->initialDownlinkBWP));
8695       if(dlBwp->pdcch_Config)
8696       {
8697          if(dlBwp->pdcch_Config->choice.setup)
8698          {
8699             macSrvCellCfg->initDlBwp.pdcchPresent = true;
8700             extractPdcchCfg(dlBwp->pdcch_Config->choice.setup, &macSrvCellCfg->initDlBwp.pdcchCfg);
8701          }
8702       }
8703       if(dlBwp->pdsch_Config)
8704       {
8705          if(dlBwp->pdsch_Config->choice.setup)
8706          {
8707             macSrvCellCfg->initDlBwp.pdschPresent = true;
8708             extractPdschCfg(dlBwp->pdsch_Config->choice.setup, &macSrvCellCfg->initDlBwp.pdschCfg);
8709          }
8710       }
8711    }
8712    if(cuSrvCellCfg->firstActiveDownlinkBWP_Id)
8713       macSrvCellCfg->firstActvDlBwpId = *(cuSrvCellCfg->firstActiveDownlinkBWP_Id);
8714    if(cuSrvCellCfg->defaultDownlinkBWP_Id)
8715       macSrvCellCfg->defaultDlBwpId = *(cuSrvCellCfg->defaultDownlinkBWP_Id);
8716    if(cuSrvCellCfg->bwp_InactivityTimer)
8717    {
8718       if(macSrvCellCfg->bwpInactivityTmr)
8719       {
8720          memcpy(macSrvCellCfg->bwpInactivityTmr, cuSrvCellCfg->bwp_InactivityTimer, sizeof(uint8_t));
8721       }
8722       else
8723       {
8724          macSrvCellCfg->bwpInactivityTmr = NULLP;
8725          DU_ALLOC_SHRABL_BUF(macSrvCellCfg->bwpInactivityTmr, sizeof(uint8_t));
8726          if(macSrvCellCfg->bwpInactivityTmr)
8727          {
8728             memcpy(macSrvCellCfg->bwpInactivityTmr, cuSrvCellCfg->bwp_InactivityTimer, sizeof(uint8_t));
8729          }
8730          else
8731          {
8732             DU_LOG("\nERROR  --> F1AP : Memory Alloc failed for bwpInactivityTmr at extractSpCellDedicatedCfg()");
8733             return RFAILED;
8734          }
8735       }
8736    }
8737    if(cuSrvCellCfg->pdsch_ServingCellConfig)
8738    {
8739       if(cuSrvCellCfg->pdsch_ServingCellConfig->choice.setup)
8740       {
8741          ret = extractPdschServingCellCfg(cuSrvCellCfg->pdsch_ServingCellConfig->choice.setup, &macSrvCellCfg->pdschServCellCfg);
8742          if(ret == RFAILED)
8743          {
8744             DU_LOG("\nERROR --> F1AP : Failed at extractPdschServingCellCfg()");
8745             return RFAILED;
8746          }
8747       }
8748    }
8749    if(cuSrvCellCfg->uplinkConfig)
8750    {
8751      if(cuSrvCellCfg->uplinkConfig->initialUplinkBWP)
8752      {
8753         ulBwp = ((BWP_UplinkDedicated_t *)(cuSrvCellCfg->uplinkConfig->initialUplinkBWP));
8754         if(ulBwp->pusch_Config)
8755         {
8756            macSrvCellCfg->initUlBwp.puschPresent = true;
8757            extractPuschCfg(ulBwp->pusch_Config, &macSrvCellCfg->initUlBwp.puschCfg);
8758         }
8759         if(ulBwp->pucch_Config)
8760         {
8761            macSrvCellCfg->initUlBwp.pucchPresent = true;
8762            memset(&macSrvCellCfg->initUlBwp.pucchCfg, 0, sizeof(PucchCfg));
8763            extractPucchCfg(ulBwp->pucch_Config, &macSrvCellCfg->initUlBwp.pucchCfg);
8764         }
8765      }
8766      if(cuSrvCellCfg->uplinkConfig->firstActiveUplinkBWP_Id)
8767         macSrvCellCfg->firstActvUlBwpId = *(cuSrvCellCfg->uplinkConfig->firstActiveUplinkBWP_Id);
8768    }
8769    return ret;
8770 }
8771 /*******************************************************************
8772  *
8773  * @brief Fills Reconfig Cell group Info received by CU
8774  *
8775  * @details
8776  *
8777  *    Function : extractUeReCfgCellInfo
8778  *
8779  *    Functionality: Fills Reconfig Cell group Info received by CU
8780  *
8781  * @params[in] CellGroupConfigRrc_t *macCellGrpCfg
8782  *             MacUeCfg*  macUeCfg
8783  * @return ROK/RFAILED
8784  *
8785  * ****************************************************************/
8786 uint8_t extractUeReCfgCellInfo(CellGroupConfigRrc_t *cellGrp, MacUeCfg *macUeCfg)
8787 {
8788    uint8_t ret = ROK;
8789    MAC_CellGroupConfig_t     *macCellGroup = NULLP;
8790    PhysicalCellGroupConfig_t *phyCellGrpCfg = NULLP;
8791    SpCellConfig_t            *spcellCfg = NULLP;
8792    ServingCellConfig_t       *servCellCfg = NULLP;
8793
8794    if(cellGrp)
8795    {
8796       /* Fill MacCell Group Reconfig  */
8797       if(cellGrp->mac_CellGroupConfig)
8798       {
8799          macUeCfg->macCellGrpCfgPres = true;
8800          macCellGroup = ((MAC_CellGroupConfig_t *)(cellGrp->mac_CellGroupConfig));
8801          if(macCellGroup->schedulingRequestConfig)
8802          {
8803             extractSchReqReConfig(macCellGroup->schedulingRequestConfig, &macUeCfg->macCellGrpCfg.schReqCfg);
8804          }
8805          if(macCellGroup->tag_Config)
8806          {
8807             extractTagReconfig(macCellGroup->tag_Config, &macUeCfg->macCellGrpCfg.tagCfg);
8808          }
8809          if(macCellGroup->bsr_Config)
8810          {
8811             macUeCfg->macCellGrpCfg.bsrTmrCfg.periodicTimer = macCellGroup->bsr_Config->periodicBSR_Timer;
8812             macUeCfg->macCellGrpCfg.bsrTmrCfg.retxTimer     = macCellGroup->bsr_Config->retxBSR_Timer;
8813             if(macCellGroup->bsr_Config->logicalChannelSR_DelayTimer)
8814             {
8815                macUeCfg->macCellGrpCfg.bsrTmrCfg.srDelayTimer  =\
8816                *(macCellGroup->bsr_Config->logicalChannelSR_DelayTimer);
8817             }
8818          }
8819          if(macCellGroup->phr_Config)
8820          {
8821             if(macCellGroup->phr_Config->present == MAC_CellGroupConfig__phr_Config_PR_setup)
8822             {
8823                macUeCfg->macCellGrpCfg.phrCfgSetupPres = true;
8824                if(macCellGroup->phr_Config->choice.setup)
8825                {
8826                   macUeCfg->macCellGrpCfg.phrCfg.periodicTimer     = \
8827                   macCellGroup->phr_Config->choice.setup->phr_PeriodicTimer;
8828                   macUeCfg->macCellGrpCfg.phrCfg.prohibitTimer     = \
8829                   macCellGroup->phr_Config->choice.setup->phr_ProhibitTimer;
8830                   macUeCfg->macCellGrpCfg.phrCfg.txPowerFactor     = \
8831                   macCellGroup->phr_Config->choice.setup->phr_Tx_PowerFactorChange;
8832                   macUeCfg->macCellGrpCfg.phrCfg.multiplePHR       = \
8833                   macCellGroup->phr_Config->choice.setup->multiplePHR;
8834                   macUeCfg->macCellGrpCfg.phrCfg.dummy             = \
8835                   macCellGroup->phr_Config->choice.setup->dummy;
8836                   macUeCfg->macCellGrpCfg.phrCfg.phrType2OtherCell = \
8837                   macCellGroup->phr_Config->choice.setup->phr_Type2OtherCell;
8838                   macUeCfg->macCellGrpCfg.phrCfg.phrOtherCG        = \
8839                   macCellGroup->phr_Config->choice.setup->phr_ModeOtherCG;
8840                }
8841             }
8842          }
8843       }
8844       /* Fill Physical Cell Group Reconfig */
8845       if(cellGrp->physicalCellGroupConfig)
8846       {
8847          macUeCfg->phyCellGrpCfgPres = true;
8848          phyCellGrpCfg = ((PhysicalCellGroupConfig_t *)(cellGrp->physicalCellGroupConfig));
8849          if(phyCellGrpCfg->p_NR_FR1)
8850          {
8851             if(*(phyCellGrpCfg->p_NR_FR1) != macUeCfg->phyCellGrpCfg.pNrFr1)
8852                macUeCfg->phyCellGrpCfg.pNrFr1 = *(phyCellGrpCfg->p_NR_FR1);
8853          }
8854          macUeCfg->phyCellGrpCfg.pdschHarqAckCodebook = phyCellGrpCfg->pdsch_HARQ_ACK_Codebook;
8855       }
8856       /* Fill SpCell Reconfig */
8857       if(cellGrp->spCellConfig)
8858       {
8859          macUeCfg->spCellCfgPres = true;
8860          spcellCfg = ((SpCellConfig_t *)(cellGrp->spCellConfig));
8861          if(spcellCfg->servCellIndex)
8862          {
8863             macUeCfg->spCellCfg.servCellIdx = *(spcellCfg->servCellIndex);
8864          }
8865          /* Fill Serving cell Reconfig info */
8866          if(cellGrp->spCellConfig->spCellConfigDedicated)
8867          {
8868             servCellCfg = ((ServingCellConfig_t *)(cellGrp->spCellConfig->spCellConfigDedicated));
8869             ret = extractSpCellDedicatedCfg(servCellCfg, &macUeCfg->spCellCfg.servCellCfg);
8870             if(ret == RFAILED)
8871             {
8872                DU_LOG("\nERROR --> F1AP : Failed at extractSpCellDedicatedCfg()");
8873             }
8874          }
8875       }
8876    }
8877    return ret;
8878 }
8879 /*******************************************************************
8880 *
8881 * @brief free the memory allocated by decoder
8882 *
8883 * @details
8884 *
8885 *    Function : freeAperDecodeNrcgi
8886 *
8887 *    Functionality: Free Nrcgi values
8888 *
8889 * @params[in] NRCGI_t *nrcgi
8890 * @return void
8891 *
8892 * ****************************************************************/
8893
8894
8895 void freeAperDecodeNrcgi(NRCGI_t *nrcgi)
8896 {
8897     if(nrcgi->pLMN_Identity.buf != NULLP)
8898     {
8899        free(nrcgi->pLMN_Identity.buf);
8900     }
8901     if(nrcgi->nRCellIdentity.buf != NULLP)
8902     {
8903        free(nrcgi->nRCellIdentity.buf);
8904     }
8905 }
8906 /*******************************************************************
8907 *
8908 * @brief free the memory allocated by decoder
8909 *
8910 * @details
8911 *
8912 *    Function : freeAperDecodeCuToDuInfo
8913 *
8914 *    Functionality:  Free Cu To Du Information
8915 *
8916 * @params[in] CUtoDURRCInformation_t *rrcMsg
8917 * @return void
8918 *
8919 * ****************************************************************/
8920
8921
8922 void freeAperDecodeCuToDuInfo(CUtoDURRCInformation_t *rrcMsg)
8923 {
8924    uint8_t ieIdx =0;
8925    uint8_t arrIdx =0;
8926
8927    if(rrcMsg->uE_CapabilityRAT_ContainerList)
8928    {
8929       if(rrcMsg->uE_CapabilityRAT_ContainerList->buf)
8930          free(rrcMsg->uE_CapabilityRAT_ContainerList->buf);
8931       free(rrcMsg->uE_CapabilityRAT_ContainerList);
8932    }
8933
8934    if(rrcMsg->iE_Extensions)
8935    {
8936       if(rrcMsg->iE_Extensions->list.array)
8937       {
8938          for(ieIdx= 0; ieIdx < rrcMsg->iE_Extensions->list.count; ieIdx++)
8939          {
8940             if(rrcMsg->iE_Extensions->list.array[ieIdx])
8941             {
8942                switch(rrcMsg->iE_Extensions->list.array[ieIdx]->id)
8943                {
8944                   case ProtocolIE_ID_id_CellGroupConfig:
8945                      if(rrcMsg->iE_Extensions->list.array[ieIdx]->extensionValue.choice.CellGroupConfig.buf != NULLP)
8946                      {
8947                         free(rrcMsg->iE_Extensions->list.array[ieIdx]->extensionValue.choice.CellGroupConfig.buf);
8948                      }
8949                      break;
8950                   default:
8951                      DU_LOG("\nERROR  -->  F1AP : Invalid Event type %ld at FreeCuToDuInfo()", \
8952                            rrcMsg->iE_Extensions->list.array[ieIdx]->id);
8953                      break;
8954                }
8955             }
8956          }
8957          for(arrIdx = 0; arrIdx < ieIdx; arrIdx++)
8958          {
8959             free(rrcMsg->iE_Extensions->list.array[arrIdx]);
8960          }
8961          free(rrcMsg->iE_Extensions->list.array);
8962
8963       }
8964
8965       free(rrcMsg->iE_Extensions);
8966    }
8967 }
8968 /*******************************************************************
8969 *
8970 * @brief free the memory allocated by decoder
8971 *
8972 * @details
8973 *
8974 *    Function : freeAperDecodeSplCellList
8975 *
8976 *    Functionality: Free Spl Cell List
8977                     where memory allocated by aper_decoder
8978 *
8979 * @params[in]  SCell_ToBeSetup_List_t *spCellLst
8980 * @return void
8981 *
8982 * ****************************************************************/
8983
8984
8985 void freeAperDecodeSplCellList(SCell_ToBeSetup_List_t *spCellLst)
8986 {
8987     uint8_t  cellIdx =0;
8988
8989     if(spCellLst->list.array != NULLP)
8990     {
8991        for(cellIdx=0; cellIdx<spCellLst->list.count; cellIdx++)
8992        {
8993           if(cellIdx==0&&spCellLst->list.array[cellIdx]!=NULLP)
8994           {
8995              freeAperDecodeNrcgi(&spCellLst->list.array[cellIdx]->value.choice.SCell_ToBeSetup_Item.sCell_ID);
8996           }
8997           if(spCellLst->list.array[cellIdx]!=NULLP)
8998           {
8999              free(spCellLst->list.array[cellIdx]);
9000           }
9001        }
9002        free(spCellLst->list.array);
9003     }
9004 }
9005 /*******************************************************************
9006 *
9007 * @brief free the memory allocated by decoder
9008 *
9009 * @details
9010 *
9011 *    Function : freeAperDecodeSRBSetup
9012 *
9013 *    Functionality: added free part for the memory allocated by aper_decoder
9014 *
9015 * @params[in] SRBs_ToBeSetup_List_t *srbSet
9016 * @return void
9017 *
9018 ****************************************************************/
9019
9020
9021 void freeAperDecodeSRBSetup(SRBs_ToBeSetup_List_t *srbSet)
9022 {
9023     uint8_t srbIdx =0;
9024     if(srbSet->list.array != NULLP)
9025     {
9026        for(srbIdx=0; srbIdx<srbSet->list.count; srbIdx++)
9027        {
9028           if(srbSet->list.array[srbIdx]!=NULLP)
9029           {
9030              free(srbSet->list.array[srbIdx]);
9031           }
9032        }
9033        free(srbSet->list.array);
9034     }
9035 }
9036
9037 /*******************************************************************
9038 *
9039 * @brief free the memory allocated by decoder
9040 *
9041 * @details
9042 *
9043 *    Function : freeAperDecodeULTnlInfo
9044 *
9045 *    Functionality: added free part for the memory allocated by aper_decoder
9046 *
9047 * @params[in] ULUPTNLInformation_ToBeSetup_List_t *ulInfo
9048 * @return void
9049 *
9050 * ****************************************************************/
9051
9052
9053 void freeAperDecodeULTnlInfo(ULUPTNLInformation_ToBeSetup_List_t *ulInfo)
9054 {
9055    uint8_t ulIdx=0;
9056    if(ulInfo->list.array != NULLP)
9057    {
9058       for(ulIdx=0; ulIdx<ulInfo->list.count; ulIdx++)
9059       {
9060          if(ulIdx==0&&ulInfo->list.array[ulIdx]!=NULLP)
9061          {
9062             if(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel!=NULLP)
9063             {
9064                if(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel->\
9065                      transportLayerAddress.buf != NULLP)
9066                {
9067                   if(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf\
9068                         !=NULLP)
9069                   {
9070                      free(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf);
9071                   }
9072                   free(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel->\
9073                         transportLayerAddress.buf);
9074                }
9075                free(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel);
9076             }
9077          }
9078          if(ulInfo->list.array[ulIdx]!=NULLP)
9079          {
9080             free(ulInfo->list.array[ulIdx]);
9081          }
9082       }
9083       free(ulInfo->list.array);
9084    }
9085 }
9086 /*******************************************************************
9087 *
9088 * @brief free the memory allocated by decoder
9089 *
9090 * @details
9091 *
9092 *    Function : freeAperDecodeDRBSetup
9093 *
9094 *    Functionality: free DRBSetup which is allocated by decoder
9095 *
9096 * @params[in]  DRBs_ToBeSetup_List_t *drbSet
9097 * @return void
9098 *
9099 * ****************************************************************/
9100
9101 void freeAperDecodeDRBSetup(DRBs_ToBeSetup_List_t *drbSet)
9102 {
9103    DRBs_ToBeSetup_Item_t *drbSetItem = NULLP;
9104    uint8_t  flowIdx =0;
9105    uint8_t  drbIdx =0;
9106
9107    if(drbSet->list.array != NULLP)
9108    {
9109       for(drbIdx=0; drbIdx<drbSet->list.count; drbIdx++)
9110       {
9111          if(drbIdx==0&&drbSet->list.array[drbIdx] != NULLP)
9112          {
9113             drbSetItem =&drbSet->list.array[drbIdx]->value.choice.DRBs_ToBeSetup_Item;
9114             if(drbSetItem->qoSInformation.choice.choice_extension != NULLP)
9115             {
9116                if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
9117                      qoS_Characteristics.choice.non_Dynamic_5QI !=NULLP)
9118                {
9119                   if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
9120                         qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow!=NULLP)
9121                   {
9122                      if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
9123                            qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume!=NULLP)
9124                      {
9125
9126                         if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sST.buf!=NULLP)
9127                         {
9128
9129                            if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD!=NULLP)
9130                            {
9131
9132                               if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD->\
9133                                     buf!=NULLP)
9134                               {
9135
9136                                  if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.\
9137                                        flows_Mapped_To_DRB_List.list.array != NULLP)
9138                                  {
9139
9140                                     for(flowIdx=0;flowIdx<drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9141                                           DRB_Information.flows_Mapped_To_DRB_List.list.count; flowIdx++)
9142                                     {
9143
9144                                        if(flowIdx==0&&drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9145                                              DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]!=NULLP)
9146                                        {
9147                                           if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9148                                                 DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
9149                                                 qoSFlowLevelQoSParameters.\
9150                                                 qoS_Characteristics.choice.non_Dynamic_5QI!=NULLP)
9151                                           {
9152                                              if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9153                                                    DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
9154                                                    qoSFlowLevelQoSParameters.\
9155                                                    qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow!=NULLP)
9156                                              {
9157
9158                                                 if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9159                                                       DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
9160                                                       qoSFlowLevelQoSParameters.\
9161                                                       qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume!=NULLP)
9162                                                 {
9163
9164
9165                                                    free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9166                                                          DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
9167                                                          qoSFlowLevelQoSParameters.\
9168                                                          qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume);
9169                                                 }
9170
9171                                                 free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9172                                                       DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
9173                                                       qoSFlowLevelQoSParameters.\
9174                                                       qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow);
9175                                              }
9176
9177                                              free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9178
9179                                                    DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
9180                                                    qoSFlowLevelQoSParameters.\
9181                                                    qoS_Characteristics.choice.non_Dynamic_5QI);
9182                                           }
9183                                        }
9184                                        if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9185                                              DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]!=NULLP)
9186                                        {
9187
9188                                           free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9189                                                 DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]);
9190                                        }
9191                                     }
9192
9193                                     free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9194                                           DRB_Information.flows_Mapped_To_DRB_List.list.array);
9195                                  }
9196
9197                                  free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9198                                        DRB_Information.sNSSAI.sD->buf);
9199                               }
9200
9201                               free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD);
9202                            }
9203
9204                            free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sST.buf);
9205
9206                         }
9207
9208                         free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
9209
9210                               qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume);
9211                      }
9212
9213                      free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
9214                            qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow);
9215                   }
9216
9217                   free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
9218                         qoS_Characteristics.choice.non_Dynamic_5QI);
9219                }
9220                free(drbSetItem->qoSInformation.choice.choice_extension);
9221             }
9222             freeAperDecodeULTnlInfo(&drbSetItem->uLUPTNLInformation_ToBeSetup_List);
9223             if(drbSetItem->uLConfiguration)
9224             {
9225                free(drbSetItem->uLConfiguration);
9226             }
9227          }
9228          if(drbSet->list.array[drbIdx]!=NULLP)
9229          {
9230             free(drbSet->list.array[drbIdx]);
9231          }
9232       }
9233       free(drbSet->list.array);
9234    }
9235 }
9236
9237
9238 /*******************************************************************
9239  *
9240  * @brief builds Mac Cell Cfg
9241  *
9242  * @details
9243  *
9244  *    Function : procUeReCfgCellInfo
9245  *
9246  *    Functionality: builds Mac Cell Cfg
9247  *
9248  * @params[in] MacUeCfg pointer
9249  *             void pointer
9250  *
9251  * @return void
9252  *
9253  * ****************************************************************/
9254 uint8_t procUeReCfgCellInfo(MacUeCfg *macUeCfg, void *cellInfo)
9255 {
9256    uint8_t ret = ROK;
9257    CellGroupConfigRrc_t *cellGrp = NULLP;
9258
9259    if(cellInfo)
9260    {
9261       cellGrp = (CellGroupConfigRrc_t *)cellInfo;
9262       ret = extractUeReCfgCellInfo(cellGrp, macUeCfg);
9263       if(ret == RFAILED)
9264          DU_LOG("\nERROR  -->  F1AP : Failed at procUeReCfgCellInfo()");
9265    }
9266    if(ret == RFAILED)
9267    {
9268       freeUeReCfgCellGrpInfo(macUeCfg);
9269    }
9270    return ret;
9271 }
9272
9273 /*******************************************************************
9274  *
9275  * @brief Filling modulation info in mac ue cfg
9276  *
9277  * @details
9278  *
9279  *    Function : duFillModulationDetails
9280  *
9281  *    Functionality: Filling modulation info in mac ue cfg
9282  *
9283  * @params[in] MAC UE Config to be updated
9284  *             Current UE configuration
9285  *             UE NR capability from CU
9286  * @return ROK     - success
9287  *         RFAILED - failure
9288  *
9289  * ****************************************************************/
9290 void duFillModulationDetails(MacUeCfg *ueCfg, MacUeCfg *oldUeCfg, void *ueCap)
9291 {
9292    UE_NR_Capability_t *ueNrCap=NULLP;
9293
9294    if(ueCap)
9295       ueNrCap = (UE_NR_Capability_t *)ueCap;
9296
9297    /* Filling DL modulation info */
9298    if(ueNrCap->featureSets && ueNrCap->featureSets->featureSetsDownlinkPerCC && \
9299          ueNrCap->featureSets->featureSetsDownlinkPerCC->list.array[0] && \
9300          ueNrCap->featureSets->featureSetsDownlinkPerCC->list.array[0]->supportedModulationOrderDL)
9301    {
9302       switch(*(ueNrCap->featureSets->featureSetsDownlinkPerCC->list.array[0]->supportedModulationOrderDL))
9303       {
9304          case ModulationOrder_qpsk:
9305             {
9306                ueCfg->dlModInfo.modOrder = MOD_ORDER_QPSK;
9307                break;
9308             }
9309          case ModulationOrder_qam16:
9310             {
9311                ueCfg->dlModInfo.modOrder = MOD_ORDER_QAM16;
9312                break;
9313             }
9314          case ModulationOrder_qam64:
9315             {
9316                ueCfg->dlModInfo.modOrder = MOD_ORDER_QAM64;
9317                ueCfg->dlModInfo.mcsIndex = PDSCH_MCS_INDEX;
9318                ueCfg->dlModInfo.mcsTable = MCS_TABLE_QAM64;
9319                break;
9320             }
9321          case ModulationOrder_qam256:
9322             {
9323                ueCfg->dlModInfo.modOrder = MOD_ORDER_QAM256;
9324                break;
9325             }
9326          default:
9327             {
9328                DU_LOG("\nERROR  -->  DU APP: Incorrect downlink modulation order received. Reatining old modulation configuration");
9329                memcpy(&ueCfg->dlModInfo, &oldUeCfg->dlModInfo, sizeof(ModulationInfo));
9330                break;
9331             }
9332       }
9333    }
9334    else
9335    {
9336       memcpy(&ueCfg->dlModInfo, &oldUeCfg->dlModInfo, sizeof(ModulationInfo));
9337    }
9338
9339    /* Filling UL modulation info */
9340    if(ueNrCap->featureSets && ueNrCap->featureSets->featureSetsUplinkPerCC && \
9341          ueNrCap->featureSets->featureSetsUplinkPerCC->list.array[0] && \
9342          ueNrCap->featureSets->featureSetsUplinkPerCC->list.array[0]->supportedModulationOrderUL)
9343    {
9344       switch(*(ueNrCap->featureSets->featureSetsUplinkPerCC->list.array[0]->supportedModulationOrderUL))
9345       {
9346          case ModulationOrder_qpsk:
9347             {
9348                ueCfg->ulModInfo.modOrder = MOD_ORDER_QPSK;
9349                break;
9350             }
9351          case ModulationOrder_qam16:
9352             {
9353                ueCfg->ulModInfo.modOrder = MOD_ORDER_QAM16;
9354                ueCfg->ulModInfo.mcsIndex = PUSCH_MCS_INDEX;
9355                ueCfg->ulModInfo.mcsTable = MCS_TABLE_QAM64;
9356                break;
9357             }
9358          case ModulationOrder_qam64:
9359             {
9360                ueCfg->ulModInfo.modOrder = MOD_ORDER_QAM64;
9361                break;
9362             }
9363          case ModulationOrder_qam256:
9364             {
9365                ueCfg->ulModInfo.modOrder = MOD_ORDER_QAM256;
9366                break;
9367             }
9368          default:
9369             {
9370                DU_LOG("\nERROR  -->  DU APP: Incorrect uplink modulation order received. Reatining old modulation configuration");
9371                memcpy(&ueCfg->ulModInfo, &oldUeCfg->ulModInfo, sizeof(ModulationInfo));
9372                break;
9373             }
9374       }
9375    }
9376    else
9377    {
9378       memcpy(&ueCfg->ulModInfo, &oldUeCfg->ulModInfo, sizeof(ModulationInfo));
9379    }
9380 }
9381
9382 /*******************************************************************
9383  *
9384  * @brief Function to extract cellGrp Info present in cutoDu cont
9385  *
9386  * @details
9387  *
9388  *    Function : extractCellGrpInfo
9389  *
9390  *    Functionality: Function to extract cellGrp Info present
9391  *                   in cutoDu cont
9392  *
9393  * @params[in] ProtocolExtensionContainer_4624P16_t pointer
9394  *
9395  * @return CellGroupConfigRrc_t *
9396  *
9397  * ****************************************************************/
9398
9399 CellGroupConfigRrc_t *extractCellGrpInfo(ProtocolExtensionContainer_4624P16_t *protocolIeExtn,\
9400       DuUeCfg *ueCfgDb)
9401 {
9402    uint8_t idx2 =0;
9403    uint16_t id =0;
9404    uint16_t recvBufLen =0;
9405    CellGroupConfigRrc_t *cellGrpCfg = NULLP;
9406    CUtoDURRCInformation_ExtIEs_t *extIeInfo = NULLP;
9407    asn_dec_rval_t rval; /* Decoder return value */
9408    memset(&rval, 0, sizeof(asn_dec_rval_t));
9409
9410    if(protocolIeExtn)
9411    {
9412       for(idx2 = 0; idx2 < protocolIeExtn->list.count; idx2++)
9413       {
9414          extIeInfo = ((CUtoDURRCInformation_ExtIEs_t *)(protocolIeExtn->list.array[idx2]));
9415          id = extIeInfo->id;
9416          switch(id)
9417          {
9418             case ProtocolIE_ID_id_CellGroupConfig:
9419             {
9420                recvBufLen = extIeInfo->extensionValue.choice.CellGroupConfig.size;
9421                /* decoding the CellGroup Buf received */
9422                DU_ALLOC(cellGrpCfg, sizeof(CellGroupConfigRrc_t));
9423                if(cellGrpCfg)
9424                {
9425                   memset(cellGrpCfg, 0, sizeof(CellGroupConfigRrc_t));
9426                   rval = aper_decode(0, &asn_DEF_CellGroupConfigRrc, (void **)&cellGrpCfg,
9427                      extIeInfo->extensionValue.choice.CellGroupConfig.buf, recvBufLen, 0, 0);
9428                   if(rval.code == RC_FAIL || rval.code == RC_WMORE)
9429                   {
9430                      DU_LOG("\nERROR  -->  F1AP : ASN decode failed at decodeCellGrpCfg()");
9431                      return NULLP;
9432                   }
9433                   xer_fprint(stdout, &asn_DEF_CellGroupConfigRrc, cellGrpCfg);
9434                   if(extractRlcCfgToAddMod(cellGrpCfg->rlc_BearerToAddModList, ueCfgDb))
9435                      return NULLP;
9436                }
9437                break;
9438             }
9439             default:
9440                DU_LOG("\nERROR  -->  F1AP : Invalid IE received CUtoDURRCInformation:%d at decodeCellGrpCfg()", id);
9441                break;
9442          }
9443       }
9444    }
9445    return cellGrpCfg;
9446 }
9447
9448 /*******************************************************************
9449  *
9450  * @brief Fills Srb List received by CU
9451  *
9452  * @details
9453  *
9454  *    Function : procSrbListToSetup
9455  *
9456  *    Functionality: Fills Srb List received  by CU
9457  *
9458  * @params[in] SRBs_ToBeSetup_Item_t *cuSrbItem
9459  *             LcCfg pointer
9460  *             RlcBearerCfg pointer
9461  * @return void
9462  *
9463  * ****************************************************************/
9464 uint8_t procSrbListToSetup(SRBs_ToBeSetup_Item_t * srbItem, LcCfg *macLcToAdd, RlcBearerCfg *rlcLcToAdd)
9465 {
9466    uint8_t ret = ROK;
9467
9468    /* Filling RLC INFO */
9469    procRlcLcCfg(srbItem->sRBID, srbItem->sRBID, RB_TYPE_SRB, RLC_AM, CONFIG_ADD, NULL, rlcLcToAdd);
9470
9471    /* Filling MAC INFO */
9472    ret = procMacLcCfg(srbItem->sRBID, RB_TYPE_SRB, CONFIG_ADD, NULL,NULL, NULL, macLcToAdd, NULL);
9473    if(ret == RFAILED)
9474    {
9475       DU_LOG("\nERROR  -->  F1AP : Failed at MAC LC Cfg in procSrbListToSetup()");
9476       return ret;
9477    }
9478    return ret;
9479 }
9480
9481
9482
9483 /*******************************************************************
9484  *
9485  * @brief extract Srb List received by CU
9486  *
9487  * @details
9488  *
9489  *    Function : extractSrbListToSetup
9490  *
9491  *    Functionality: extract Srb List received by CU
9492  *                   for both MAC and RLC
9493  *
9494  * @params[in] SRBs_ToBeSetup_Item_t pointer
9495  *             DuUeCfg pointer
9496  * @return ROK/RFAIED
9497  *
9498  * ****************************************************************/
9499
9500 uint8_t extractSrbListToSetup(SRBs_ToBeSetup_List_t *srbCfg, DuUeCfg *ueCfgDb)
9501 {
9502    uint8_t ret, srbIdx;
9503    SRBs_ToBeSetup_Item_t *srbItem = NULLP;
9504
9505    if(srbCfg)
9506    {
9507       for(srbIdx = 0; srbIdx < srbCfg->list.count; srbIdx++)
9508       {
9509          srbItem = &srbCfg->list.array[srbIdx]->value.choice.SRBs_ToBeSetup_Item;
9510          if(ueCfgDb->numMacLcs > MAX_NUM_LC)
9511          {
9512             DU_LOG("\nERROR   -->  F1AP:  MAX LC Reached in MAC");
9513             ret = RFAILED;
9514             break;
9515          }
9516          if(ueCfgDb->numRlcLcs > MAX_NUM_LC)
9517          {
9518             DU_LOG("\nERROR   -->  F1AP:  MAX LC Reached in RLC");
9519             ret = RFAILED;
9520             break;
9521          }
9522          memset(&ueCfgDb->macLcCfg[ueCfgDb->numMacLcs], 0, sizeof(LcCfg));
9523          memset(&ueCfgDb->rlcLcCfg[ueCfgDb->numRlcLcs], 0, sizeof(RlcBearerCfg));
9524          ret = procSrbListToSetup(srbItem, &ueCfgDb->macLcCfg[ueCfgDb->numMacLcs],\
9525             &ueCfgDb->rlcLcCfg[ueCfgDb->numRlcLcs]);
9526          ueCfgDb->numRlcLcs++;
9527          ueCfgDb->numMacLcs++;
9528          if(ret == RFAILED)
9529          {
9530             DU_LOG("\nERROR  -->  F1AP:  Failed at extractSrbListToSetup()");
9531             break;
9532          }
9533       }
9534    }
9535    else
9536       ret = RFAILED;
9537
9538    return ret;
9539 }
9540
9541 /*******************************************************************
9542  *
9543  * @brief Fills Drb List received by CU
9544  *
9545  * @details
9546  *
9547  *    Function : procDrbListToSetup
9548  *
9549  *    Functionality: Fills Drb List received by CU
9550  *                   for both MAC and RLC
9551  *
9552  * @params[in] SRBs_ToBeSetup_Item_t pointer
9553  *             LcCfg pointer,
9554  *             RlcBearerCfg pointer
9555  * @return void
9556  *
9557  * ****************************************************************/
9558
9559 uint8_t procDrbListToSetup(uint8_t lcId, DRBs_ToBeSetup_Item_t *drbItem,\
9560 DRBs_ToBeSetupMod_Item_t *drbSetupModItem, LcCfg *macLcToAdd, RlcBearerCfg *rlcLcToAdd, UpTnlCfg *upTnlInfo)
9561 {
9562
9563    if(drbItem != NULLP)
9564    {
9565       /* Filling RLC INFO */
9566       procRlcLcCfg(drbItem->dRBID, lcId, RB_TYPE_DRB, drbItem->rLCMode, CONFIG_ADD, NULL, rlcLcToAdd);
9567
9568       /* Filling MAC INFO */
9569       if(procMacLcCfg(lcId, RB_TYPE_DRB, CONFIG_ADD, drbItem, NULL, NULL, macLcToAdd, upTnlInfo) != ROK)
9570       {
9571          DU_LOG("\nERROR  --> F1AP : Failed at RLC LC Cfg in procDrbListToSetup()");
9572          return RFAILED;
9573       }
9574    }
9575    else if(drbSetupModItem != NULLP)
9576    {
9577       procRlcLcCfg(drbSetupModItem->dRBID, lcId, RB_TYPE_DRB, drbSetupModItem->rLCMode, CONFIG_ADD, NULL, rlcLcToAdd);
9578
9579       if(procMacLcCfg(lcId, RB_TYPE_DRB, CONFIG_ADD, NULL, drbSetupModItem, NULL, macLcToAdd, upTnlInfo) != ROK)
9580       {
9581          DU_LOG("\nERROR  --> F1AP : Failed at RLC LC Cfg in procDrbListToSetup()");
9582          return RFAILED;
9583       }
9584    }
9585    return ROK;
9586 }
9587
9588 /*******************************************************************
9589  *
9590  * @brief extract Drb List received by CU
9591  *
9592  * @details
9593  *
9594  *    Function : extractDrbListToSetup
9595  *
9596  *    Functionality: extract Drb List received by CU
9597  *                   for both MAC and RLC
9598  *
9599  * @params[in] DRBs_ToBeSetup_Item_t pointer
9600  *             DuUeCfg pointer
9601  * @return ROK/RFAIED
9602  *
9603  * ****************************************************************/
9604
9605 uint8_t extractDrbListToSetup(uint8_t lcId, DRBs_ToBeSetup_List_t *drbCfg,DRBs_ToBeSetupMod_List_t *drbSetupModCfg,\
9606 uint8_t drbCount, DuUeCfg *ueCfgDb)
9607 {
9608    uint8_t ret, drbIdx;
9609    DRBs_ToBeSetup_Item_t *drbItem = NULLP;
9610    DRBs_ToBeSetupMod_ItemIEs_t *drbSetupModItem = NULLP;
9611
9612    ret = ROK;
9613    if(drbCount > 0)
9614    {
9615       for(drbIdx = 0; drbIdx < drbCount; drbIdx++)
9616       {
9617          if(ueCfgDb->numMacLcs > MAX_NUM_LC)
9618          {
9619             DU_LOG("\nERROR  -->  F1AP :  MAX LC Reached in MAC at extractDrbListToSetup()");
9620             ret = RFAILED;
9621             break;
9622          }
9623          if(ueCfgDb->numRlcLcs > MAX_NUM_LC)
9624          {
9625             DU_LOG("\nERROR  -->  F1AP :  MAX LC Reached in RLC at extractDrbListToSetup()");
9626             ret = RFAILED;
9627             break;
9628          }
9629          memset(&ueCfgDb->macLcCfg[ueCfgDb->numMacLcs], 0, sizeof(LcCfg));
9630          memset(&ueCfgDb->rlcLcCfg[ueCfgDb->numRlcLcs], 0, sizeof(RlcBearerCfg));
9631
9632          if(drbCfg != NULL)
9633          {
9634             drbItem = &drbCfg->list.array[drbIdx]->value.choice.DRBs_ToBeSetup_Item;
9635             ret = procDrbListToSetup(lcId, drbItem, NULL, &ueCfgDb->macLcCfg[ueCfgDb->numMacLcs],\
9636                &ueCfgDb->rlcLcCfg[ueCfgDb->numRlcLcs], &ueCfgDb->upTnlInfo[ueCfgDb->numDrb]);
9637             if(ret == RFAILED)
9638             {
9639                DU_LOG("\nERROR  --> F1AP : Failed at extractDrbListToSetup()");
9640                break;
9641             }
9642          }
9643          else if(drbSetupModCfg != NULL)
9644          {
9645             drbSetupModItem = (DRBs_ToBeSetupMod_ItemIEs_t *) drbSetupModCfg->list.array[drbIdx];
9646             ret = procDrbListToSetup(lcId, NULL, &(drbSetupModItem->value.choice.DRBs_ToBeSetupMod_Item) ,\
9647             &ueCfgDb->macLcCfg[ueCfgDb->numMacLcs], &ueCfgDb->rlcLcCfg[ueCfgDb->numRlcLcs],\
9648             &ueCfgDb->upTnlInfo[ueCfgDb->numDrb]);
9649             if(ret == RFAILED)
9650             {
9651                DU_LOG("\nERROR  --> F1AP : Failed at extractDrbListToSetup()");
9652                break;
9653             }
9654          }
9655          ueCfgDb->numRlcLcs++;
9656          ueCfgDb->numMacLcs++;
9657          ueCfgDb->numDrb++;
9658          if(ret == RFAILED)
9659          {
9660             DU_LOG("\nERROR  --> F1AP : Failed at extractDrbListToSetup()");
9661             break;
9662          }
9663       }
9664    }
9665    else
9666       ret = RFAILED;
9667
9668    return ret;
9669 }
9670
9671 /*******************************************************************
9672  *
9673  * @brief Function to extract Dl RRC Msg received from CU
9674  *
9675  * @details
9676  *
9677  *    Function : extractDlRrcMsg
9678  *
9679  *    Functionality: Function to extract Dl RRC Msg received from CU
9680  *
9681  * @params[in] F1AP message
9682  * @return ROK     - success
9683  *         RFAILED - failure
9684  *
9685  * ****************************************************************/
9686
9687 uint8_t extractDlRrcMsg(uint32_t gnbDuUeF1apId, uint32_t gnbCuUeF1apId, \
9688    F1DlRrcMsg *dlRrcMsg, RRCContainer_t *rrcContainer)
9689 {
9690    uint8_t ret = ROK;
9691    dlRrcMsg->rrcMsgSize = rrcContainer->size;
9692    if(dlRrcMsg->rrcMsgSize > 0)
9693    {
9694       DU_ALLOC_SHRABL_BUF(dlRrcMsg->rrcMsgPdu, dlRrcMsg->rrcMsgSize);
9695       if(!dlRrcMsg->rrcMsgPdu)
9696       {
9697          DU_LOG("\nERROR  --> DU APP : Memory allocation failed for RRC Msg in extractDlRrcMsg()");
9698          ret = RFAILED;
9699       }
9700       else
9701       {
9702          dlRrcMsg->gnbDuUeF1apId = gnbDuUeF1apId;
9703          dlRrcMsg->gnbCuUeF1apId = gnbCuUeF1apId;
9704          dlRrcMsg->srbId = SRB1_LCID;
9705          memcpy(dlRrcMsg->rrcMsgPdu, rrcContainer->buf, dlRrcMsg->rrcMsgSize);
9706       }
9707    }
9708    return ret;
9709 }
9710
9711 /*******************************************************************
9712  *
9713  * @brief Extract UE capability info
9714  *
9715  * @details
9716  *
9717  *    Function : extractUeCapability
9718  *
9719  *    Functionality: Extract UE capability info and stores in ue Cb
9720  *
9721  * @params[in] Octet string of UE capability RAT container list
9722  * @return ROK     - success
9723  *         RFAILED - failure
9724  *
9725  * ****************************************************************/
9726 UE_NR_Capability_t *extractUeCapability(UE_CapabilityRAT_ContainerList_t *ueCapablityListBuf, DuUeCb *ueCb)
9727 {
9728    uint8_t  idx;
9729    uint16_t recvBufLen;
9730    asn_dec_rval_t rval;
9731    UE_NR_Capability_t  *ueNrCap = NULLP;
9732    UE_CapabilityRAT_ContainerListRRC_t  *ueCapRatContList = NULLP;
9733
9734    /* Decoding UE Capability RAT Container List */
9735    recvBufLen = ueCapablityListBuf->size;
9736    DU_ALLOC(ueCapRatContList, sizeof(UE_CapabilityRAT_ContainerListRRC_t));
9737    if(!ueCapRatContList)
9738    {
9739       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in extractUeCapability");
9740       return NULLP;
9741    }
9742    memset(ueCapRatContList, 0, sizeof(UE_CapabilityRAT_ContainerListRRC_t));
9743    memset(&rval, 0, sizeof(asn_dec_rval_t));
9744    rval = aper_decode(0, &asn_DEF_UE_CapabilityRAT_ContainerListRRC, (void **)&ueCapRatContList,
9745           ueCapablityListBuf->buf, recvBufLen, 0, 0);
9746    if(rval.code == RC_FAIL || rval.code == RC_WMORE)
9747    {
9748       DU_LOG("\nERROR  -->  F1AP : ASN decode failed at decodeCellGrpCfg()");
9749       return NULLP;
9750    }
9751    xer_fprint(stdout, &asn_DEF_UE_CapabilityRAT_ContainerListRRC, ueCapRatContList);
9752
9753    /* Free encoded buffer after decoding */
9754
9755    for(idx = 0; idx < ueCapRatContList->list.count; idx++)
9756    {
9757       if(ueCapRatContList->list.array[idx]->rat_Type == RAT_Type_nr)
9758       {
9759          /* Decoding UE NR Capability */
9760           recvBufLen = ueCapRatContList->list.array[idx]->ue_CapabilityRAT_Container.size;
9761           DU_ALLOC(ueNrCap, sizeof(UE_NR_Capability_t));
9762           if(!ueNrCap)
9763           {
9764              DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in extractUeCapability");
9765              DU_FREE(ueCapRatContList, sizeof(UE_CapabilityRAT_ContainerListRRC_t));
9766              return NULLP;
9767           }
9768           memset(ueNrCap, 0, sizeof(UE_NR_Capability_t));
9769           memset(&rval, 0, sizeof(asn_dec_rval_t));
9770           rval = aper_decode(0, &asn_DEF_UE_NR_Capability, (void **)&ueNrCap,
9771                  ueCapRatContList->list.array[idx]->ue_CapabilityRAT_Container.buf, recvBufLen, 0, 0);
9772           if(rval.code == RC_FAIL || rval.code == RC_WMORE)
9773           {
9774              DU_LOG("\nERROR  -->  F1AP : ASN decode failed at decodeCellGrpCfg()");
9775              return NULLP;
9776           }
9777           xer_fprint(stdout, &asn_DEF_UE_NR_Capability, ueNrCap);
9778
9779           /* Free encoded buffer after decoding */
9780           free(ueCapRatContList->list.array[idx]->ue_CapabilityRAT_Container.buf);
9781       }
9782       free(ueCapRatContList->list.array[idx]);
9783    }
9784
9785    /* Free Memory*/
9786    free(ueCapRatContList->list.array);
9787    DU_FREE(ueCapRatContList, sizeof(UE_CapabilityRAT_ContainerListRRC_t));
9788    return ueNrCap;
9789 }
9790
9791 /*******************************************************************
9792 *
9793 * @brief free UE context setup request from CU
9794 *
9795 * @details
9796 *
9797 *    Function : freeAperDecodeF1UeContextSetupReq
9798 *
9799 *    Functionality: freeing part for the memory allocated by aper_decoder
9800 *
9801 * @params[in] F1AP message
9802 * @return ROK     - success
9803 *         RFAILED - failure
9804 *
9805 * ****************************************************************/
9806 void freeAperDecodeF1UeContextSetupReq(UEContextSetupRequest_t   *ueSetReq)
9807 {
9808    uint8_t ieIdx = 0;
9809
9810    if(ueSetReq->protocolIEs.list.array != NULLP)
9811    {
9812       for(ieIdx = 0; ieIdx < ueSetReq->protocolIEs.list.count; ieIdx++)
9813       {
9814          if(ueSetReq->protocolIEs.list.array[ieIdx])
9815          {
9816             switch(ueSetReq->protocolIEs.list.array[ieIdx]->id)
9817             {
9818                case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
9819                   break;
9820                case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
9821                   break;
9822                case ProtocolIE_ID_id_SpCell_ID:
9823                   freeAperDecodeNrcgi(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.NRCGI);
9824                   break;
9825                case ProtocolIE_ID_id_ServCellIndex:
9826                   break;
9827                case ProtocolIE_ID_id_SpCellULConfigured:
9828                   break;
9829                case ProtocolIE_ID_id_CUtoDURRCInformation:
9830
9831                   freeAperDecodeCuToDuInfo(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.CUtoDURRCInformation);
9832                   break;
9833                case ProtocolIE_ID_id_SCell_ToBeSetup_List:
9834
9835                   freeAperDecodeSplCellList(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.SCell_ToBeSetup_List);
9836                   break;
9837                case ProtocolIE_ID_id_SRBs_ToBeSetup_List:
9838
9839                   freeAperDecodeSRBSetup(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.SRBs_ToBeSetup_List);
9840                   break;
9841                case ProtocolIE_ID_id_DRBs_ToBeSetup_List:
9842
9843                   freeAperDecodeDRBSetup(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.DRBs_ToBeSetup_List);
9844                   break;
9845                case ProtocolIE_ID_id_RRCContainer:
9846                   {
9847
9848                      if(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf != NULLP)
9849                      {
9850
9851                         free(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf);
9852                      }
9853                      break;
9854                   }
9855                case ProtocolIE_ID_id_RRCDeliveryStatusRequest:
9856                   break;
9857                case ProtocolIE_ID_id_GNB_DU_UE_AMBR_UL:
9858                   {
9859                      if(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.BitRate.buf)
9860                      {
9861                         free(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.BitRate.buf);
9862                      }
9863                      break;
9864                   }
9865                default:
9866                   DU_LOG("\nERROR  -->  F1AP: Invalid event type %ld " ,ueSetReq->protocolIEs.list.array[ieIdx]->id);
9867             }
9868             free(ueSetReq->protocolIEs.list.array[ieIdx]);
9869          }
9870       }
9871       free(ueSetReq->protocolIEs.list.array);
9872    }
9873 }
9874 /*******************************************************************
9875  *
9876  * @brief Process UE context setup request from CU
9877  *
9878  * @details
9879  *
9880  *    Function : procF1UeContextSetupReq
9881  *
9882  *    Functionality: Process UE context setup request from CU
9883  *
9884  * @params[in] F1AP message
9885  * @return ROK     - success
9886  *         RFAILED - failure
9887  *
9888  * ****************************************************************/
9889 uint8_t procF1UeContextSetupReq(F1AP_PDU_t *f1apMsg)
9890 {
9891    uint8_t  ret=0, ieIdx=0, ueIdx=0, lcId=0, cellIdx=0;
9892    bool ueCbFound = false;
9893    uint32_t gnbCuUeF1apId=0, gnbDuUeF1apId=0, bitRateSize=0;
9894    DuUeCb   *duUeCb = NULL;
9895    UEContextSetupRequest_t   *ueSetReq = NULL;
9896    DRBs_ToBeSetup_List_t *drbCfg = NULL;
9897
9898    ret = ROK;
9899
9900    ueSetReq = &f1apMsg->choice.initiatingMessage->value.choice.UEContextSetupRequest;
9901    for(ieIdx=0; (ieIdx < ueSetReq->protocolIEs.list.count && ret == ROK); ieIdx++)
9902    {
9903       switch(ueSetReq->protocolIEs.list.array[ieIdx]->id)
9904       {
9905          case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
9906             {
9907                gnbCuUeF1apId = ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID;
9908                break;
9909             }
9910          case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
9911             {
9912                gnbDuUeF1apId = ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID;
9913                break;
9914             }
9915          case ProtocolIE_ID_id_ServCellIndex:
9916             {
9917                cellIdx = ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.ServCellIndex;
9918                for(ueIdx = 0; ueIdx < MAX_NUM_UE; ueIdx++)
9919                {
9920                   if((duCb.actvCellLst[cellIdx]->ueCb[ueIdx].gnbDuUeF1apId == gnbDuUeF1apId)&&\
9921                         (duCb.actvCellLst[cellIdx]->ueCb[ueIdx].gnbCuUeF1apId == gnbCuUeF1apId))
9922                   {
9923                      ueCbFound = true;
9924                      duUeCb = &duCb.actvCellLst[cellIdx]->ueCb[ueIdx];
9925                      DU_ALLOC(duUeCb->f1UeDb, sizeof(F1UeContextSetupDb));
9926                      if(duUeCb->f1UeDb)
9927                      {
9928                         memset(duUeCb->f1UeDb, 0, sizeof(F1UeContextSetupDb));
9929                         duUeCb->f1UeDb->actionType = UE_CTXT_SETUP;
9930                         duUeCb->f1UeDb->cellIdx = cellIdx;
9931                      }
9932                      else
9933                      {
9934                         DU_LOG("\nERROR  -->  F1AP: Memory Alloc Failed at procF1UeContextSetupReq()");
9935                         ret = RFAILED;
9936                      }
9937                   }
9938                   else
9939                      ueCbFound = false;
9940
9941                }
9942                if(!ueCbFound)
9943                {
9944                   DU_LOG("\nERROR  -->  F1AP: DuUeCb is not found at procF1UeContextSetupReq()");
9945                   ret = RFAILED;
9946                }
9947                break;
9948             }
9949          case ProtocolIE_ID_id_SpCellULConfigured:
9950             /* Indicates whether the gNB-CU requests the gNB-DU to configure the uplink as no UL,
9951                UL, SUL or UL+SUL for the indicated cell for the UE */
9952             break;
9953          case ProtocolIE_ID_id_CUtoDURRCInformation:
9954             {
9955                if(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.CUtoDURRCInformation.uE_CapabilityRAT_ContainerList)
9956                {
9957                   duUeCb->f1UeDb->duUeCfg.ueNrCapability = \
9958                   extractUeCapability(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.CUtoDURRCInformation.\
9959                   uE_CapabilityRAT_ContainerList, duUeCb);
9960                }
9961                if(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.CUtoDURRCInformation.iE_Extensions)
9962                {
9963                   duUeCb->f1UeDb->duUeCfg.cellGrpCfg = extractCellGrpInfo(ueSetReq->protocolIEs.list.array[ieIdx]->\
9964                         value.choice.CUtoDURRCInformation.iE_Extensions, &duUeCb->f1UeDb->duUeCfg);
9965                   if(!duUeCb->f1UeDb->duUeCfg.cellGrpCfg)
9966                   {
9967                      DU_LOG("\nERROR  -->  F1AP: Failed to extract cell Grp Info");
9968                      //TODO: Update the failure cause in ue context Setup Response
9969                      ret = RFAILED;
9970                   }
9971                }
9972                break;
9973             }
9974          case ProtocolIE_ID_id_SCell_ToBeSetup_List:
9975             {
9976                DU_LOG("\nINFO   -->  DU_APP: Received SCell_ToBeSetup_List but  Not processing the list");
9977                break;
9978             }
9979          case ProtocolIE_ID_id_SRBs_ToBeSetup_List:
9980             {
9981                if(extractSrbListToSetup(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.SRBs_ToBeSetup_List,\
9982                &duUeCb->f1UeDb->duUeCfg))
9983                {
9984                   DU_LOG("\nERROR  -->  DU APP : Failed at extractSrbListToSetup()");
9985                   //TODO: Update the failure cause in ue context Setup Response
9986                   ret = RFAILED;
9987                }
9988                break;
9989             }
9990          case ProtocolIE_ID_id_DRBs_ToBeSetup_List:
9991             {
9992                lcId = getDrbLcId(&duUeCb->drbBitMap);
9993                if(lcId != RFAILED)
9994                {
9995                   drbCfg = &ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.DRBs_ToBeSetup_List;
9996                   if(extractDrbListToSetup(lcId, drbCfg, NULL, drbCfg->list.count, &duUeCb->f1UeDb->duUeCfg))
9997                   {
9998                      DU_LOG("\nERROR  -->  DU APP : Failed at extractDrbListToSetup()");
9999                      //TODO: Update the failure cause in ue context Setup Response
10000                      ret = RFAILED;
10001                   }
10002                }
10003                else
10004                   ret = RFAILED;
10005                break;
10006             }
10007          case ProtocolIE_ID_id_RRCContainer:
10008             {
10009                /* Filling Dl RRC Msg Info */
10010                DU_ALLOC_SHRABL_BUF(duUeCb->f1UeDb->dlRrcMsg, sizeof(F1DlRrcMsg));
10011                if(!duUeCb->f1UeDb->dlRrcMsg)
10012                {
10013                   DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for DL RRC Msg in procUeCtxtSetupReq()");
10014                   ret = RFAILED;
10015                }
10016                else
10017                {
10018                   duUeCb->f1UeDb->dlRrcMsgPres = true;
10019                   memset(duUeCb->f1UeDb->dlRrcMsg, 0, sizeof(F1DlRrcMsg));
10020                   ret = extractDlRrcMsg(gnbDuUeF1apId, gnbCuUeF1apId, duUeCb->f1UeDb->dlRrcMsg,\
10021                         &ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer);
10022                }
10023                break;
10024             }
10025          case ProtocolIE_ID_id_RRCDeliveryStatusRequest:
10026             {
10027                if(duUeCb->f1UeDb->dlRrcMsg->rrcMsgPdu)
10028                {
10029                   duUeCb->f1UeDb->dlRrcMsg->deliveryStatRpt = true;
10030                }
10031                else
10032                {
10033                   DU_LOG("\nERROR  -->  Ignoring delivery report, since rrcContainer is not present");
10034                }
10035                break;
10036             }
10037          case ProtocolIE_ID_id_GNB_DU_UE_AMBR_UL:
10038             {
10039                /* MaximumBitRate Uplink */
10040                bitRateSize = ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.BitRate.size;
10041                if(bitRateSize > 0)
10042                {
10043                   DU_ALLOC_SHRABL_BUF(duUeCb->f1UeDb->duUeCfg.ambrCfg, bitRateSize);
10044                   if(!duUeCb->f1UeDb->duUeCfg.ambrCfg)
10045                   {
10046                      DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for bitRate in procUeCtxtSetupReq");
10047                      ret = RFAILED;
10048                   }
10049                   else
10050                   {
10051                      memset(duUeCb->f1UeDb->duUeCfg.ambrCfg, 0, sizeof(AmbrCfg));
10052                      memcpy(&duUeCb->f1UeDb->duUeCfg.ambrCfg->ulBr,
10053                            ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.BitRate.buf, bitRateSize);
10054                   }
10055                }
10056                else
10057                   ret = RFAILED;
10058                break;
10059             }
10060          default:
10061             {
10062                break;
10063             }
10064       }
10065    }
10066    if(ret == RFAILED)
10067    {
10068       /*TODO : Negative case*/
10069       // BuildAndSendUeContextSetupRsp(ueIdx, cellId);
10070       DU_LOG("\nERROR  -->  F1AP: Failed to process UE CNTXT SETUP REQ at procF1UeContextSetupReq()");
10071    }
10072    else
10073       ret = duProcUeContextSetupRequest(duUeCb);
10074
10075    freeAperDecodeF1UeContextSetupReq(ueSetReq);
10076    return ret;
10077
10078 }
10079 /*******************************************************************
10080  * @brief Free the memory allocated for Dl Tunnel Info
10081  *
10082  * @details
10083  *
10084  *    Function : freeDlTnlInfo
10085  *
10086  *    Functionality:
10087  *       Free the memory allocated for Dl Tunnel Info
10088  *
10089  * @params[in] DLUPTNLInformation_ToBeSetup_List_t *
10090  * @return void
10091  *
10092  * ****************************************************************/
10093
10094 void freeDlTnlInfo(DLUPTNLInformation_ToBeSetup_List_t *tnlInfo)
10095 {
10096    uint8_t arrIdx = 0;
10097
10098    for(arrIdx=0; arrIdx < tnlInfo->list.count; arrIdx++)
10099    {
10100       DU_FREE(tnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel, sizeof(GTPTunnel_t));
10101    }
10102 }
10103
10104 /*******************************************************************
10105  * @brief Free the memory allocated for DRB setup List
10106  *
10107  * @details
10108  *
10109  *    Function : freeDrbSetupList
10110  *
10111  *    Functionality:
10112  *       Free the memory allocated for DRB setup list
10113  *
10114  * @params[in] DRBs_Setup_List_t *
10115  * @return void
10116  *
10117  * ****************************************************************/
10118 void freeDrbSetupList(DRBs_Setup_List_t *drbSetupList)
10119 {
10120    uint8_t arrIdx = 0;
10121    DRBs_Setup_ItemIEs_t *drbItemIe = NULLP;
10122
10123    for(arrIdx = 0; arrIdx < drbSetupList->list.count; arrIdx++)
10124    {
10125       drbItemIe = ((DRBs_Setup_ItemIEs_t *)drbSetupList->list.array[arrIdx]);
10126       freeDlTnlInfo(&drbItemIe->value.choice.DRBs_Setup_Item.dLUPTNLInformation_ToBeSetup_List);
10127    }
10128 }
10129
10130 /*******************************************************************
10131  * @brief Free the memory allocated for UE Setup response
10132  *
10133  * @details
10134  *
10135  *    Function : FreeUeContextSetupRsp
10136  *
10137  *    Functionality:
10138  *       Free the memory allocated for UE Setup response
10139  *
10140  * @params[in] F1AP PDU for UE setup response
10141  * @return ROK     - success
10142  *         RFAILED - failure
10143  *
10144  * ****************************************************************/
10145 void FreeUeContextSetupRsp(F1AP_PDU_t *f1apMsg)
10146 {
10147    uint8_t idx;
10148    UEContextSetupResponse_t *ueSetRsp = NULLP;
10149
10150    if(f1apMsg)
10151    {
10152       if(f1apMsg->choice.successfulOutcome)
10153       {
10154          ueSetRsp = &f1apMsg->choice.successfulOutcome->value.choice.\
10155                     UEContextSetupResponse;
10156          if(ueSetRsp->protocolIEs.list.array)
10157          {
10158             for(idx = 0; idx < ueSetRsp->protocolIEs.list.count; idx++)
10159             {
10160                if(ueSetRsp->protocolIEs.list.array[idx])
10161                {
10162                   switch(ueSetRsp->protocolIEs.list.array[idx]->id)
10163                   {
10164                      case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
10165                         break;
10166                      case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
10167                         break;
10168                      case ProtocolIE_ID_id_DUtoCURRCInformation:
10169                         {
10170                            CellGroupConfig_t *cellGrpCfg = NULLP;
10171                            cellGrpCfg  = &ueSetRsp->protocolIEs.list.array[idx]->value.choice.\
10172                                          DUtoCURRCInformation.cellGroupConfig;
10173                            if(cellGrpCfg->buf != NULLP)
10174                            {
10175                               DU_FREE(cellGrpCfg->buf, cellGrpCfg->size);
10176                               cellGrpCfg = NULLP;
10177                            }
10178                            break;
10179                         }
10180                     case ProtocolIE_ID_id_DRBs_Setup_List:
10181                         {
10182                            freeDrbSetupList(&ueSetRsp->protocolIEs.list.array[idx]->value.choice.DRBs_Setup_List);
10183                            break;
10184                         }
10185                      default:
10186                         DU_LOG("\nERROR  -->  DUAPP: Invalid Id %ld at FreeUeContextSetupRsp()",\
10187                         ueSetRsp->protocolIEs.list.array[idx]->id);
10188                         break;
10189                   }
10190                   DU_FREE(ueSetRsp->protocolIEs.list.array[idx],\
10191                         sizeof(UEContextSetupResponseIEs_t));
10192                }
10193             }
10194             DU_FREE(ueSetRsp->protocolIEs.list.array, \
10195                   ueSetRsp->protocolIEs.list.size);
10196          }
10197          DU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
10198       }
10199       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
10200    }
10201 }
10202
10203 /*******************************************************************
10204  *
10205  * @brief Builds Ue context Setup Rsp DU To CU Info
10206  *
10207  * @details
10208  *
10209  *    Function : EncodeUeCntxtDuToCuInfo
10210  *
10211  *    Functionality: Builds Ue context Setup Rsp DU To CU Info
10212  *
10213  * @params[in] CellGroupConfig_t *, CellGroupConfigRrc_t *
10214  *
10215  * @return ROK     - success
10216  *         RFAILED - failure
10217  *
10218  ******************************************************************/
10219
10220 uint8_t EncodeUeCntxtDuToCuInfo(CellGroupConfig_t *duToCuCellGrp, CellGroupConfigRrc_t *duCellGrpCfg)
10221 {
10222    asn_enc_rval_t        encRetVal;
10223
10224    xer_fprint(stdout, &asn_DEF_CellGroupConfigRrc, duCellGrpCfg);
10225    memset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
10226    encBufSize = 0;
10227    encRetVal = aper_encode(&asn_DEF_CellGroupConfigRrc, 0, duCellGrpCfg, PrepFinalEncBuf, encBuf);
10228    /* Encode results */
10229    if(encRetVal.encoded == ENCODE_FAIL)
10230    {
10231       DU_LOG( "\nERROR  -->  F1AP : Could not encode UeCntxtDuToCuInfo (at %s)\n",\
10232             encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
10233       return RFAILED;
10234    }
10235    else
10236    {
10237       DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for UeCntxtDuToCuInfo\n");
10238       for(int i=0; i< encBufSize; i++)
10239       {
10240          printf("%x",encBuf[i]);
10241       }
10242    }
10243    duToCuCellGrp->size = encBufSize;
10244    DU_ALLOC(duToCuCellGrp->buf, duToCuCellGrp->size);
10245    if(!duToCuCellGrp->buf)
10246    {
10247       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in UeCntxtDuToCuInfo");
10248    }
10249    memcpy(duToCuCellGrp->buf, encBuf, duToCuCellGrp->size);
10250    return ROK;
10251 }
10252
10253 /*******************************************************************
10254  *
10255  * @brief Fills Dl Gtp tunnel Info
10256  *
10257  * @details
10258  *
10259  *    Function : fillGtpTunnelforDl
10260  *
10261  *    Functionality: Fills Dl Gtp tunnel Info
10262  *
10263  * @params[in]
10264  *
10265  * @return ROK     - success
10266  *         RFAILED - failure
10267  *
10268  * ****************************************************************/
10269
10270 uint8_t fillGtpTunnelforDl(GTPTunnel_t *gtpDl, GtpTnlCfg *gtpUeCfg)
10271 {
10272    uint8_t bufSize = 0;
10273
10274    gtpDl->transportLayerAddress.size    = 4*sizeof(uint8_t);
10275    DU_ALLOC(gtpDl->transportLayerAddress.buf, gtpDl->transportLayerAddress.size);
10276    if(gtpDl->transportLayerAddress.buf == NULLP)
10277    {
10278       return RFAILED;
10279    }
10280    memcpy(gtpDl->transportLayerAddress.buf, &gtpUeCfg->dlTnlAddress, gtpDl->transportLayerAddress.size);
10281
10282    /*GTP TEID*/
10283    gtpDl->gTP_TEID.size = 4 * sizeof(uint8_t);
10284    DU_ALLOC(gtpDl->gTP_TEID.buf, gtpDl->gTP_TEID.size);
10285    if(gtpDl->gTP_TEID.buf == NULLP)
10286    {
10287       return RFAILED;
10288    }
10289    bufSize = 3; /*forming an Octect String*/
10290    fillTeIdString(bufSize, gtpUeCfg->teId, gtpDl->gTP_TEID.buf);
10291
10292    return ROK;
10293 }
10294
10295 /*******************************************************************
10296  *
10297  * @brief Fills DL Tunnel Setup List
10298  *
10299  * @details
10300  *
10301  *    Function : fillDlTnlSetupList
10302  *
10303  *    Functionality: Fills the DL Tunnel Setup List
10304  *
10305  * @params[in]
10306  *
10307  * @return ROK     - success
10308  *         RFAILED - failure
10309  *
10310  * ****************************************************************/
10311
10312 uint8_t fillDlTnlSetupList(DLUPTNLInformation_ToBeSetup_List_t *dlTnlInfo, UpTnlCfg *tnlCfg)
10313 {
10314    uint8_t ret = ROK, arrIdx = 0, eleCount = 0;
10315
10316    eleCount = 1;
10317    dlTnlInfo->list.count = eleCount;
10318    dlTnlInfo->list.size = (eleCount * sizeof(DLUPTNLInformation_ToBeSetup_Item_t *));
10319
10320    /* Initialize the DL Tnl Setup List Members */
10321    DU_ALLOC(dlTnlInfo->list.array, dlTnlInfo->list.size);
10322    if(dlTnlInfo->list.array == NULLP)
10323    {
10324       DU_LOG(" ERROR  -->  F1AP : Memory allocation for DL Tnl Setup List in fillDlTnlSetupList()");
10325       ret = RFAILED;
10326    }
10327    for(arrIdx=0; arrIdx < eleCount; arrIdx++)
10328    {
10329       DU_ALLOC(dlTnlInfo->list.array[arrIdx], sizeof(DLUPTNLInformation_ToBeSetup_Item_t));
10330       if(dlTnlInfo->list.array[arrIdx] == NULLP)
10331       {
10332          DU_LOG(" ERROR  -->  F1AP : Memory allocation for arrIdx [%d] failed in fillDlTnlSetupList()", arrIdx);
10333          return RFAILED;
10334       }
10335       dlTnlInfo->list.array[arrIdx]->dLUPTNLInformation.present = UPTransportLayerInformation_PR_gTPTunnel;
10336       DU_ALLOC(dlTnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel, sizeof(GTPTunnel_t));
10337       if(dlTnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel == NULLP)
10338       {
10339          DU_LOG(" ERROR  -->  F1AP : Memory allocation for DL tunnel info in fillDlTnlSetupList()");
10340          return RFAILED;
10341       }
10342       ret = fillGtpTunnelforDl(dlTnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel,\
10343                tnlCfg->tnlCfg1);
10344       if(ret != ROK)
10345          break;
10346    }
10347    return ret;
10348 }
10349
10350 /*******************************************************************
10351  *
10352  * @brief Fills the Drb Setup List for Ue Context Setup Response
10353  *
10354  * @details
10355  *
10356  *    Function : fillDrbSetupList
10357  *
10358  *    Functionality: Fills the Drb Setup List for Ue Context Setup Response
10359  *
10360  * @params[in]
10361  *
10362  * @return ROK     - success
10363  *         RFAILED - failure
10364  *
10365  * ****************************************************************/
10366 uint8_t fillDrbSetupList(DRBs_Setup_List_t *drbSetupList, DuUeCfg *ueCfg)
10367 {
10368    uint8_t ret = ROK, arrIdx = 0, eleCount = 0;
10369    DRBs_Setup_ItemIEs_t *drbItemIe = NULLP;
10370
10371    eleCount = ueCfg->numDrb;
10372    drbSetupList->list.count = eleCount;
10373    drbSetupList->list.size = \
10374         (eleCount * sizeof(DRBs_Setup_Item_t *));
10375
10376    /* Initialize the Drb Setup List Members */
10377    DU_ALLOC(drbSetupList->list.array, drbSetupList->list.size);
10378    if(drbSetupList->list.array == NULLP)
10379    {
10380       DU_LOG(" ERROR  -->  F1AP : Memory allocation for DRB Setup List in fillDrbSetupList()");
10381       ret = RFAILED;
10382    }
10383
10384    for(arrIdx=0; arrIdx < eleCount; arrIdx++)
10385    {
10386       DU_ALLOC(drbSetupList->list.array[arrIdx], sizeof(DRBs_Setup_Item_t));
10387       if(drbSetupList->list.array[arrIdx] == NULLP)
10388       {
10389          DU_LOG(" ERROR  -->  F1AP : Memory allocation for arrIdx [%d] failed in fillDrbSetupList()", arrIdx);
10390          return RFAILED;
10391       }
10392       drbItemIe = ((DRBs_Setup_ItemIEs_t *)drbSetupList->list.array[arrIdx]);
10393       drbItemIe->id = ProtocolIE_ID_id_DRBs_Setup_Item;
10394       drbItemIe->criticality = Criticality_reject;
10395       drbItemIe->value.present = DRBs_Setup_ItemIEs__value_PR_DRBs_Setup_Item;
10396       drbItemIe->value.choice.DRBs_Setup_Item.dRBID = ueCfg->upTnlInfo[arrIdx].drbId;
10397       ret = fillDlTnlSetupList(&drbItemIe->value.choice.DRBs_Setup_Item.dLUPTNLInformation_ToBeSetup_List,\
10398           &ueCfg->upTnlInfo[arrIdx]);
10399       if(ret != ROK)
10400          break;
10401    }
10402    return ret;
10403 }
10404
10405 /*******************************************************************
10406  *
10407  * @brief Builds and sends the UE Setup Response
10408  *
10409  * @details
10410  *
10411  *    Function : BuildAndSendUeContextSetupRsp
10412  *
10413  *    Functionality: Constructs the UE Setup Response and sends
10414  *                   it to the DU through SCTP.
10415  *
10416  * @params[in]
10417  *
10418  * @return ROK     - success
10419  *         RFAILED - failure
10420  *
10421  * ****************************************************************/
10422 uint8_t BuildAndSendUeContextSetupRsp(uint8_t ueIdx, uint8_t cellId)
10423 {
10424    uint8_t   idx, ret, cellIdx, elementCnt;
10425    uint32_t  gnbCuUeF1apId;   /* gNB-CU UE F1AP Id */
10426    uint32_t  gnbDuUeF1apId;   /* gNB-DU UE F1AP Id */
10427    asn_enc_rval_t  encRetVal;        /* Encoder return value */
10428    F1AP_PDU_t               *f1apMsg = NULLP;
10429    UEContextSetupResponse_t *ueSetRsp = NULLP;
10430    CellGroupConfigRrc_t     *cellGrpCfg = NULLP;
10431    DuUeCb                   *ueCb = NULLP;
10432
10433    DU_LOG("\n INFO   -->  F1AP : Building UE Context Setup Response for cellId %d, ueIdx %d\n", cellId, ueIdx);
10434
10435    while(true)
10436    {
10437       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
10438       if(f1apMsg == NULLP)
10439       {
10440          DU_LOG(" ERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
10441          ret = RFAILED;
10442          break;
10443       }
10444
10445       f1apMsg->present = F1AP_PDU_PR_successfulOutcome;
10446       DU_ALLOC(f1apMsg->choice.successfulOutcome,
10447             sizeof(SuccessfulOutcome_t));
10448       if(f1apMsg->choice.successfulOutcome == NULLP)
10449       {
10450          DU_LOG(" ERROR  -->  F1AP : Memory allocation for      F1AP-PDU failed");
10451          ret = RFAILED;
10452          break;
10453       }
10454
10455       f1apMsg->choice.successfulOutcome->procedureCode = \
10456                                                          ProcedureCode_id_UEContextSetup;
10457       f1apMsg->choice.successfulOutcome->criticality = Criticality_reject;
10458       f1apMsg->choice.successfulOutcome->value.present = \
10459                                                          SuccessfulOutcome__value_PR_UEContextSetupResponse;
10460
10461       ueSetRsp =
10462          &f1apMsg->choice.successfulOutcome->value.choice.UEContextSetupResponse;
10463       elementCnt = 4;
10464       ueSetRsp->protocolIEs.list.count = elementCnt;
10465       ueSetRsp->protocolIEs.list.size = \
10466                                         elementCnt * sizeof(UEContextSetupResponse_t *);
10467
10468       /* Initialize the UESetup members */
10469       DU_ALLOC(ueSetRsp->protocolIEs.list.array, \
10470             ueSetRsp->protocolIEs.list.size);
10471       if(ueSetRsp->protocolIEs.list.array == NULLP)
10472       {
10473          DU_LOG(" ERROR  -->  F1AP : Memory allocation for UE Setup Response failed");
10474          ret = RFAILED;
10475          break;
10476       }
10477
10478       for(idx=0; idx<elementCnt; idx++)
10479       {
10480          DU_ALLOC(ueSetRsp->protocolIEs.list.array[idx],\
10481                sizeof(UEContextSetupResponseIEs_t));
10482          if(ueSetRsp->protocolIEs.list.array[idx] == NULLP)
10483          {
10484             DU_LOG(" ERROR  -->  F1AP : Memory allocation for UE Setup Response failed");
10485             ret = RFAILED;
10486             break;
10487          }
10488       }
10489       /* Fetching Ue Cb Info*/
10490       GET_CELL_IDX(cellId, cellIdx);
10491       gnbDuUeF1apId = duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].gnbDuUeF1apId;
10492       gnbCuUeF1apId = duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].gnbCuUeF1apId;
10493       ueCb = &duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1];
10494
10495       idx = 0;
10496       /*GNB CU UE F1AP ID*/
10497       ueSetRsp->protocolIEs.list.array[idx]->id = \
10498                                                   ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
10499       ueSetRsp->protocolIEs.list.array[idx]->criticality = Criticality_reject;
10500       ueSetRsp->protocolIEs.list.array[idx]->value.present = \
10501                                                              UEContextSetupResponseIEs__value_PR_GNB_CU_UE_F1AP_ID;
10502       ueSetRsp->protocolIEs.list.array[idx]->value.choice.GNB_CU_UE_F1AP_ID = gnbCuUeF1apId;
10503
10504       /*GNB DU UE F1AP ID*/
10505       idx++;
10506       ueSetRsp->protocolIEs.list.array[idx]->id = \
10507                                                   ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
10508       ueSetRsp->protocolIEs.list.array[idx]->criticality = Criticality_reject;
10509       ueSetRsp->protocolIEs.list.array[idx]->value.present = \
10510                                                              UEContextSetupResponseIEs__value_PR_GNB_DU_UE_F1AP_ID;
10511       ueSetRsp->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID = gnbDuUeF1apId;
10512
10513
10514       /*DUtoCURRC Information */
10515       idx++;
10516       ueSetRsp->protocolIEs.list.array[idx]->id  = \
10517                                                    ProtocolIE_ID_id_DUtoCURRCInformation;
10518       ueSetRsp->protocolIEs.list.array[idx]->criticality = Criticality_reject;
10519       ueSetRsp->protocolIEs.list.array[idx]->value.present =\
10520                                                             UEContextSetupResponseIEs__value_PR_DUtoCURRCInformation;
10521       if(ueCb->f1UeDb)
10522       {
10523          if(ueCb->f1UeDb->duUeCfg.cellGrpCfg)
10524          {
10525             cellGrpCfg = (CellGroupConfigRrc_t*)ueCb->f1UeDb->duUeCfg.cellGrpCfg;
10526             ret = EncodeUeCntxtDuToCuInfo(&ueSetRsp->protocolIEs.list.array[idx]->value.\
10527                      choice.DUtoCURRCInformation.cellGroupConfig, cellGrpCfg);
10528             if(ret == RFAILED)
10529             {
10530                DU_LOG("\nERROR  -->  F1AP : Failed to EncodeUeCntxtDuToCuInfo in BuildAndSendUeContextSetupRsp()");
10531                freeF1UeDb(ueCb->f1UeDb);
10532                ueCb->f1UeDb = NULLP;
10533                break;
10534             }
10535          }
10536       }
10537       else
10538       {
10539          DU_LOG("\nERROR  -->  F1AP : Failed to form DUtoCU RRCInfo at BuildAndSendUeContextSetupRsp()");
10540          ret = RFAILED;
10541          break;
10542       }
10543
10544       /* Drb Setup List */
10545       idx++;
10546       ueSetRsp->protocolIEs.list.array[idx]->id  = \
10547                                  ProtocolIE_ID_id_DRBs_Setup_List;
10548       ueSetRsp->protocolIEs.list.array[idx]->criticality = Criticality_reject;
10549       ueSetRsp->protocolIEs.list.array[idx]->value.present =\
10550                                  UEContextSetupResponseIEs__value_PR_DRBs_Setup_List;
10551       ret = fillDrbSetupList(&ueSetRsp->protocolIEs.list.array[idx]->value.choice.DRBs_Setup_List,\
10552                &ueCb->f1UeDb->duUeCfg);
10553       if(ret == RFAILED)
10554       {
10555          DU_LOG("\nERROR  -->  F1AP : Failed to fillDrbSetupList in BuildAndSendUeContextSetupRsp()");
10556          freeF1UeDb(ueCb->f1UeDb);
10557          ueCb->f1UeDb = NULLP;
10558          break;
10559       }
10560
10561        /* Free UeContext Db created during Ue context Req */
10562        freeF1UeDb(ueCb->f1UeDb);
10563        ueCb->f1UeDb = NULLP;
10564
10565       /* TODO: To send Drb list */
10566       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
10567
10568       /* Encode the UE context setup response type as APER */
10569       memset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
10570       encBufSize = 0;
10571       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
10572             encBuf);
10573       /* Encode results */
10574       if(encRetVal.encoded == ENCODE_FAIL)
10575       {
10576          DU_LOG( "\nERROR  -->  F1AP : Could not encode UE Context Setup Response structure (at %s)\n",\
10577                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
10578          ret = RFAILED;
10579          break;
10580       }
10581       else
10582       {
10583          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for UE Context Setup Response\n");
10584          for(int i=0; i< encBufSize; i++)
10585          {
10586             printf("%x",encBuf[i]);
10587          }
10588       }
10589
10590       /* Sending  msg  */
10591       if(sendF1APMsg()  != ROK)
10592       {
10593          DU_LOG("\nERROR  -->  F1AP : Sending UE Context Setup Response failed");
10594          ret = RFAILED;
10595          break;
10596       }
10597       break;
10598    }
10599    FreeUeContextSetupRsp(f1apMsg);
10600    return ret;
10601 }/* End of BuildAndSendUeContextSetupRsp */
10602 /*******************************************************************
10603 *
10604 * @brief  Build And Send Ue Context Rsp
10605 *
10606 * @details
10607 *
10608 *    Function : BuildAndSendUeCtxtRsp
10609 *
10610 *    Functionality : Build And Send Ue Context Rsp
10611
10612 * @params[in]
10613 * @return sucess = ROK
10614 *         failure = RFAILED
10615 *
10616 * ****************************************************************/
10617 uint8_t BuildAndSendUeCtxtRsp(uint8_t ueIdx, uint8_t cellId)
10618 {
10619    uint8_t cellIdx = 0, actionType = 0;
10620
10621    GET_CELL_IDX(cellId, cellIdx);
10622    actionType = duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].f1UeDb->actionType;
10623
10624    switch(actionType)
10625    {
10626       case UE_CTXT_SETUP:
10627          BuildAndSendUeContextSetupRsp(ueIdx, cellId);
10628          break;
10629       case UE_CTXT_MOD:
10630          BuildAndSendUeContextModResp(ueIdx, cellId);
10631          break;
10632       default:
10633          DU_LOG("ERROR  -->  F1AP: Invalid Action Type %d at BuildAndSendUeCtxtRsp()", actionType);
10634          break;
10635
10636    }
10637    return ROK;
10638 }
10639
10640 /*******************************************************************
10641  *
10642  * @brief deallocating the memory of  F1reset msg
10643  *
10644  * @details
10645  *
10646  *    Function : FreeF1ResetReq
10647  *
10648  *    Functionality :
10649  *         - freeing memory of F1reset request msg
10650  *
10651  * @params[in]
10652  * @return void
10653  *
10654  *
10655  * ****************************************************************/
10656 void FreeF1ResetReq(F1AP_PDU_t *f1apMsg)
10657 {
10658    uint8_t idx =0 ;
10659    Reset_t *f1ResetMsg;
10660
10661    if(f1apMsg)
10662    {
10663       if(f1apMsg->choice.initiatingMessage)
10664       {
10665          f1ResetMsg = &f1apMsg->choice.initiatingMessage->value.choice.Reset;
10666
10667          if(f1ResetMsg->protocolIEs.list.array)
10668          {
10669             for(idx=0 ;idx < f1ResetMsg->protocolIEs.list.count ; idx++)
10670             {
10671                if(f1ResetMsg->protocolIEs.list.array[idx])
10672                {
10673                   DU_FREE(f1ResetMsg->protocolIEs.list.array[idx],sizeof(ResetIEs_t));
10674                }
10675             }
10676             DU_FREE(f1ResetMsg->protocolIEs.list.array,f1ResetMsg->protocolIEs.list.size);
10677          }
10678          DU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
10679       }
10680       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
10681    }
10682 }
10683 /*******************************************************************
10684  *
10685  * @brief Build and Send F1reset request
10686  *
10687  * @details
10688  *
10689  *    Function : BuildAndSendF1ResetReq
10690  *
10691  *    Functionality:
10692  *         - Build and Send F1reset request msg
10693  *
10694  * @params[in]
10695  * @return ROK     - success
10696  *         RFAILED - failure
10697  *
10698  * ****************************************************************/
10699 uint8_t BuildAndSendF1ResetReq()
10700 {
10701    uint8_t          elementCnt=0;
10702    uint8_t          idx=0;
10703    uint8_t          ret= RFAILED;
10704    Reset_t          *f1ResetMsg = NULLP;
10705    F1AP_PDU_t       *f1apMsg = NULLP;
10706    asn_enc_rval_t   encRetVal;
10707    DU_LOG("\nINFO   -->  F1AP : Building F1 Reset request \n");
10708    do
10709    {
10710       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
10711       if(f1apMsg == NULLP)
10712       {
10713          break;
10714       }
10715       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
10716       DU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
10717       if(f1apMsg->choice.initiatingMessage == NULLP)
10718       {
10719          break;
10720       }
10721       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_Reset;
10722       f1apMsg->choice.initiatingMessage->criticality = Criticality_reject;
10723       f1apMsg->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_Reset;
10724
10725       f1ResetMsg = &f1apMsg->choice.initiatingMessage->value.choice.Reset;
10726
10727       elementCnt = 3;
10728       f1ResetMsg->protocolIEs.list.count = elementCnt;
10729       f1ResetMsg->protocolIEs.list.size = elementCnt * sizeof(ResetIEs_t *);
10730
10731       /* Initialize the F1Setup members */
10732       DU_ALLOC(f1ResetMsg->protocolIEs.list.array,f1ResetMsg->protocolIEs.list.size);
10733       if(f1ResetMsg->protocolIEs.list.array == NULLP)
10734       {
10735          break;
10736       }
10737       for(idx=0; idx<elementCnt; idx++)
10738       {
10739          DU_ALLOC(f1ResetMsg->protocolIEs.list.array[idx],sizeof(ResetIEs_t));
10740          if(f1ResetMsg->protocolIEs.list.array[idx] == NULLP)
10741          {
10742             break;
10743          }
10744       }
10745
10746       /*TransactionID*/
10747       idx=0;
10748       f1ResetMsg->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_TransactionID;
10749       f1ResetMsg->protocolIEs.list.array[idx]->criticality = Criticality_reject;
10750       f1ResetMsg->protocolIEs.list.array[idx]->value.present = ResetIEs__value_PR_TransactionID;
10751       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.TransactionID = 1;
10752
10753       /*Cause*/
10754       idx++;
10755       f1ResetMsg->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_Cause;
10756       f1ResetMsg->protocolIEs.list.array[idx]->criticality = Criticality_ignore;
10757       f1ResetMsg->protocolIEs.list.array[idx]->value.present = ResetIEs__value_PR_Cause;
10758       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.Cause.present = Cause_PR_radioNetwork;
10759       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.Cause.choice.radioNetwork = CauseRadioNetwork_action_desirable_for_radio_reasons;
10760
10761       /*Reset Type*/
10762       idx++;
10763       f1ResetMsg->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_ResetType;
10764       f1ResetMsg->protocolIEs.list.array[idx]->criticality = Criticality_reject;
10765       f1ResetMsg->protocolIEs.list.array[idx]->value.present = ResetIEs__value_PR_ResetType;
10766       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.ResetType.present = ResetType_PR_f1_Interface;
10767       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.ResetType.choice.f1_Interface = ResetAll_reset_all;
10768
10769       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
10770
10771       /* Encode the F1SetupRequest type as APER */
10772       memset(encBuf, 0, ENC_BUF_MAX_LEN);
10773       encBufSize = 0;
10774       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
10775             encBuf);
10776
10777       /* Encode results */
10778       if(encRetVal.encoded == ENCODE_FAIL)
10779       {
10780          DU_LOG("\nERROR  -->  F1AP : Could not encode F1Reset structure (at %s)\n",\
10781                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
10782          break;
10783       }
10784       else
10785       {
10786          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for F1Reset\n");
10787          for(idx=0; idx< encBufSize; idx++)
10788          {
10789             printf("%x",encBuf[idx]);
10790          }
10791       }
10792
10793       if(sendF1APMsg() != ROK)
10794       {
10795          DU_LOG("\nERROR  -->  F1AP : Sending F1 Reset request failed");
10796          break;
10797       }
10798
10799       ret = ROK;
10800       break;
10801    }while(true);
10802
10803    FreeF1ResetReq(f1apMsg);
10804    return ret;
10805 }
10806 /*******************************************************************
10807  *
10808  * @brief Build And Send F1ResetAck
10809  *
10810  * @details
10811  *
10812  *    Function : BuildAndSendF1ResetAck
10813  *
10814  *    Functionality:
10815  *         - Build And Send  F1ResetRSP
10816  *
10817  * @return ROK     - success
10818  *         RFAILED - failure
10819  *
10820  * ****************************************************************/
10821 void FreeF1ResetAck(F1AP_PDU_t *f1apMsg)
10822 {
10823    uint8_t idx;
10824    ResetAcknowledge_t *f1ResetAck;
10825
10826    if(f1apMsg)
10827    {
10828       if(f1apMsg->choice.successfulOutcome)
10829       {
10830          f1ResetAck= &f1apMsg->choice.successfulOutcome->value.choice.ResetAcknowledge;
10831
10832          if(f1ResetAck->protocolIEs.list.array)
10833          {
10834             for(idx=0; idx<f1ResetAck->protocolIEs.list.count ; idx++)
10835             {
10836                if(f1ResetAck->protocolIEs.list.array[idx])
10837                {
10838                   DU_FREE(f1ResetAck->protocolIEs.list.array[idx], sizeof(ResetAcknowledgeIEs_t));
10839                }
10840             }
10841             DU_FREE(f1ResetAck->protocolIEs.list.array, f1ResetAck->protocolIEs.list.size );
10842          }
10843          DU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
10844       }
10845       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
10846    }
10847 }
10848
10849 /*******************************************************************
10850  *
10851  * @brief Build And Send F1ResetAck
10852  *
10853  * @details
10854  *
10855  *    Function : BuildAndSendF1ResetAck
10856  *
10857  *    Functionality:
10858  *         - Build And Send  F1ResetRSP
10859  *
10860  *  @params[in]
10861  * @return ROK     - success
10862  *         RFAILED - failure
10863  *
10864  * ****************************************************************/
10865 uint8_t BuildAndSendF1ResetAck()
10866 {
10867    uint8_t                idx = 0;
10868    uint8_t                elementCnt = 0;
10869    uint8_t                ret = RFAILED;
10870    F1AP_PDU_t             *f1apMsg = NULL;
10871    ResetAcknowledge_t     *f1ResetAck = NULLP;
10872    asn_enc_rval_t         encRetVal;
10873    DU_LOG("\nINFO   -->  F1AP : Building F1 Reset Acknowledgment \n");
10874
10875    do{
10876       /* Allocate the memory for F1ResetRequest_t */
10877       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
10878       if(f1apMsg == NULLP)
10879       {
10880          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
10881          break;
10882       }
10883
10884       f1apMsg->present =  F1AP_PDU_PR_successfulOutcome;
10885
10886       DU_ALLOC(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
10887       if(f1apMsg->choice.successfulOutcome == NULLP)
10888       {
10889          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
10890          break;
10891       }
10892       f1apMsg->choice.successfulOutcome->criticality   = Criticality_reject;
10893       f1apMsg->choice.successfulOutcome->value.present = SuccessfulOutcome__value_PR_ResetAcknowledge;
10894       f1ResetAck = &f1apMsg->choice.successfulOutcome->value.choice.ResetAcknowledge;
10895
10896       elementCnt = 1;
10897
10898       f1ResetAck->protocolIEs.list.count = elementCnt;
10899       f1ResetAck->protocolIEs.list.size = elementCnt*sizeof(ResetAcknowledgeIEs_t *);
10900
10901       DU_ALLOC(f1ResetAck->protocolIEs.list.array, f1ResetAck->protocolIEs.list.size );
10902       if(f1ResetAck->protocolIEs.list.array == NULLP)
10903       {
10904          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1ResetAckIEs failed");
10905          break;
10906       }
10907
10908       for(idx=0; idx<elementCnt; idx++)
10909       {
10910          DU_ALLOC(f1ResetAck->protocolIEs.list.array[idx], sizeof(ResetAcknowledgeIEs_t));
10911          if(f1ResetAck->protocolIEs.list.array[idx] == NULLP)
10912          {
10913             break;
10914          }
10915       }
10916       /*TransactionID*/
10917       idx = 0;
10918       f1ResetAck->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_TransactionID;
10919       f1ResetAck->protocolIEs.list.array[idx]->criticality = Criticality_reject;
10920       f1ResetAck->protocolIEs.list.array[idx]->value.present = ResetAcknowledgeIEs__value_PR_TransactionID;
10921       f1ResetAck->protocolIEs.list.array[idx]->value.choice.TransactionID = TRANS_ID;
10922
10923       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
10924
10925       /* Encode the F1SetupRequest type as UPER */
10926       memset(encBuf, 0, ENC_BUF_MAX_LEN);
10927       encBufSize = 0;
10928       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
10929
10930       /* Check encode results */
10931       if(encRetVal.encoded == ENCODE_FAIL)
10932       {
10933          DU_LOG("\nERROR  -->  F1AP : Could not encode F1ResetAck structure (at %s)\n",\
10934                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
10935          break;
10936       }
10937       else
10938       {
10939          DU_LOG("\nDUBUG   -->  F1AP : Created APER encoded buffer for F1ResetAck\n");
10940          for(int i=0; i< encBufSize; i++)
10941          {
10942             printf("%x",encBuf[i]);
10943          }
10944       }
10945       /* Sending msg */
10946       if(sendF1APMsg() != ROK)
10947       {
10948          DU_LOG("\nERROR  -->  F1AP : Sending F1 Reset Acknowledgement failed");
10949          break;
10950       }
10951
10952       ret = ROK;
10953       break;
10954    }while(true);
10955
10956    FreeF1ResetAck(f1apMsg);
10957    return ret;
10958 }
10959 /******************************************************************
10960 *
10961 * @brief free F1 reset msg allocated by aper_decoder
10962 *
10963 * @details
10964 *
10965 *    Function : freeAperDecodeF1ResetMsg
10966 *
10967 *    Functionality: free F1 reset msg allocated by aper_decoder
10968 *
10969 * @params[in] Reset_t *f1ResetMsg
10970 * @return void
10971 *
10972 * ****************************************************************/
10973
10974 void freeAperDecodeF1ResetMsg(Reset_t *f1ResetMsg)
10975 {
10976    uint8_t ieIdx =0;
10977    if(f1ResetMsg->protocolIEs.list.array)
10978    {
10979       for(ieIdx=0 ;ieIdx < f1ResetMsg->protocolIEs.list.count ; ieIdx++)
10980       {
10981          if(f1ResetMsg->protocolIEs.list.array[ieIdx])
10982          {
10983             free(f1ResetMsg->protocolIEs.list.array[ieIdx]);
10984          }
10985       }
10986       free(f1ResetMsg->protocolIEs.list.array);
10987    }
10988 }
10989
10990 /******************************************************************
10991  *
10992  * @brief Processes DL RRC Message Transfer  sent by CU
10993  *
10994  * @details
10995  *
10996  *    Function : procF1ResetReq
10997  *
10998  *    Functionality: Processes DL RRC Message Transfer sent by CU
10999  *
11000  * @params[in] F1AP_PDU_t ASN decoded F1AP message
11001  * @return ROK     - success
11002  *         RFAILED - failure
11003  *
11004  * ****************************************************************/
11005 uint8_t procF1ResetReq(F1AP_PDU_t *f1apMsg)
11006 {
11007    /* we are currently not supporting Ue release. right now we are supporting only init case of fireset */
11008    uint8_t       ieIdx = 0;
11009    uint8_t        ret = ROK;
11010    Reset_t       *f1ResetMsg = NULLP;
11011
11012    DU_LOG("\nINFO   -->  Processing F1 reset request");
11013    f1ResetMsg = &f1apMsg->choice.initiatingMessage->value.choice.Reset;
11014
11015    for(ieIdx=0; ieIdx<f1ResetMsg->protocolIEs.list.count; ieIdx++)
11016    {
11017       switch(f1ResetMsg->protocolIEs.list.array[ieIdx]->id)
11018       {
11019          case ProtocolIE_ID_id_TransactionID:
11020             break;
11021
11022          case ProtocolIE_ID_id_Cause:
11023             break;
11024
11025          case ProtocolIE_ID_id_ResetType:
11026             {
11027                break;
11028             }
11029
11030          default:
11031             break;
11032       }
11033    }
11034    ret = BuildAndSendF1ResetAck();
11035    DU_LOG("\nINFO   -->  UE release is not supported for now");
11036
11037    freeAperDecodeF1ResetMsg(f1ResetMsg);
11038
11039    return ret;
11040 }
11041
11042 /*******************************************************************
11043  *
11044  * @brief free the RRC delivery report
11045  *
11046  * @details
11047  *
11048  *    Function : freeRrcDeliveryReport
11049  *
11050  *    Functionality: free the RRC delivery report
11051  *
11052  * @params[in]
11053  * @return ROK     - success
11054  *         RFAILED - failure
11055  *
11056  * ****************************************************************/
11057 void freeRrcDeliveryReport(F1AP_PDU_t  *f1apMsg )
11058 {
11059    uint8_t idx=0;
11060    RRCDeliveryReport_t *rrcDeliveryReport= NULLP;
11061
11062    if(f1apMsg)
11063    {
11064       if(f1apMsg->choice.initiatingMessage)
11065       {
11066          rrcDeliveryReport = &f1apMsg->choice.initiatingMessage->value.choice.RRCDeliveryReport;
11067          if(rrcDeliveryReport->protocolIEs.list.array)
11068          {
11069             for(idx =0 ;idx <rrcDeliveryReport->protocolIEs.list.count ;
11070                   idx++)
11071             {
11072                if(rrcDeliveryReport->protocolIEs.list.array[idx])
11073                {
11074                   DU_FREE(rrcDeliveryReport->protocolIEs.list.array[idx],
11075                         sizeof(RRCDeliveryReportIEs_t));
11076                }
11077             }
11078             DU_FREE(rrcDeliveryReport->protocolIEs.list.array,
11079                   rrcDeliveryReport->protocolIEs.list.size);
11080          }
11081          DU_FREE(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
11082       }
11083       DU_FREE(f1apMsg,
11084             sizeof(F1AP_PDU_t));
11085    }
11086 }
11087
11088 /*******************************************************************
11089 *
11090 * @brief Builds and sends the RRC delivery report
11091 *
11092 * @details
11093 *
11094 *    Function : BuildAndSendRrcDeliveryReport
11095 *
11096 *    Functionality: Builds and sends the RRC delivery report
11097 *
11098 * @params[in]
11099 *
11100 * @return ROK     - success
11101 *         RFAILED - failure
11102 *
11103 * ****************************************************************/
11104 uint8_t BuildAndSendRrcDeliveryReport(uint32_t gnbCuUeF1apId, \
11105    uint32_t gnbDuUeF1apId, RrcDeliveryReport *rrcDelivery)
11106 {
11107    uint8_t             ret = RFAILED;
11108    uint8_t             idx    = 0;
11109    uint8_t             idx1   = 0;
11110    uint8_t             elementCnt = 0;
11111    F1AP_PDU_t          *f1apMsg = NULLP;
11112    asn_enc_rval_t      encRetVal;
11113    RRCDeliveryReport_t *rrcDeliveryReport= NULLP;
11114
11115    do{
11116
11117       DU_LOG("\nINFO   -->  F1AP : Building RRC delivery Message Transfer Message\n");
11118       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
11119       if(f1apMsg == NULLP)
11120       {
11121          DU_LOG(" ERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
11122          break;
11123       }
11124       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
11125       DU_ALLOC(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
11126       if(f1apMsg->choice.initiatingMessage == NULLP)
11127       {
11128          DU_LOG(" ERROR  -->  F1AP : Memory allocation for  F1AP-PDU  failed");
11129          break;
11130       }
11131       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_RRCDeliveryReport;
11132       f1apMsg->choice.initiatingMessage->criticality   = Criticality_ignore;
11133       f1apMsg->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_RRCDeliveryReport;
11134
11135       rrcDeliveryReport = &f1apMsg->choice.initiatingMessage->value.choice.RRCDeliveryReport;
11136       elementCnt = 4;
11137       rrcDeliveryReport->protocolIEs.list.count = elementCnt;
11138       rrcDeliveryReport->protocolIEs.list.size = elementCnt * sizeof(RRCDeliveryReportIEs_t *);
11139
11140       /* Initialize the F1Setup members */
11141       DU_ALLOC(rrcDeliveryReport->protocolIEs.list.array, rrcDeliveryReport->protocolIEs.list.size);
11142       if(rrcDeliveryReport->protocolIEs.list.array == NULLP)
11143       {
11144          DU_LOG(" ERROR  -->  F1AP : Memory allocation for RRC Delivery  failed");
11145          break;
11146       }
11147       for(idx =0 ;idx <elementCnt; idx++)
11148       {
11149          DU_ALLOC(rrcDeliveryReport->protocolIEs.list.array[idx], sizeof(RRCDeliveryReportIEs_t));
11150          if(rrcDeliveryReport->protocolIEs.list.array[idx] == NULLP)
11151          {
11152             break;
11153          }
11154       }
11155
11156       idx1 = 0;
11157
11158       /*GNB CU UE F1AP ID*/
11159       rrcDeliveryReport->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
11160       rrcDeliveryReport->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
11161       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.present = RRCDeliveryReportIEs__value_PR_GNB_CU_UE_F1AP_ID;
11162       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.choice.GNB_CU_UE_F1AP_ID = gnbCuUeF1apId;
11163
11164       /*GNB DU UE F1AP ID*/
11165       idx1++;
11166       rrcDeliveryReport->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
11167       rrcDeliveryReport->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
11168       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.present = RRCDeliveryReportIEs__value_PR_GNB_DU_UE_F1AP_ID;
11169       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.choice.GNB_DU_UE_F1AP_ID = gnbDuUeF1apId;
11170
11171       /*RRC delivery status*/
11172       idx1++;
11173       rrcDeliveryReport->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_RRCDeliveryStatus;
11174       rrcDeliveryReport->protocolIEs.list.array[idx1]->criticality = Criticality_ignore;
11175       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.present = RRCDeliveryReportIEs__value_PR_RRCDeliveryStatus;
11176       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.choice.RRCDeliveryStatus.delivery_status =\
11177       rrcDelivery->rrcDeliveryStatus.deliveryStatus;
11178       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.choice.RRCDeliveryStatus.triggering_message =\
11179       rrcDelivery->rrcDeliveryStatus.triggeringMessage;
11180
11181       /* SRB ID */
11182       idx1++;
11183       rrcDeliveryReport->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_SRBID;
11184       rrcDeliveryReport->protocolIEs.list.array[idx1]->criticality = Criticality_ignore;
11185       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.present = RRCDeliveryReportIEs__value_PR_SRBID;
11186       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.choice.SRBID =  rrcDelivery->srbId;
11187
11188       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
11189
11190       /* Encode the RRC DELIVERY REPORT type as APER */
11191       memset(encBuf, 0, ENC_BUF_MAX_LEN);
11192       encBufSize = 0;
11193       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
11194             encBuf);
11195
11196       /* Encode results */
11197       if(encRetVal.encoded == ENCODE_FAIL)
11198       {
11199          DU_LOG("\nERROR  -->  F1AP : Could not encode RRC Delivery Msg structure (at %s)\n",\
11200                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
11201          break;
11202       }
11203       else
11204       {
11205          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for RRC Delivery Msg \n");
11206          for(idx=0; idx< encBufSize; idx++)
11207          {
11208             printf("%x",encBuf[idx]);
11209          }
11210       }
11211
11212       /* Sending msg */
11213       if(sendF1APMsg() != ROK)
11214       {
11215          DU_LOG("\nERROR  -->  F1AP : Sending RRC delivery  msg request failed");
11216          break;
11217       }
11218       ret = ROK;
11219       break;
11220
11221    }while(true);
11222
11223    freeRrcDeliveryReport(f1apMsg);
11224    return ret;
11225 }
11226
11227 /*******************************************************************
11228  *
11229  * @brief Processes cells to be activated
11230  *
11231  * @details
11232  *
11233  *    Function : extractCellsToBeActivated
11234  *
11235  *    Functionality:
11236  *      - Processes cells to be activated list received in F1SetupRsp
11237  *
11238  * @params[in] void
11239  * @return ROK     - success
11240  *         RFAILED - failure
11241  *
11242  * ****************************************************************/
11243
11244 uint8_t extractCellsToBeActivated(Cells_to_be_Activated_List_t cellsToActivate)
11245 {
11246    uint8_t  ret = ROK;
11247    uint16_t idx, nci, pci = 0;
11248    Cells_to_be_Activated_List_Item_t cell;
11249
11250    for(idx=0; idx<cellsToActivate.list.count; idx++)
11251    {
11252       nci = 0;
11253       cell = cellsToActivate.list.array[idx]->value.choice.Cells_to_be_Activated_List_Item;
11254       bitStringToInt(&cell.nRCGI.nRCellIdentity, &nci);
11255
11256       if(cell.nRPCI)
11257       {
11258          pci = *cell.nRPCI;
11259       }
11260       ret = duProcCellsToBeActivated(cell.nRCGI.pLMN_Identity.buf, nci, pci);
11261    }
11262    return ret;
11263 }
11264 /******************************************************************
11265 *
11266 * @brief Processes F1 Setup Response allocated by aper_decoder
11267 *
11268 * @details
11269 *
11270 *    Function : freeF1SetupRsp
11271 *
11272 *    Functionality: free F1 Setup Response allocated by aper_decoder
11273 *
11274 * @params[in] F1SetupResponse_t *f1SetRspMsg
11275 * @return void
11276 *
11277 * ****************************************************************/
11278
11279 void freeAperDecodeF1SetupRsp(F1SetupResponse_t *f1SetRspMsg)
11280 {
11281    uint8_t ieIdx =0;
11282    uint8_t arrIdx =0;
11283    Cells_to_be_Activated_List_t *cellToActivate =NULLP;
11284    RRC_Version_t      *rrcVer =NULLP;
11285
11286    if(f1SetRspMsg->protocolIEs.list.array)
11287    {
11288       for(ieIdx=0; ieIdx<f1SetRspMsg->protocolIEs.list.count; ieIdx++)
11289       {
11290          if(f1SetRspMsg->protocolIEs.list.array[ieIdx])
11291          {
11292             switch(f1SetRspMsg->protocolIEs.list.array[ieIdx]->id)
11293             {
11294                case ProtocolIE_ID_id_Cells_to_be_Activated_List:
11295                   {
11296                      cellToActivate =
11297                         &f1SetRspMsg->protocolIEs.list.array[ieIdx]->value.choice.Cells_to_be_Activated_List;
11298                      if(cellToActivate->list.array)
11299                      {
11300                         for(arrIdx=0; arrIdx<cellToActivate->list.count ; arrIdx++)
11301                         {
11302                            if(cellToActivate->list.array[arrIdx])
11303                            {
11304
11305                               if(cellToActivate->list.array[0]->value.choice.Cells_to_be_Activated_List_Item.nRCGI.\
11306                               pLMN_Identity.buf)
11307                               {
11308                                  if(cellToActivate->list.array[0]->value.choice.\
11309                                        Cells_to_be_Activated_List_Item.nRCGI.nRCellIdentity.buf)
11310                                  {
11311                                     free(cellToActivate->list.array[0]->value.choice.\
11312                                           Cells_to_be_Activated_List_Item.nRCGI.nRCellIdentity.buf);
11313                                  }
11314
11315                                  free(cellToActivate->list.array[0]->value.choice.Cells_to_be_Activated_List_Item.\
11316                                        nRCGI.pLMN_Identity.buf);
11317                               }
11318                               free(cellToActivate->list.array[arrIdx]);
11319                            }
11320                         }
11321                         free(cellToActivate->list.array);
11322                      }
11323                      break;
11324                   }
11325                case ProtocolIE_ID_id_TransactionID:
11326                   {
11327                      break;
11328                   }
11329                case ProtocolIE_ID_id_gNB_CU_Name:
11330                   {
11331                      free(f1SetRspMsg->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_Name.buf);
11332                      break;
11333                   }
11334                case ProtocolIE_ID_id_GNB_CU_RRC_Version:
11335                   {
11336                      rrcVer = &f1SetRspMsg->protocolIEs.list.array[ieIdx]->value.choice.RRC_Version;
11337                      if(rrcVer->latest_RRC_Version.buf)
11338                      {
11339                         if(rrcVer->iE_Extensions)
11340                         {
11341                            if(rrcVer->iE_Extensions->list.array)
11342                            {
11343                               if(rrcVer->iE_Extensions->list.array[0])
11344                               {
11345                                  if(rrcVer->iE_Extensions->list.\
11346                                        array[0]->extensionValue.choice.Latest_RRC_Version_Enhanced.buf)
11347                                  {
11348                                     free(rrcVer->iE_Extensions->list.\
11349                                           array[0]->extensionValue.choice.Latest_RRC_Version_Enhanced.buf);
11350                                  }
11351                                  free(rrcVer->iE_Extensions->list.array[0]);
11352                               }
11353                               free(rrcVer->iE_Extensions->list.array);
11354                            }
11355                            free(rrcVer->iE_Extensions);
11356                         }
11357                         free(rrcVer->latest_RRC_Version.buf);
11358                      }
11359                      break;
11360
11361                   }
11362                default:
11363                   {
11364                      DU_LOG("\nERROR  -->  DU_APP : Invalid IE received in F1SetupRsp:%ld",
11365                            f1SetRspMsg->protocolIEs.list.array[ieIdx]->id);
11366                   }
11367             }
11368             free(f1SetRspMsg->protocolIEs.list.array[ieIdx]);
11369          }
11370       }
11371       free(f1SetRspMsg->protocolIEs.list.array);
11372    }
11373 }
11374 /******************************************************************
11375  *
11376  * @brief Processes F1 Setup Response sent by CU
11377  *
11378  * @details
11379  *
11380  *    Function : procF1SetupRsp
11381  *
11382  *    Functionality: Processes F1 Setup Response sent by CU
11383  *
11384  * @params[in] F1AP_PDU_t ASN decoded F1AP message
11385  * @return ROK     - success
11386  *         RFAILED - failure
11387  *
11388  * ****************************************************************/
11389 uint8_t procF1SetupRsp(F1AP_PDU_t *f1apMsg)
11390 {
11391    uint8_t ret = ROK;
11392    uint16_t idx =0;
11393    F1SetupResponse_t *f1SetRspMsg = NULLP;
11394    GNB_CU_Name_t     *cuName = NULLP;
11395    F1SetupRsp  f1SetRspDb;
11396    RRC_Version_t      *rrcVer =NULLP;
11397
11398    memset(&f1SetRspDb, 0, sizeof(F1SetupRsp));
11399
11400    DU_LOG("\nINFO   -->  F1AP : F1 Setup Response received");
11401    f1SetRspMsg = &f1apMsg->choice.successfulOutcome->value.choice.F1SetupResponse;
11402
11403    for(idx=0; idx<f1SetRspMsg->protocolIEs.list.count; idx++)
11404    {
11405       switch(f1SetRspMsg->protocolIEs.list.array[idx]->id)
11406       {
11407          case ProtocolIE_ID_id_Cells_to_be_Activated_List:
11408             {
11409                extractCellsToBeActivated(f1SetRspMsg->protocolIEs.list.array[idx]->\
11410                      value.choice.Cells_to_be_Activated_List);
11411                break;
11412             }
11413          case ProtocolIE_ID_id_TransactionID:
11414             {
11415                f1SetRspDb.transId = f1SetRspMsg->protocolIEs.list.array[idx]->\
11416                                     value.choice.TransactionID;
11417                break;
11418             }
11419          case ProtocolIE_ID_id_gNB_CU_Name:
11420             {
11421                cuName = &f1SetRspMsg->protocolIEs.list.array[idx]->\
11422                         value.choice.GNB_CU_Name;
11423                strcpy(f1SetRspDb.cuName, (const char*)cuName->buf);
11424                break;
11425             }
11426          case ProtocolIE_ID_id_GNB_CU_RRC_Version:
11427             {
11428                rrcVer = &f1SetRspMsg->protocolIEs.list.array[idx]->value.choice.RRC_Version;
11429                strcpy(f1SetRspDb.rrcVersion.rrcVer,
11430                      (const char*)rrcVer->latest_RRC_Version.buf);
11431                break;
11432             }
11433          default:
11434             DU_LOG("\nERROR  -->  DU_APP : Invalid IE received in F1SetupRsp:%ld",
11435                   f1SetRspMsg->protocolIEs.list.array[idx]->id);
11436       }
11437       duProcF1SetupRsp();
11438    }
11439
11440    freeAperDecodeF1SetupRsp(f1SetRspMsg);
11441    return ret;
11442 }
11443 /*******************************************************************
11444 *
11445 * @brief free GNB DU config update ack
11446 *
11447 * @details
11448 *
11449 *    Function : freeAperDecodeGnbDuAck
11450 *
11451 *    Functionality: Processes GNB DU config update ack And
11452 *                     added free part for the memory allocated by aper_decoder
11453 *
11454 * @params[in] F1AP_PDU_t ASN decoded F1AP message
11455 * @return ROK     - success
11456 *         RFAILED - failure
11457 *
11458 * ****************************************************************/
11459
11460 void freeAperDecodeGnbDuAck(GNBDUConfigurationUpdateAcknowledge_t *gnbDuAck)
11461 {
11462    uint8_t ieIdx = 0;
11463
11464    if(gnbDuAck->protocolIEs.list.array)
11465    {
11466       for(ieIdx=0; ieIdx < gnbDuAck->protocolIEs.list.count; ieIdx++)
11467       {
11468          if(gnbDuAck->protocolIEs.list.array[ieIdx])
11469          {
11470             free(gnbDuAck->protocolIEs.list.array[ieIdx]);
11471          }
11472       }
11473       free(gnbDuAck->protocolIEs.list.array);
11474    }
11475 }
11476 /*******************************************************************
11477 *
11478 * @brief Processes GNB DU config update ack
11479 *
11480 * @details
11481 *
11482 *    Function : procF1GNBDUCfgUpdAck
11483 *
11484 *    Functionality: added free part for the memory allocated by aper_decoder
11485 *
11486 * @params[in] F1AP_PDU_t *f1apMsg
11487 * @return void
11488 *
11489 * ****************************************************************/
11490 uint8_t procF1GNBDUCfgUpdAck(F1AP_PDU_t *f1apMsg)
11491 {
11492    uint8_t ieIdx;
11493    GNBDUConfigurationUpdateAcknowledge_t *gnbDuAck = NULLP;
11494
11495    DU_LOG("\nINFO   -->  F1AP : GNB-DU config update acknowledgment");
11496    gnbDuAck = &f1apMsg->choice.successfulOutcome->value.choice.GNBDUConfigurationUpdateAcknowledge;
11497
11498    for(ieIdx=0; ieIdx < gnbDuAck->protocolIEs.list.count; ieIdx++)
11499    {
11500       switch(gnbDuAck->protocolIEs.list.array[ieIdx]->id)
11501       {
11502          case ProtocolIE_ID_id_TransactionID:
11503             break;
11504          case ProtocolIE_ID_id_Cells_to_be_Activated_List:
11505             break;
11506          default :
11507             DU_LOG("\nERROR  -->  F1AP: Invalid IE Received: %ld, at procF1GNBDUCfgUpdAck()", \
11508             gnbDuAck->protocolIEs.list.array[ieIdx]->id);
11509             break;
11510       }
11511    }
11512    duProcGnbDuCfgUpdAckMsg();
11513 #if 0
11514    if(BuildAndSendF1ResetReq() != ROK)
11515    {
11516       return RFAILED;
11517    }
11518 #endif
11519
11520    freeAperDecodeGnbDuAck(gnbDuAck);
11521    return ROK;
11522 }
11523 /******************************************************************
11524 *
11525 * @brief free DL RRC Message Transfer allocated by aper_decoder
11526 *
11527 * @details
11528 *
11529 *    Function : freeAperDecodef1DlRrcMsg
11530 *
11531 *    Functionality: free DL RRC Message Transfer allocated by aper_decoder
11532 *
11533 * @params[in] DLRRCMessageTransfer_t *f1DlRrcMsg
11534 * @return ROK     - success
11535 *         RFAILED - failure
11536 *
11537 * ****************************************************************/
11538
11539 void freeAperDecodef1DlRrcMsg(DLRRCMessageTransfer_t *f1DlRrcMsg)
11540 {
11541    uint8_t ieIdx =0;
11542    RRCContainer_t *rrcContainer = NULLP;
11543
11544    if(f1DlRrcMsg->protocolIEs.list.array)
11545    {
11546       for(ieIdx=0; ieIdx<f1DlRrcMsg->protocolIEs.list.count; ieIdx++)
11547       {
11548          if(f1DlRrcMsg->protocolIEs.list.array[ieIdx])
11549          {
11550             switch(f1DlRrcMsg->protocolIEs.list.array[ieIdx]->id)
11551             {
11552                case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
11553                   break;
11554                case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
11555                   break;
11556                case ProtocolIE_ID_id_SRBID:
11557                   break;
11558                case ProtocolIE_ID_id_RRCContainer:
11559                   {
11560                      rrcContainer =&f1DlRrcMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer;
11561                      free(rrcContainer->buf);
11562                   }
11563                case ProtocolIE_ID_id_ExecuteDuplication:
11564                   break;
11565                case ProtocolIE_ID_id_RRCDeliveryStatusRequest:
11566                   break;
11567                   break;
11568             }
11569             free(f1DlRrcMsg->protocolIEs.list.array[ieIdx]);
11570          }
11571       }
11572       free(f1DlRrcMsg->protocolIEs.list.array);
11573    }
11574 }
11575 /******************************************************************
11576  *
11577  * @brief Processes DL RRC Message Transfer  sent by CU
11578  *
11579  * @details
11580  *
11581  *    Function : procF1DlRrcMsgTrans
11582  *
11583  *    Functionality: Processes DL RRC Message Transfer sent by CU
11584  *
11585  * @params[in] F1AP_PDU_t ASN decoded F1AP message
11586  * @return ROK     - success
11587  *         RFAILED - failure
11588  *
11589  * ****************************************************************/
11590 uint8_t procF1DlRrcMsgTrans(F1AP_PDU_t *f1apMsg)
11591 {
11592    uint8_t  idx, ret;
11593    DLRRCMessageTransfer_t *f1DlRrcMsg = NULLP;
11594    F1DlRrcMsg dlMsg;
11595    memset(&dlMsg, 0, sizeof(F1DlRrcMsg));
11596
11597    DU_LOG("\nINFO   -->  DU_APP : DL RRC message transfer Recevied");
11598    f1DlRrcMsg = &f1apMsg->choice.initiatingMessage->value.choice.DLRRCMessageTransfer;
11599
11600    ret = ROK;
11601
11602    for(idx=0; idx<f1DlRrcMsg->protocolIEs.list.count; idx++)
11603    {
11604       switch(f1DlRrcMsg->protocolIEs.list.array[idx]->id)
11605       {
11606          case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
11607             {
11608                dlMsg.gnbCuUeF1apId = f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.GNB_CU_UE_F1AP_ID;
11609                break;
11610             }
11611          case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
11612             {
11613                dlMsg.gnbDuUeF1apId = f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID;
11614                break;
11615             }
11616          case ProtocolIE_ID_id_SRBID:
11617             {
11618                dlMsg.srbId = f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.SRBID;
11619                break;
11620             }
11621          case ProtocolIE_ID_id_ExecuteDuplication:
11622             dlMsg.execDup = true;
11623             break;
11624
11625          case ProtocolIE_ID_id_RRCContainer:
11626             {
11627                if(f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.size > 0)
11628                {
11629                   dlMsg.rrcMsgSize = f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.size;
11630                   DU_ALLOC(dlMsg.rrcMsgPdu, dlMsg.rrcMsgSize);
11631                   if(dlMsg.rrcMsgPdu)
11632                   {
11633                      memcpy(dlMsg.rrcMsgPdu, f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.buf,\
11634                         dlMsg.rrcMsgSize);
11635                   }
11636                   else
11637                   {
11638                      DU_LOG("\nERROR  -->  DU APP : Memory alloc Failed at RRC Container at procF1DlRrcMsgTrans()");
11639                      return RFAILED;
11640                   }
11641                }
11642                else
11643                {
11644                   DU_LOG("\nERROR  -->  DU_APP : RRC Container Size is invalid:%ld",\
11645                   f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.size);
11646                   return RFAILED;
11647                }
11648                break;
11649             }
11650          case ProtocolIE_ID_id_RRCDeliveryStatusRequest:
11651             {
11652                dlMsg.deliveryStatRpt = true;
11653                break;
11654             }
11655          default:
11656             DU_LOG("\nERROR  -->  DU_APP : Invalid IE received in DL RRC Msg Transfer:%ld",
11657                   f1DlRrcMsg->protocolIEs.list.array[idx]->id);
11658       }
11659    }
11660
11661    ret = duProcDlRrcMsg(&dlMsg);
11662
11663    freeAperDecodef1DlRrcMsg(f1DlRrcMsg);
11664    return ret;
11665 }
11666 /*******************************************************************
11667  *
11668 * @brief Builds the DRB to be Setup Mod list
11669 *
11670 * @details
11671 *
11672 *    Function :
11673 *
11674 *    Functionality: Constructs the DRB to be Setup Mod list
11675 *
11676 * @params[in] DRBs_SetupMod_List_t *drbSet
11677 *
11678 * @return ROK     - success
11679 *         RFAILED - failure
11680 *
11681 * ****************************************************************/
11682
11683 uint8_t BuildDrbSetupModList(DRBs_SetupMod_List_t *drbSet , DuUeCfg *ueCfg)
11684 {
11685    uint8_t arrIdx =0;
11686    uint8_t drbCnt =0;
11687    struct DRBs_SetupMod_ItemIEs *drbItemIe;
11688
11689    drbCnt = 1;
11690    drbSet->list.count = drbCnt;
11691    drbSet->list.size = drbCnt * sizeof(DRBs_SetupMod_ItemIEs_t *);
11692    DU_ALLOC(drbSet->list.array, drbSet->list.size);
11693    if(drbSet->list.array == NULLP)
11694    {
11695       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDrbToBeSetupModList");
11696       return  RFAILED;
11697    }
11698    for(arrIdx=0; arrIdx<drbCnt; arrIdx++)
11699    {
11700       DU_ALLOC(drbSet->list.array[arrIdx], sizeof(DRBs_SetupMod_ItemIEs_t));
11701       if(drbSet->list.array[arrIdx] == NULLP)
11702       {
11703               DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDrbToBeSetupModList");
11704               return  RFAILED;
11705       }
11706
11707       drbItemIe = (struct DRBs_SetupMod_ItemIEs *)drbSet->list.array[arrIdx];
11708       drbItemIe->id = ProtocolIE_ID_id_DRBs_SetupMod_Item;
11709       drbItemIe->criticality = Criticality_reject;
11710       drbItemIe->value.present = DRBs_SetupMod_ItemIEs__value_PR_DRBs_SetupMod_Item;
11711       drbItemIe->value.choice.DRBs_SetupMod_Item.dRBID = ueCfg->upTnlInfo[arrIdx].drbId;
11712       if(fillDlTnlSetupList(&drbItemIe->value.choice.DRBs_SetupMod_Item.dLUPTNLInformation_ToBeSetup_List,\
11713       &ueCfg->upTnlInfo[arrIdx])!= ROK)
11714       {
11715          DU_LOG("\nERROR  -->  F1AP : Failed to fill DlTnl SetupList in BuildDrbToBeSetupModList");
11716          return RFAILED;
11717       }
11718
11719    }
11720
11721    return ROK;
11722 }
11723 /*******************************************************************
11724 * @brief Free the memory allocated for DRB setup List
11725 *
11726 * @details
11727 *
11728 *    Function : FreeDrbSetupModList
11729 *
11730 *    Functionality:
11731 *       Free the memory allocated for DRB setup list
11732 *
11733 * @params[in] DRBs_Setup_List_t *
11734 * @return void
11735 *
11736 * ****************************************************************/
11737 void FreeDrbSetupModList(DRBs_SetupMod_List_t *drbSetupList)
11738 {
11739    uint8_t arrIdx = 0;
11740    DRBs_SetupMod_ItemIEs_t *drbItemIe = NULLP;
11741
11742    for(arrIdx = 0; arrIdx < drbSetupList->list.count; arrIdx++)
11743    {
11744       drbItemIe = ((DRBs_SetupMod_ItemIEs_t *)drbSetupList->list.array[arrIdx]);
11745       freeDlTnlInfo(&drbItemIe->value.choice.DRBs_SetupMod_Item.dLUPTNLInformation_ToBeSetup_List);
11746    }
11747 }
11748 /*******************************************************************
11749 * @brief Free the memory allocated for UE Context Mod Response
11750 *
11751 * @details
11752 *
11753 *    Function : FreeUeContextModResp
11754 *
11755 *    Functionality:
11756 *       Free the memory allocated for UE Context Mod Response
11757 *
11758 * @params[in] F1AP_PDU_t *f1apMsg
11759 * @return void
11760 *
11761 * ****************************************************************/
11762
11763 void FreeUeContextModResp(F1AP_PDU_t *f1apMsg)
11764 {
11765    uint8_t ieIdx;
11766    UEContextModificationResponse_t *ueContextModifyRes = NULLP;
11767    if(f1apMsg)
11768    {
11769       if(f1apMsg->choice.successfulOutcome)
11770       {
11771          ueContextModifyRes =&f1apMsg->choice.successfulOutcome->value.choice.UEContextModificationResponse;
11772          if(ueContextModifyRes->protocolIEs.list.array)
11773          {
11774             for(ieIdx=0 ; ieIdx<ueContextModifyRes->protocolIEs.list.count; ieIdx++)
11775             {
11776                if(ueContextModifyRes->protocolIEs.list.array[ieIdx])
11777                {
11778                   switch(ueContextModifyRes->protocolIEs.list.array[ieIdx]->id)
11779                   {
11780                      case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
11781                         break;
11782                      case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
11783                         break;
11784                      case ProtocolIE_ID_id_DRBs_SetupMod_List:
11785                         {
11786                             FreeDrbSetupModList(&(ueContextModifyRes->protocolIEs.list.array[ieIdx]->\
11787                             value.choice.DRBs_SetupMod_List));
11788                             break;
11789                         }
11790                   }
11791                   DU_FREE(ueContextModifyRes->protocolIEs.list.array[ieIdx], sizeof(UEContextModificationResponse_t));
11792                }
11793
11794             }
11795             DU_FREE(ueContextModifyRes->protocolIEs.list.array, ueContextModifyRes->protocolIEs.list.size);
11796          }
11797          DU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
11798       }
11799       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
11800    }
11801 }
11802
11803 /*****************************************************************i
11804 *
11805 * @brief Creating the ue context modifcation response and sending
11806 *
11807 * @details
11808 *
11809 *    Function : BuildAndSendUeContextModResp
11810 *
11811 *    Functionality:
11812 *         - Creating the ue context modifcation response
11813 *
11814 * @params[in]
11815 * @return ROK     - success
11816 *         RFAILED - failure
11817 *
11818 * ****************************************************************/
11819 uint8_t BuildAndSendUeContextModResp(uint8_t ueIdx, uint8_t cellId)
11820 {
11821    uint8_t   ieIdx = 0;
11822    uint8_t   cellIdx =0;
11823    uint8_t   elementCnt = 0;
11824    uint8_t   ret = RFAILED;
11825    uint32_t  gnbCuUeF1apId;   /* gNB-CU UE F1AP Id */
11826    uint32_t  gnbDuUeF1apId;   /* gNB-DU UE F1AP Id */
11827    F1AP_PDU_t *f1apMsg = NULLP;
11828    asn_enc_rval_t         encRetVal;
11829    UEContextModificationResponse_t *ueContextModifyRes = NULLP;
11830    DuUeCb                   *ueCb = NULLP;
11831
11832    DU_LOG("\nINFO  -->  F1AP : Building Ue context modification response\n");
11833
11834    while(1)
11835    {
11836       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
11837       if(f1apMsg == NULLP)
11838       {
11839          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed Ue context modification");
11840          break;
11841       }
11842
11843       f1apMsg->present =  F1AP_PDU_PR_successfulOutcome;
11844
11845       DU_ALLOC(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
11846       if(f1apMsg->choice.successfulOutcome == NULLP)
11847       {
11848          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed Ue context modification");
11849          break;
11850       }
11851       f1apMsg->choice.successfulOutcome->procedureCode = ProcedureCode_id_UEContextModification;
11852       f1apMsg->choice.successfulOutcome->criticality = Criticality_reject;
11853       f1apMsg->choice.successfulOutcome->value.present = SuccessfulOutcome__value_PR_UEContextModificationResponse;
11854
11855       ueContextModifyRes =&f1apMsg->choice.successfulOutcome->value.choice.UEContextModificationResponse;
11856
11857       elementCnt = 3;
11858       ueContextModifyRes->protocolIEs.list.count = elementCnt;
11859       ueContextModifyRes->protocolIEs.list.size = elementCnt*sizeof(UEContextModificationResponse_t*);
11860
11861       /* Initialize the UE context modification members */
11862       DU_ALLOC(ueContextModifyRes->protocolIEs.list.array, ueContextModifyRes->protocolIEs.list.size);
11863       if(ueContextModifyRes->protocolIEs.list.array == NULLP)
11864       {
11865          DU_LOG("\nERROR  -->  F1AP : Memory allocation for UE context modifcation Request failed");
11866          break;
11867       }
11868
11869       for(ieIdx=0 ; ieIdx<elementCnt; ieIdx++)
11870       {
11871          DU_ALLOC(ueContextModifyRes->protocolIEs.list.array[ieIdx], sizeof(UEContextModificationResponse_t));
11872          if(ueContextModifyRes->protocolIEs.list.array[ieIdx] == NULLP)
11873          {
11874             DU_LOG("\nERROR  -->  F1AP : Memory allocation for UE context modifcation Request failed");
11875             break;
11876          }
11877       }
11878
11879       /* Fetching Ue Cb Info*/
11880       GET_CELL_IDX(cellId, cellIdx);
11881       gnbDuUeF1apId = duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].gnbDuUeF1apId;
11882       gnbCuUeF1apId = duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].gnbCuUeF1apId;
11883       ueCb = &duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1];
11884
11885       ieIdx=0;
11886       ueContextModifyRes->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
11887       ueContextModifyRes->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
11888       ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.present =\
11889       UEContextModificationResponseIEs__value_PR_GNB_CU_UE_F1AP_ID;
11890       ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID = gnbCuUeF1apId;
11891
11892       ieIdx++;
11893       ueContextModifyRes->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
11894       ueContextModifyRes->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
11895       ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.present=\
11896       UEContextModificationResponseIEs__value_PR_GNB_DU_UE_F1AP_ID;
11897       ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID = gnbDuUeF1apId;
11898
11899       ieIdx++;
11900       ueContextModifyRes->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_DRBs_SetupMod_List;
11901       ueContextModifyRes->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
11902       ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.present =\
11903       UEContextModificationResponseIEs__value_PR_DRBs_SetupMod_List;
11904       if(ueCb->f1UeDb)
11905       {
11906          ret = BuildDrbSetupModList(&(ueContextModifyRes->protocolIEs.list.array[ieIdx]->\
11907                   value.choice.DRBs_SetupMod_List) , &ueCb->f1UeDb->duUeCfg);
11908          if(ret != ROK)
11909          {
11910             DU_LOG( "\nERROR  -->  F1AP : Failed to build drb setupmod List ");
11911             break;
11912          }
11913          freeF1UeDb(ueCb->f1UeDb);
11914          ueCb->f1UeDb = NULLP;
11915       }
11916       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
11917
11918       /* Encode the F1SetupRequest type as APER */
11919       memset(encBuf, 0, ENC_BUF_MAX_LEN);
11920       encBufSize = 0;
11921       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,encBuf);
11922
11923       /* Encode results */
11924       if(encRetVal.encoded == ENCODE_FAIL)
11925       {
11926          DU_LOG( "\nERROR  -->  F1AP : Could not encode UE Context Setup Request structure (at %s)\n",\
11927                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
11928          ret = RFAILED;
11929          break;
11930       }
11931       else
11932       {
11933          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for UE Context Modification Response\n");
11934          for(int i=0; i< encBufSize; i++)
11935          {
11936             printf("%x",encBuf[i]);
11937          }
11938       }
11939
11940       /* Sending  msg  */
11941       if(sendF1APMsg() != ROK)
11942       {
11943          DU_LOG("\nERROR  -->  F1AP : Sending UE Context Setup Res Failed");
11944          ret = RFAILED;
11945          break;
11946       }
11947       break;
11948    }
11949    FreeUeContextModResp(f1apMsg);
11950    return ret;
11951 }
11952 /*******************************************************************
11953  *
11954  * @brief Deallocating the memory allocated by the aper decoder
11955  *          for QOSInfo
11956  *
11957  * @details
11958  *
11959  *    Function : freeAperDecodeQosInfo
11960  *
11961  *    Functionality:  Deallocating the memory allocated for QOSInfo
11962  *
11963  * @params[in] QoSFlowLevelQoSParameters_t *drbQos
11964  *
11965  * @return void
11966  *
11967  * ****************************************************************/
11968
11969 void freeAperDecodeQosInfo(QoSFlowLevelQoSParameters_t *drbQos)
11970 {
11971    if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI != NULLP)
11972    {
11973       if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow!=NULLP)
11974       {
11975          if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume!=NULLP)
11976          {
11977             free(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume);
11978          }
11979          free(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow);
11980       }
11981       free(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI);
11982    }
11983 }
11984 /*******************************************************************
11985  *
11986  * @brief Deallocating the memory allocated by the aper decoder
11987  *          for UlTnlInfoforDrb
11988  *
11989  * @details
11990  *
11991  *    Function : freeAperDecodeUlTnlInfoforDrbSetupMod
11992  *
11993  *    Functionality:  Deallocating memory allocated for UlTnlInfoforDrb
11994  *
11995  * @params[in] ULUPTNLInformation_ToBeSetup_List_t *ulInfo
11996  *
11997  * @return void
11998  *
11999  * ****************************************************************/
12000 void freeAperDecodeUlTnlInfoforDrbSetupMod(ULUPTNLInformation_ToBeSetup_List_t *ulInfo)
12001 {
12002    uint8_t arrIdx =0;
12003
12004    if(ulInfo->list.array)
12005    {
12006       for(arrIdx=0; arrIdx<ulInfo->list.count ; arrIdx++)
12007       {
12008          if(ulInfo->list.array[arrIdx])
12009          {
12010             if(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel )
12011             {
12012                if(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf)
12013                {
12014                   if(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf)
12015                   {
12016                      free(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
12017                            gTP_TEID.buf);
12018                   }
12019                   free(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
12020                         transportLayerAddress.buf);
12021                }
12022                free(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel);
12023             }
12024             free(ulInfo->list.array[arrIdx]);
12025          }
12026       }
12027       free(ulInfo->list.array);
12028    }
12029 }
12030 /*******************************************************************
12031  *
12032  * @brief Deallocating the memory allocated by the aper decoder
12033  *          for DrbSetupModItem
12034  *
12035  * @details
12036  *
12037  *    Function : freeAperDecodeDrbSetupModItem
12038  *
12039  *    Functionality:  Deallocating memory allocated for DrbSetupModItem
12040  *
12041  * @params[in] DRBs_ToBeSetupMod_Item_t *drbItem
12042  *
12043  * @return void
12044  *
12045  * ****************************************************************/
12046
12047 void freeAperDecodeDrbSetupModItem(DRBs_ToBeSetupMod_Item_t *drbItem)
12048 {
12049    uint8_t arrIdx =0;
12050    SNSSAI_t *snssai =NULLP;
12051    Flows_Mapped_To_DRB_List_t *flowMap = NULLP;
12052
12053    drbItem->qoSInformation.present = QoSInformation_PR_choice_extension;
12054    switch(drbItem->qoSInformation.present)
12055    {
12056       case QoSInformation_PR_NOTHING:
12057          break;
12058       case QoSInformation_PR_eUTRANQoS:
12059          {
12060             if(drbItem->qoSInformation.choice.eUTRANQoS)
12061             {
12062                free(drbItem->qoSInformation.choice.eUTRANQoS);
12063             }
12064             break;
12065          }
12066       case QoSInformation_PR_choice_extension:
12067          {
12068             if(drbItem->qoSInformation.choice.choice_extension)
12069             {
12070                freeAperDecodeQosInfo(&drbItem->qoSInformation.choice.choice_extension->value.choice.\
12071                      DRB_Information.dRB_QoS);
12072                snssai = &drbItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI;
12073                if(snssai->sST.buf)
12074                {
12075                   free(snssai->sST.buf);
12076                }
12077                if(snssai->sD)
12078                {
12079                   if(snssai->sD->buf)
12080                   {
12081                      free(snssai->sD->buf);
12082                   }
12083                   free(snssai->sD);
12084                }
12085
12086                flowMap = &drbItem->qoSInformation.choice.choice_extension->value.choice.\
12087                          DRB_Information.flows_Mapped_To_DRB_List;
12088                if(flowMap->list.array)
12089                {
12090                   for(arrIdx=0; arrIdx<flowMap->list.count; arrIdx++)
12091                   {
12092                      if(flowMap->list.array[arrIdx] )
12093                      {
12094                         freeAperDecodeQosInfo(&flowMap->list.array[arrIdx]->qoSFlowLevelQoSParameters);
12095                         free(flowMap->list.array[arrIdx]);
12096                      }
12097                   }
12098                   free(flowMap->list.array);
12099                }
12100
12101                free(drbItem->qoSInformation.choice.choice_extension);
12102             }
12103             break;
12104          }
12105
12106    }
12107    freeAperDecodeUlTnlInfoforDrbSetupMod(&drbItem->uLUPTNLInformation_ToBeSetup_List);
12108    if(drbItem->uLConfiguration)
12109    {
12110       free(drbItem->uLConfiguration);
12111    }
12112 }
12113
12114 /*******************************************************************
12115  *
12116  * @brief Deallocating the memory allocated by the aper decoder
12117  *          for DrbToBeSetupModList
12118  *
12119  * @details
12120  *
12121  *    Function : freeAperDecodeDrbToBeSetupModList
12122  *
12123  *    Functionality:  Deallocating memory allocated for DrbToBeSetupModList
12124  *
12125  * @params[in] DRBs_ToBeSetupMod_List_t *drbSet
12126  *
12127  * @return void
12128  *
12129  * ****************************************************************/
12130
12131 void freeAperDecodeDrbToBeSetupModList(DRBs_ToBeSetupMod_List_t *drbSet)
12132 {
12133    uint8_t arrIdx =0;
12134    struct DRBs_ToBeSetupMod_ItemIEs *drbItemIe;
12135
12136    if(drbSet->list.array)
12137    {
12138       for(arrIdx=0; arrIdx<drbSet->list.count ; arrIdx++)
12139       {
12140          if(drbSet->list.array[arrIdx] != NULLP)
12141          {
12142             if(arrIdx == 0)
12143             {
12144                drbItemIe = (DRBs_ToBeSetupMod_ItemIEs_t *)drbSet->list.array[arrIdx];
12145                freeAperDecodeDrbSetupModItem(&(drbItemIe->value.choice.DRBs_ToBeSetupMod_Item));
12146             }
12147             free(drbSet->list.array[arrIdx]);
12148          }
12149       }
12150       free(drbSet->list.array);
12151    }
12152
12153 }
12154 /*******************************************************************
12155  *
12156  * @brief Deallocating the memory allocated by the aper decoder
12157  *          for UeContextModificationReqMsg
12158  *
12159  * @details
12160  *
12161  *    Function : freeAperDecodeUeContextModificationReqMsg
12162  *
12163  *    Functionality:  Deallocating memory allocated for
12164  *                  UeContextModificationReqMsg
12165  *
12166  * @params[in] UEContextModificationRequest_t *UeContextModifyReq
12167  *
12168  * @return void
12169  *
12170  * ****************************************************************/
12171 void freeAperDecodeUeContextModificationReqMsg(UEContextModificationRequest_t *UeContextModifyReq )
12172 {
12173    uint8_t arrIdx, ieId;
12174
12175    if(UeContextModifyReq->protocolIEs.list.array)
12176    {
12177       for( arrIdx = 0 ; arrIdx<UeContextModifyReq->protocolIEs.list.count ; arrIdx++)
12178       {
12179          if(UeContextModifyReq->protocolIEs.list.array[arrIdx])
12180          {
12181             ieId = UeContextModifyReq->protocolIEs.list.array[arrIdx]->id;
12182             switch(ieId)
12183             {
12184                case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
12185                   break;
12186                case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
12187                   break;
12188                case ProtocolIE_ID_id_DRBs_ToBeSetupMod_List:
12189                   {
12190                      freeAperDecodeDrbToBeSetupModList(&UeContextModifyReq->protocolIEs.list.array[arrIdx]->\
12191                            value.choice.DRBs_ToBeSetupMod_List);
12192                      break;
12193                   }
12194             }
12195             free(UeContextModifyReq->protocolIEs.list.array[arrIdx]);
12196          }
12197       }
12198       free(UeContextModifyReq->protocolIEs.list.array);
12199    }
12200 }
12201 /*******************************************************************
12202  *
12203  * @brief processing the F1 UeContextModificationReq
12204  *
12205  * @details
12206  *
12207  *    Function : procF1UeContextModificationReq
12208  *
12209  *    Functionality:  processing the F1 UeContextModificationReq
12210  *
12211  * @params[in] F1AP_PDU_t *f1apMsg
12212  *
12213  * @return
12214  * ****************************************************************/
12215 uint8_t procF1UeContextModificationReq(F1AP_PDU_t *f1apMsg)
12216 {
12217    UEContextModificationRequest_t *ueContextModifyReq = NULLP;
12218    uint8_t  ret = ROK, ieIdx = 0, lcId =0,cellIdx=0, ueIdx=0;
12219    DuUeCb   *duUeCb = NULLP;
12220    DRBs_ToBeSetupMod_List_t *drbSetupModCfg;
12221    uint32_t gnbCuUeF1apId, gnbDuUeF1apId;
12222
12223    ueContextModifyReq = &f1apMsg->choice.initiatingMessage->value.choice.UEContextModificationRequest;
12224    for(ieIdx=0; (ieIdx < ueContextModifyReq->protocolIEs.list.count && ret == ROK); ieIdx++)
12225    {
12226       switch(ueContextModifyReq->protocolIEs.list.array[ieIdx]->id)
12227       {
12228          case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
12229             {
12230                gnbCuUeF1apId = ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID;
12231                break;
12232             }
12233          case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
12234             {
12235                gnbDuUeF1apId = ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID;
12236                break;
12237             }
12238          case ProtocolIE_ID_id_DRBs_ToBeSetupMod_List:
12239             {
12240                for(cellIdx = 0; cellIdx < duCb.numActvCells; cellIdx++)
12241                {
12242                   for(ueIdx = 0; ueIdx < duCb.numUe; ueIdx++)
12243                   {
12244                      if((duCb.actvCellLst[cellIdx]->ueCb[ueIdx].gnbDuUeF1apId == gnbDuUeF1apId)&&\
12245                            (duCb.actvCellLst[cellIdx]->ueCb[ueIdx].gnbCuUeF1apId == gnbCuUeF1apId))
12246                      {
12247
12248                         duUeCb = &duCb.actvCellLst[cellIdx]->ueCb[ueIdx];
12249                         lcId = getDrbLcId(&duUeCb->drbBitMap);
12250                         if(lcId != RFAILED)
12251                         {
12252                            DU_ALLOC(duUeCb->f1UeDb, sizeof(F1UeContextSetupDb));
12253                            if(duUeCb->f1UeDb)
12254                            {
12255                               duUeCb->f1UeDb->actionType = UE_CTXT_MOD;
12256                               drbSetupModCfg = &ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.\
12257                               choice.DRBs_ToBeSetupMod_List;
12258                               if(extractDrbListToSetup(lcId, NULL, drbSetupModCfg ,drbSetupModCfg->list.count, \
12259                               &duUeCb->f1UeDb->duUeCfg))
12260                               {
12261                                  DU_LOG("\nERROR  -->  DU APP : Failed at extractDrbListToSetup()");
12262                                  ret = RFAILED;
12263                               }
12264                            }
12265                         }
12266                      }
12267                      else
12268                      {
12269                         DU_LOG("\nERROR  -->  DU APP : wrong values of gnbCuUeF1apId and gnbDuUeF1apId ");
12270                         ret = RFAILED;
12271                      }
12272                   }
12273                }
12274                break;
12275             }
12276       }
12277    }
12278    if(ret != RFAILED)
12279    {
12280       ret = duProcUeContextModReq(duUeCb);
12281    }
12282    freeAperDecodeUeContextModificationReqMsg(ueContextModifyReq);
12283    return ret;
12284 }
12285 /*****************************************************************i
12286 *
12287 * @brief Free memory allocated for UE Context Release Request
12288 *
12289 * @details
12290 *
12291 *    Function : FreeUeContextReleaseReq
12292 *
12293 *    Functionality:
12294 *         - Free memory allocated for UE Context Release Request
12295 *
12296 * @params[in] F1AP_PDU_t *f1apMsg
12297 * @return void
12298 *
12299 * *************************************************************/
12300 void FreeUeContextReleaseReq(F1AP_PDU_t *f1apMsg)
12301 {
12302    uint8_t ieIdx;
12303    UEContextReleaseRequest_t *ueReleaseReq = NULLP;
12304
12305    if(f1apMsg)
12306    {
12307       if(f1apMsg->choice.initiatingMessage)
12308       {
12309          ueReleaseReq =&f1apMsg->choice.initiatingMessage->value.choice.UEContextReleaseRequest;
12310          if(ueReleaseReq->protocolIEs.list.array)
12311          {
12312             for(ieIdx=0 ; ieIdx<ueReleaseReq->protocolIEs.list.count; ieIdx++)
12313             {
12314                DU_FREE(ueReleaseReq->protocolIEs.list.array[ieIdx], sizeof(UEContextReleaseRequest_t));
12315             }
12316             DU_FREE(ueReleaseReq->protocolIEs.list.array, ueReleaseReq->protocolIEs.list.size);
12317          }
12318          DU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
12319       }
12320       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
12321    }
12322
12323 }
12324 /*****************************************************************i
12325 *
12326 * @brief Build and Send UE Context Release Request
12327 *
12328 * @details
12329 *
12330 *    Function : BuildAndSendUeContextReleaseReq
12331 *
12332 *    Functionality:
12333 *         - Build and Send UE Context Release Request
12334 *
12335 * @params[in]
12336 * @return ROK     - success
12337 *         RFAILED - failure
12338 *
12339 * *************************************************************/
12340 uint8_t BuildAndSendUeContextReleaseReq(uint16_t cellId, uint8_t ueIdx)
12341 {
12342    bool memAllocFail = false;
12343    uint8_t ieIdx =0;
12344    uint8_t ret = RFAILED;
12345    uint16_t cellIdx =0;
12346    uint16_t crnti = 0;
12347    uint8_t  elementCnt = 0;
12348    uint32_t  gnbCuUeF1apId =0;   /* gNB-CU UE F1AP Id */
12349    uint32_t  gnbDuUeF1apId =0;   /* gNB-DU UE F1AP Id */
12350    asn_enc_rval_t encRetVal;
12351    F1AP_PDU_t *f1apMsg = NULLP;
12352    UEContextReleaseRequest_t *ueReleaseReq = NULLP;
12353
12354    DU_LOG("\nINFO  --> Building the UE Context Release Request");
12355    do
12356    {
12357       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
12358       if(f1apMsg == NULLP)
12359       {
12360          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseReq(): Memory allocation failed for f1apMsg");
12361          break;
12362       }
12363
12364       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
12365       DU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
12366       if(f1apMsg->choice.initiatingMessage == NULLP)
12367       {
12368          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseReq(): Memory allocation failed for\
12369          initiatingMessage");
12370          break;
12371       }
12372       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_UEContextReleaseRequest;
12373       f1apMsg->choice.initiatingMessage->criticality = Criticality_reject;
12374       f1apMsg->choice.initiatingMessage->value.present = \
12375       InitiatingMessage__value_PR_UEContextReleaseRequest;
12376
12377       ueReleaseReq = &f1apMsg->choice.initiatingMessage->value.choice.UEContextReleaseRequest;
12378
12379       elementCnt = 2;
12380
12381       ueReleaseReq->protocolIEs.list.count = elementCnt;
12382       ueReleaseReq->protocolIEs.list.size = elementCnt * sizeof(UEContextReleaseRequest_t *);
12383
12384       /* Initialize the F1Setup members */
12385       DU_ALLOC(ueReleaseReq->protocolIEs.list.array,ueReleaseReq->protocolIEs.list.size);
12386       if(ueReleaseReq->protocolIEs.list.array == NULLP)
12387       {
12388          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseReq(): Memory allocation failed for IE array");
12389          break;
12390       }
12391       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
12392       {
12393          DU_ALLOC(ueReleaseReq->protocolIEs.list.array[ieIdx],\
12394                sizeof(UEContextReleaseRequest_t));
12395          if(ueReleaseReq->protocolIEs.list.array[ieIdx] == NULLP)
12396          {
12397             DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseReq(): Memory allocation failed for IE elements");
12398             memAllocFail = true;
12399             break;
12400          }
12401       }
12402       if(memAllocFail == true)
12403          break;
12404
12405       /* Fetching Ue Cb Info*/
12406       GET_CELL_IDX(cellId, cellIdx);
12407       if(duCb.actvCellLst[cellIdx] == NULLP)
12408       {
12409          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseReq(): CellId[%d] does not exist", cellId);
12410          break;
12411       }
12412       else
12413       {
12414          GET_CRNTI(crnti, ueIdx);
12415          if(duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].crnti != crnti)
12416          {
12417             DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseReq(): crnti[%d] does not exist", crnti);
12418             break;
12419          }
12420          gnbDuUeF1apId = duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].gnbDuUeF1apId;
12421          gnbCuUeF1apId = duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].gnbCuUeF1apId;
12422       }
12423
12424       ieIdx=0;
12425       ueReleaseReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
12426       ueReleaseReq->protocolIEs.list.array[ieIdx]->criticality= Criticality_reject;
12427       ueReleaseReq->protocolIEs.list.array[ieIdx]->value.present = \
12428       UEContextReleaseRequestIEs__value_PR_GNB_CU_UE_F1AP_ID;
12429       ueReleaseReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID =gnbCuUeF1apId;
12430
12431       ieIdx++;
12432       ueReleaseReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
12433       ueReleaseReq->protocolIEs.list.array[ieIdx]->criticality= Criticality_reject;
12434       ueReleaseReq->protocolIEs.list.array[ieIdx]->value.present =\
12435       UEContextReleaseRequestIEs__value_PR_GNB_DU_UE_F1AP_ID;
12436       ueReleaseReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID =gnbDuUeF1apId;
12437
12438       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
12439
12440       /* Encode the F1SetupRequest type as APER */
12441       memset(encBuf, 0, ENC_BUF_MAX_LEN);
12442       encBufSize = 0;
12443       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
12444       /* Encode results */
12445       if(encRetVal.encoded == ENCODE_FAIL)
12446       {
12447          DU_LOG("\nERROR  -->  F1AP : Could not encode UEContextReleaseRequest structure (at %s)\n",\
12448                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
12449          break;
12450       }
12451       else
12452       {
12453          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for UEContextReleaseRequest\n");
12454          for(ieIdx=0; ieIdx< encBufSize; ieIdx++)
12455          {
12456             printf("%x",encBuf[ieIdx]);
12457          }
12458       }
12459
12460       /* Sending msg */
12461       if(sendF1APMsg() != ROK)
12462       {
12463          DU_LOG("\nERROR  -->  F1AP : Sending UE Context Release Request failed");
12464          break;
12465       }
12466       ret = ROK;
12467       break;
12468    }while(true);
12469
12470    FreeUeContextReleaseReq(f1apMsg);
12471    return ret;
12472 }
12473 /*****************************************************************i
12474  *
12475  * @brief Free memory allocated for UE Context Release Complete
12476  *
12477  * @details
12478  *
12479  *    Function : FreeUeContextReleaseComplete
12480  *
12481  *    Functionality:
12482  *         - Free memory allocated for UE Context Release Complete
12483  *
12484  * @params[in] F1AP_PDU_t *f1apMsg
12485  * @return void
12486  *
12487  * *************************************************************/
12488 void FreeUeContextReleaseComplete(F1AP_PDU_t *f1apMsg)
12489 {
12490    uint8_t ieIdx;
12491    UEContextReleaseComplete_t *ueReleaseComplete = NULLP;
12492
12493    if(f1apMsg)
12494    {
12495       if(f1apMsg->choice.successfulOutcome)
12496       {
12497          ueReleaseComplete =&f1apMsg->choice.successfulOutcome->value.choice.UEContextReleaseComplete;
12498          if(ueReleaseComplete->protocolIEs.list.array)
12499          {
12500             for(ieIdx=0 ; ieIdx<ueReleaseComplete->protocolIEs.list.count; ieIdx++)
12501             {
12502                DU_FREE(ueReleaseComplete->protocolIEs.list.array[ieIdx], sizeof(UEContextReleaseComplete_t));
12503             }
12504             DU_FREE(ueReleaseComplete->protocolIEs.list.array, ueReleaseComplete->protocolIEs.list.size);
12505          }
12506          DU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
12507       }
12508       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
12509    }
12510
12511 }
12512 /*****************************************************************i
12513  *
12514  * @brief Build and Send UE Context Release Complete
12515  *
12516  * @details
12517  *
12518  *    Function : BuildAndSendUeContextReleaseComplete
12519  *
12520  *    Functionality:
12521  *         - Build and Send UE Context Release Complete
12522  *
12523  * @params[in]
12524  * @return ROK     - success
12525  *         RFAILED - failure
12526  *
12527  * *************************************************************/
12528 uint8_t BuildAndSendUeContextReleaseComplete(uint32_t  gnbCuUeF1apId, uint32_t  gnbDuUeF1apId)
12529 {
12530    bool memAllocFail = false;
12531    uint8_t ieIdx =0, ret = RFAILED, elementCnt = 0;
12532    asn_enc_rval_t encRetVal;
12533    F1AP_PDU_t *f1apMsg = NULLP;
12534    UEContextReleaseComplete_t *ueReleaseComplete = NULLP;
12535
12536    DU_LOG("\nINFO  --> Building the UE Context Release Complete");
12537    do
12538    {
12539       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
12540       if(f1apMsg == NULLP)
12541       {
12542          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseComplete(): Memory allocation failed for f1apMsg");
12543          break;
12544       }
12545
12546       f1apMsg->present = F1AP_PDU_PR_successfulOutcome;
12547       DU_ALLOC(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
12548       if(f1apMsg->choice.successfulOutcome == NULLP)
12549       {
12550          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseComplete(): Memory allocation failed for\
12551                successfulOutcome");
12552          break;
12553       }
12554       f1apMsg->choice.successfulOutcome->procedureCode = ProcedureCode_id_UEContextRelease;
12555       f1apMsg->choice.successfulOutcome->criticality = Criticality_reject;
12556       f1apMsg->choice.successfulOutcome->value.present = \
12557       SuccessfulOutcome__value_PR_UEContextReleaseComplete;
12558
12559       ueReleaseComplete = &f1apMsg->choice.successfulOutcome->value.choice.UEContextReleaseComplete;
12560
12561       elementCnt = 2;
12562       ueReleaseComplete->protocolIEs.list.count = elementCnt;
12563       ueReleaseComplete->protocolIEs.list.size = elementCnt * sizeof(UEContextReleaseComplete_t *);
12564
12565       /* Initialize the UE Release Complete members */
12566       DU_ALLOC(ueReleaseComplete->protocolIEs.list.array,ueReleaseComplete->protocolIEs.list.size);
12567       if(ueReleaseComplete->protocolIEs.list.array == NULLP)
12568       {
12569          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseComplete(): Memory allocation failed for IE array");
12570          break;
12571       }
12572       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
12573       {
12574          DU_ALLOC(ueReleaseComplete->protocolIEs.list.array[ieIdx],\
12575                sizeof(UEContextReleaseComplete_t));
12576          if(ueReleaseComplete->protocolIEs.list.array[ieIdx] == NULLP)
12577          {
12578             DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseComplete(): Memory allocation failed for IE\
12579             elements");
12580             memAllocFail = true;
12581             break;
12582          }
12583       }
12584       if(memAllocFail == true)
12585          break;
12586
12587
12588       ieIdx=0;
12589       ueReleaseComplete->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
12590       ueReleaseComplete->protocolIEs.list.array[ieIdx]->criticality= Criticality_reject;
12591       ueReleaseComplete->protocolIEs.list.array[ieIdx]->value.present = \
12592       UEContextReleaseCompleteIEs__value_PR_GNB_CU_UE_F1AP_ID;
12593       ueReleaseComplete->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID =gnbCuUeF1apId;
12594
12595       ieIdx++;
12596       ueReleaseComplete->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
12597       ueReleaseComplete->protocolIEs.list.array[ieIdx]->criticality= Criticality_reject;
12598       ueReleaseComplete->protocolIEs.list.array[ieIdx]->value.present =\
12599       UEContextReleaseCompleteIEs__value_PR_GNB_DU_UE_F1AP_ID;
12600       ueReleaseComplete->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID =gnbDuUeF1apId;
12601
12602       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
12603
12604       /* Encode the F1SetupComplete type as APER */
12605       memset(encBuf, 0, ENC_BUF_MAX_LEN);
12606       encBufSize = 0;
12607       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
12608       /* Encode results */
12609       if(encRetVal.encoded == ENCODE_FAIL)
12610       {
12611          DU_LOG("\nERROR  -->  F1AP : Could not encode UEContextReleaseComplete structure (at %s)\n",\
12612                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
12613          break;
12614       }
12615       else
12616       {
12617          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for UEContextReleaseComplete\n");
12618          for(ieIdx=0; ieIdx< encBufSize; ieIdx++)
12619          {
12620             printf("%x",encBuf[ieIdx]);
12621          }
12622       }
12623
12624       /* Sending msg */
12625       if(sendF1APMsg() != ROK)
12626       {
12627          DU_LOG("\nERROR  -->  F1AP : Sending UE Context Release Complete failed");
12628          break;
12629       }
12630       ret = ROK;
12631       break;
12632    }while(true);
12633
12634    FreeUeContextReleaseComplete(f1apMsg);
12635    return ret;
12636
12637    /*TODO: To add trigger for UE context release complete, once the operations of UE context
12638     * release command are done*/
12639 }
12640 /*******************************************************************
12641 *
12642 * @brief added free part for the memory allocated by aper_decoder
12643 *
12644 * @details
12645 *
12646 *    Function : freeAperDecodeUeContextReleaseCommand
12647 *
12648 *    Functionality: added free part for the memory allocated by aper_decoder
12649 *
12650 * @params[in] F1AP_PDU_t *f1apMsg
12651 * @return void
12652 *
12653 * ****************************************************************/
12654 void freeAperDecodeUeContextReleaseCommand(F1AP_PDU_t *f1apMsg)
12655 {
12656    uint8_t ieIdx=0;
12657    UEContextReleaseCommand_t *ueContextReleaseCommand = NULLP;
12658
12659    ueContextReleaseCommand = &f1apMsg->choice.initiatingMessage->value.choice.UEContextReleaseCommand;
12660
12661    if(ueContextReleaseCommand->protocolIEs.list.array)
12662    {
12663       for(ieIdx=0; ieIdx < ueContextReleaseCommand->protocolIEs.list.count; ieIdx++)
12664       {
12665          if(ueContextReleaseCommand->protocolIEs.list.array[ieIdx])
12666          {
12667             switch(ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->id)
12668             {
12669                case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
12670                   break;
12671                case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
12672                   break;
12673                case ProtocolIE_ID_id_Cause:
12674                   break;
12675                case ProtocolIE_ID_id_RRCContainer:
12676                {
12677                   if(ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf)
12678                   {
12679                      free(ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf);
12680                   }
12681                   break;
12682                }
12683                default :
12684                   DU_LOG("\nERROR  -->  F1AP: freeAperDecodeUeContextReleaseCommand():Invalid IE Received: %ld"\
12685                        ,ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->id);
12686                   break;
12687             }
12688          }
12689          free(ueContextReleaseCommand->protocolIEs.list.array[ieIdx]);
12690       }
12691       free(ueContextReleaseCommand->protocolIEs.list.array);
12692    }
12693 }
12694 /*******************************************************************
12695 *
12696 * @brief processing of UE Context Release Command
12697 *
12698 * @details
12699 *
12700 *    Function : procF1UeContextReleaseCommand
12701 *
12702 *    Functionality: processing of UE Context Release Command
12703 *
12704 * @params[in] F1AP_PDU_t *f1apMsg
12705 * @return void
12706 *
12707 * ****************************************************************/
12708 uint8_t procF1UeContextReleaseCommand(F1AP_PDU_t *f1apMsg)
12709 {
12710    /*TODO: processing of DL RRC Msg Transfer to RLC->SCH->MAC-LOWER-MAC->PHY, if RRC container is received */
12711
12712    freeAperDecodeUeContextReleaseCommand(f1apMsg);
12713    return ROK;
12714 }
12715 /**************************************************************
12716  *
12717  * @brief Handles received F1AP message and sends back response
12718  *
12719  * @details
12720  *
12721  *    Function : F1APMsgHdlr
12722  *
12723  *    Functionality:
12724  *         - Decodes received F1AP control message
12725  *         - Prepares response message, encodes and sends to SCTP
12726  *
12727  * @params[in]
12728  * @return ROK     - success
12729  *         RFAILED - failure
12730  *
12731  * ****************************************************************/
12732 void F1APMsgHdlr(Buffer *mBuf)
12733 {
12734    int i =0;
12735    char *recvBuf =NULLP;
12736    MsgLen copyCnt =0;
12737    MsgLen recvBufLen =0;
12738    F1AP_PDU_t *f1apMsg =NULLP;
12739    asn_dec_rval_t rval; /* Decoder return value */
12740    F1AP_PDU_t f1apasnmsg ;
12741    DU_LOG("\nINFO  -->  F1AP : Received F1AP message buffer");
12742    ODU_PRINT_MSG(mBuf, 0,0);
12743
12744    /* Copy mBuf into char array to decode it */
12745    ODU_GET_MSG_LEN(mBuf, &recvBufLen);
12746    DU_ALLOC(recvBuf, (Size)recvBufLen);
12747
12748    if(recvBuf == NULLP)
12749    {
12750       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed");
12751       return;
12752    }
12753    if(ODU_COPY_MSG_TO_FIX_BUF(mBuf, 0, recvBufLen, (Data *)recvBuf, &copyCnt) != ROK)
12754    {
12755       DU_LOG("\nERROR   -->  F1AP : Failed while copying %d", copyCnt);
12756       return;
12757    }
12758
12759    printf("\nDEBUG   -->  F1AP : Received flat buffer to be decoded : ");
12760    for(i=0; i< recvBufLen; i++)
12761    {
12762       printf("%x",recvBuf[i]);
12763    }
12764
12765    /* Decoding flat buffer into F1AP messsage */
12766    f1apMsg = &f1apasnmsg;
12767    memset(f1apMsg, 0, sizeof(F1AP_PDU_t));
12768
12769    rval = aper_decode(0, &asn_DEF_F1AP_PDU, (void **)&f1apMsg, recvBuf, recvBufLen, 0, 0);
12770    DU_FREE(recvBuf, (Size)recvBufLen);
12771
12772    if(rval.code == RC_FAIL || rval.code == RC_WMORE)
12773    {
12774       DU_LOG("\nERROR  -->  F1AP : ASN decode failed");
12775       return;
12776    }
12777    printf("\n");
12778    xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
12779
12780    switch(f1apMsg->present)
12781    {
12782       case F1AP_PDU_PR_successfulOutcome:
12783          {
12784             switch(f1apMsg->choice.successfulOutcome->value.present)
12785             {
12786                case SuccessfulOutcome__value_PR_ResetAcknowledge:
12787                   {
12788                      DU_LOG("\nINFO   -->  F1AP : F1ResetAcknowledge is received successfully ");
12789                      break;
12790                   }
12791                case SuccessfulOutcome__value_PR_F1SetupResponse:
12792                   {
12793 #ifndef ODU_TEST_STUB
12794                      procF1SetupRsp(f1apMsg);
12795 #endif
12796                      break;
12797                   }
12798
12799                case SuccessfulOutcome__value_PR_GNBDUConfigurationUpdateAcknowledge:
12800                   {
12801                      procF1GNBDUCfgUpdAck(f1apMsg);
12802                      break;
12803                   }
12804
12805                default:
12806                   {
12807                      DU_LOG("\nERROR  -->  F1AP : Invalid type of SuccessfulOutcome__value_PR_ResetAcknowledge [%d]",\
12808                            f1apMsg->choice.successfulOutcome->value.present);
12809                      return;
12810                   }
12811             }/* End of switch(successfulOutcome) */
12812             free(f1apMsg->choice.successfulOutcome);
12813             break;
12814          }
12815       case F1AP_PDU_PR_initiatingMessage:
12816          {
12817             switch(f1apMsg->choice.initiatingMessage->value.present)
12818             {
12819                case InitiatingMessage__value_PR_Reset:
12820                   {
12821                      procF1ResetReq(f1apMsg);
12822                      break;
12823                   }
12824                case InitiatingMessage__value_PR_DLRRCMessageTransfer:
12825                   {
12826                      procF1DlRrcMsgTrans(f1apMsg);
12827                      break;
12828                   }
12829                case InitiatingMessage__value_PR_UEContextSetupRequest:
12830                   {
12831                      procF1UeContextSetupReq(f1apMsg);
12832                      break;
12833                   }
12834                case InitiatingMessage__value_PR_UEContextModificationRequest:
12835                   {
12836                      procF1UeContextModificationReq(f1apMsg);
12837                      break;
12838                   }
12839                case InitiatingMessage__value_PR_UEContextReleaseCommand:
12840                   {
12841                       procF1UeContextReleaseCommand(f1apMsg);
12842                       break;
12843                   }
12844                default:
12845                   {
12846                      DU_LOG("\nERROR  -->  F1AP : Invalid type of F1AP_PDU_PR_initiatingMessage [%d]",
12847                            f1apMsg->choice.initiatingMessage->value.present);
12848                      return;
12849                   }
12850             }/* End of switch(initiatingMessage) */
12851             free(f1apMsg->choice.initiatingMessage);
12852             break;
12853          }
12854
12855       default:
12856          {
12857             DU_LOG("\nERROR  -->  F1AP : Invalid type of f1apMsg->present [%d]",f1apMsg->present);
12858             return;
12859          }
12860          free(f1apMsg);
12861
12862    }/* End of switch(f1apMsg->present) */
12863
12864 } /* End of F1APMsgHdlr */
12865
12866 /**********************************************************************
12867   End of file
12868  **********************************************************************/