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
 107 #include "Config.h"
 108 extern StartupConfig g_cfg;
 109
 110 #endif
 111
 112 DuCfgParams duCfgParam;
 113
 114 /************************************************************************
 115  *
 116  * @brief Converts enum values into actual value of Poll retransmit timer
 117  *
 118  * @details
 119  *
 120  *    Function : getPollPdu
 121  *
 122  *    Functionality: Converts enum values into actual value of poll
 123  *    retransmit timer
 124  *
 125  * @params[in] Enum value of pollPdu
 126  * @return Actual value of pollPdu
 127  *
 128  * **********************************************************************/
 129
 130 uint16_t getPollRetxTmr(uint8_t pollRetxTmrCfg)
 131 {
 132    uint16_t pollRetxTmr;
 133
 134    /* All values of poll retx timer are at interval of 5ms.
 135     * This is valid upto 250ms
 136     * Hence converting the enum value to actual value by multiplying it to 5
 137     */
 138    if(pollRetxTmrCfg <= T_PollRetransmit_ms250)
 139       pollRetxTmr = (pollRetxTmrCfg + 1) * 5;
 140    else
 141    {
 142       switch(pollRetxTmrCfg)
 143       {
 144          case T_PollRetransmit_ms300:
 145             pollRetxTmr = 300;
 146             break;
 147          case T_PollRetransmit_ms350:
 148             pollRetxTmr = 350;
 149             break;
 150          case T_PollRetransmit_ms400:
 151             pollRetxTmr = 400;
 152             break;
 153          case T_PollRetransmit_ms450:
 154             pollRetxTmr = 450;
 155             break;
 156          case T_PollRetransmit_ms500:
 157             pollRetxTmr = 500;
 158             break;
 159          case T_PollRetransmit_ms800:
 160             pollRetxTmr = 800;
 161             break;
 162          default:
 163             DU_LOG("\nERROR  -->  F1AP: Invalid value of Poll Retransmit timer");
 164             pollRetxTmr = 0;
 165       }
 166    }
 167    return pollRetxTmr;
 168 }
 169
 170 /*******************************************************************
 171  *
 172  * @brief Converts enum values into actual value of PollPdu
 173  *
 174  * @details
 175  *
 176  *    Function : getPollPdu
 177  *
 178  *    Functionality: Converts enum values into actual value of PollPdu
 179  *
 180  * @params[in] Enum value of pollPdu
 181  * @return Actual value of pollPdu
 182  *
 183  * ****************************************************************/
 184 int32_t getPollPdu(uint8_t pollPduCfg)
 185 {
 186    int32_t pollPdu;
 187    switch(pollPduCfg)
 188    {
 189       case PollPDU_p4:
 190          pollPdu = 4;
 191          break;
 192       case PollPDU_p8:
 193          pollPdu = 8;
 194          break;
 195       case PollPDU_p16:
 196          pollPdu = 16;
 197          break;
 198       case PollPDU_p32:
 199          pollPdu = 32;
 200          break;
 201       case PollPDU_p64:
 202          pollPdu = 64;
 203          break;
 204       case PollPDU_p128:
 205          pollPdu = 128;
 206          break;
 207       case PollPDU_p256:
 208          pollPdu = 256;
 209          break;
 210       case PollPDU_p512:
 211          pollPdu = 512;
 212          break;
 213       case PollPDU_p1024:
 214          pollPdu = 1024;
 215          break;
 216       case PollPDU_p2048:
 217          pollPdu = 2048;
 218          break;
 219       case PollPDU_p4096:
 220          pollPdu = 4096;
 221          break;
 222       case PollPDU_p6144:
 223          pollPdu = 6144;
 224          break;
 225       case PollPDU_p8192:
 226          pollPdu = 8192;
 227          break;
 228       case PollPDU_p12288:
 229          pollPdu = 12288;
 230          break;
 231       case PollPDU_p16384:
 232          pollPdu = 16384;
 233          break;
 234       case PollPDU_p20480:
 235          pollPdu = 20480;
 236          break;
 237       case PollPDU_p24576:
 238          pollPdu = 24576;
 239          break;
 240       case PollPDU_p28672:
 241          pollPdu = 28672;
 242          break;
 243       case PollPDU_p32768:
 244          pollPdu = 32768;
 245          break;
 246       case PollPDU_p40960:
 247          pollPdu = 40960;
 248          break;
 249       case PollPDU_p49152:
 250          pollPdu = 49152;
 251          break;
 252       case PollPDU_p57344:
 253          pollPdu = 57344;
 254          break;
 255       case PollPDU_p65536:
 256          pollPdu = 65536;
 257          break;
 258       case PollPDU_infinity:
 259          pollPdu = -1;
 260          break;
 261       default:
 262          DU_LOG("\nERROR  -->  F1AP: Invalid value of poll pdu");
 263          pollPdu = 0;
 264          break;
 265    }
 266    return pollPdu;
 267 }
 268
 269 /*******************************************************************
 270  *
 271  * @brief Converts enum values into actual value of poll bytes
 272  *
 273  * @details
 274  *
 275  *    Function : getPollByte
 276  *
 277  *    Functionality: Converts enum values into actual value of pollBytes
 278  *
 279  * @params[in] Enum value
 280  * @return Actual value
 281  *
 282  * ****************************************************************/
 283 int32_t getPollByte(uint16_t pollBytesCfg)
 284 {
 285    int32_t pollBytes;
 286    switch(pollBytesCfg)
 287    {
 288       case PollByte_kB1:
 289          pollBytes = 1000;
 290          break;
 291       case PollByte_kB2:
 292          pollBytes = 2000;
 293          break;
 294       case PollByte_kB5:
 295          pollBytes = 5000;
 296          break;
 297       case PollByte_kB8:
 298          pollBytes = 8000;
 299          break;
 300       case PollByte_kB10:
 301          pollBytes = 10000;
 302          break;
 303       case PollByte_kB15:
 304          pollBytes = 15000;
 305          break;
 306       case PollByte_kB25:
 307          pollBytes = 25000;
 308          break;
 309       case PollByte_kB50:
 310          pollBytes = 50000;
 311          break;
 312       case PollByte_kB75:
 313          pollBytes = 75000;
 314          break;
 315       case PollByte_kB100:
 316          pollBytes = 100000;
 317          break;
 318       case PollByte_kB125:
 319          pollBytes = 125000;
 320          break;
 321       case PollByte_kB250:
 322          pollBytes = 250000;
 323          break;
 324       case PollByte_kB375:
 325          pollBytes = 375000;
 326          break;
 327       case PollByte_kB500:
 328          pollBytes = 500000;
 329          break;
 330       case PollByte_kB750:
 331          pollBytes = 750000;
 332          break;
 333       case PollByte_kB1000:
 334          pollBytes = 1000000;
 335          break;
 336       case PollByte_kB1250:
 337          pollBytes = 1250000;
 338          break;
 339       case PollByte_kB1500:
 340          pollBytes = 1500000;
 341          break;
 342       case PollByte_kB2000:
 343          pollBytes = 2000000;
 344          break;
 345       case PollByte_kB3000:
 346          pollBytes = 3000000;
 347          break;
 348       case PollByte_kB4000:
 349          pollBytes = 4000000;
 350          break;
 351       case PollByte_kB4500:
 352          pollBytes = 4500000;
 353          break;
 354       case PollByte_kB5000:
 355          pollBytes = 5000000;
 356          break;
 357       case PollByte_kB5500:
 358          pollBytes = 5500000;
 359          break;
 360       case PollByte_kB6000:
 361          pollBytes = 6000000;
 362          break;
 363       case PollByte_kB6500:
 364          pollBytes = 6500000;
 365          break;
 366       case PollByte_kB7000:
 367          pollBytes = 7000000;
 368          break;
 369       case PollByte_kB7500:
 370          pollBytes = 7500000;
 371          break;
 372       case PollByte_mB8:
 373          pollBytes = 8000000;
 374          break;
 375       case PollByte_mB9:
 376          pollBytes = 9000000;
 377          break;
 378       case PollByte_mB10:
 379          pollBytes = 10000000;
 380          break;
 381       case PollByte_mB11:
 382          pollBytes = 11000000;
 383          break;
 384       case PollByte_mB12:
 385          pollBytes = 12000000;
 386          break;
 387       case PollByte_mB13:
 388          pollBytes = 13000000;
 389          break;
 390       case PollByte_mB14:
 391          pollBytes = 14000000;
 392          break;
 393       case PollByte_mB15:
 394          pollBytes = 15000000;
 395          break;
 396       case PollByte_mB16:
 397          pollBytes = 16000000;
 398          break;
 399       case PollByte_mB17:
 400          pollBytes = 17000000;
 401          break;
 402       case PollByte_mB18:
 403          pollBytes = 18000000;
 404          break;
 405       case PollByte_mB20:
 406          pollBytes = 20000000;
 407          break;
 408       case PollByte_mB25:
 409          pollBytes = 25000000;
 410          break;
 411       case PollByte_mB30:
 412          pollBytes = 30000000;
 413          break;
 414       case PollByte_mB40:
 415          pollBytes = 40000000;
 416          break;
 417       case PollByte_infinity:
 418          pollBytes = -1;
 419          break;
 420       default:
 421          DU_LOG("\nERROR  -->  F1AP: Invalid value of poll bytes");
 422          pollBytes = 0;
 423    }
 424    return pollBytes;
 425 }
 426
 427 /*******************************************************************
 428  *
 429  * @brief Converts enum values into actual value of maxRetx
 430  *
 431  * @details
 432  *
 433  *    Function : getMaxRetx
 434  *
 435  *    Functionality: Converts enum values into actual value of maxRetx
 436  *
 437  * @params[in] Enum value
 438  * @return Actual value
 439  *
 440  * ****************************************************************/
 441 uint8_t getMaxRetx(uint8_t maxRetxCfg)
 442 {
 443    uint8_t maxRetx;
 444    switch(maxRetxCfg)
 445    {
 446       case UL_AM_RLC__maxRetxThreshold_t1:
 447          maxRetx = 1;
 448          break;
 449       case UL_AM_RLC__maxRetxThreshold_t2:
 450          maxRetx = 2;
 451          break;
 452       case UL_AM_RLC__maxRetxThreshold_t3:
 453          maxRetx = 3;
 454          break;
 455       case UL_AM_RLC__maxRetxThreshold_t4:
 456          maxRetx = 4;
 457          break;
 458       case UL_AM_RLC__maxRetxThreshold_t6:
 459          maxRetx = 6;
 460          break;
 461       case UL_AM_RLC__maxRetxThreshold_t8:
 462          maxRetx = 8;
 463          break;
 464       case UL_AM_RLC__maxRetxThreshold_t16:
 465          maxRetx = 16;
 466          break;
 467       case UL_AM_RLC__maxRetxThreshold_t32:
 468          maxRetx = 32;
 469          break;
 470       default:
 471          DU_LOG("\nERROR  -->  F1AP: Invalid configuration for Max retransmission threshold");
 472          maxRetx = 0;
 473    }
 474    return maxRetx;
 475 }
 476
 477 /*******************************************************************
 478  * @brief Converts enum values into actual value of reassembly timer
 479  *
 480  * @details
 481  *
 482  *    Function : getReAsmblTmr
 483  *
 484  *    Functionality: Converts enum values into actual value of reassembly
 485  *    timer
 486  *
 487  * @params[in] Enum value of reassembly timer
 488  * @return Actual value of reassembly timer
 489  *
 490  * **********************************************************************/
 491
 492 int8_t getReAsmblTmr(uint8_t reAsmblTmrCfg)
 493 {
 494    int8_t reAsmblTmr = 0;
 495
 496    if(reAsmblTmrCfg == T_Reassembly_ms0)
 497    {
 498       reAsmblTmr = 0;
 499    }
 500    else if(reAsmblTmrCfg >= T_Reassembly_ms5 || reAsmblTmrCfg <= T_Reassembly_ms100)
 501    {
 502      /* All values of re assembly timer are at interval of 5ms.
 503       * This is valid upto 100ms
 504       * Hence converting the enum value to actual value by multiplying it to 5
 505       */
 506       reAsmblTmr = reAsmblTmrCfg * 5;
 507    }
 508    else if(reAsmblTmrCfg >= T_Reassembly_ms110 || reAsmblTmrCfg <= T_Reassembly_ms200)
 509    {
 510      /* All values of re assembly timer are at interval of 10ms.
 511       * This is valid upto 200ms
 512       * since enum value starts from 20 for 100ms, subtracting 10 and
 513       * converting the enum value to actual value by multiplying it to 10
 514       */
 515       reAsmblTmr = ((reAsmblTmrCfg-10) * 10);
 516    }
 517    else
 518    {
 519       DU_LOG("\nERROR  -->  F1AP : Invalid value of Re Assembly timer %d", reAsmblTmrCfg);
 520       reAsmblTmr = -1;
 521    }
 522    return reAsmblTmr;
 523 }
 524
 525 /************************************************************************
 526  *
 527  * @brief Converts enum values into actual value of status prohibit timer
 528  *
 529  * @details
 530  *
 531  *    Function : getStatProhTmr
 532  *
 533  *    Functionality: Converts enum values into actual value of status prohibit
 534  *    timer
 535  *
 536  * @params[in] Enum value of status prohibit timer
 537  * @return Actual value of status prohibit timer
 538  *
 539  * **********************************************************************/
 540
 541 int16_t getStatProhTmr(uint8_t statProhTmrCfg)
 542 {
 543    int16_t statProhTmr =0;
 544
 545    if(statProhTmrCfg == T_StatusProhibit_ms0)
 546    {
 547       statProhTmr = 0;
 548    }
 549    else if(statProhTmrCfg >= T_StatusProhibit_ms5 || statProhTmrCfg <= T_StatusProhibit_ms250)
 550    {
 551       /* All values of re assembly timer are at interval of 5ms.
 552        * This is valid upto 250ms
 553        * Hence converting the enum value to actual value by multiplying it to 5
 554        */
 555       statProhTmr = statProhTmrCfg * 5;
 556    }
 557    else
 558    {
 559       switch(statProhTmrCfg)
 560       {
 561          case T_StatusProhibit_ms300:
 562             statProhTmr = 300;
 563             break;
 564          case T_StatusProhibit_ms350:
 565             statProhTmr = 350;
 566             break;
 567          case T_StatusProhibit_ms400:
 568             statProhTmr = 400;
 569             break;
 570          case T_StatusProhibit_ms450:
 571             statProhTmr = 450;
 572             break;
 573          case T_StatusProhibit_ms500:
 574             statProhTmr = 500;
 575             break;
 576          case T_StatusProhibit_ms800:
 577             statProhTmr = 800;
 578             break;
 579          case T_StatusProhibit_ms1000:
 580             statProhTmr = 1000;
 581             break;
 582          case T_StatusProhibit_ms1200:
 583             statProhTmr = 1200;
 584             break;
 585          case T_StatusProhibit_ms1600:
 586             statProhTmr = 1600;
 587             break;
 588          case T_StatusProhibit_ms2000:
 589             statProhTmr = 2000;
 590             break;
 591          case T_StatusProhibit_ms2400:
 592             statProhTmr = 2400;
 593             break;
 594          default:
 595             DU_LOG("\nInvalid value of Status Prohibit timer %d", statProhTmrCfg);
 596             statProhTmr = -1;
 597             break;
 598       }
 599    }
 600    return statProhTmr;
 601 }
 602
 603 /*******************************************************************
 604  *
 605  * @brief Builds Uplink Info for NR
 606  *
 607  * @details
 608  *
 609  *    Function : BuildULNRInfo
 610  *
 611  *    Functionality: Building NR Uplink Info
 612  *
 613  * @params[in] NRFreqInfo_t *ulnrfreq
 614  * @return ROK     - success
 615  *         RFAILED - failure
 616  *
 617  * ****************************************************************/
 618 uint8_t BuildULNRInfo(NRFreqInfo_t *ulnrfreq)
 619 {
 620    uint8_t idx=0;
 621    ulnrfreq->nRARFCN = duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.\
 622                        fdd.ulNrFreqInfo.nrArfcn;
 623    ulnrfreq->freqBandListNr.list.count = 1;
 624    ulnrfreq->freqBandListNr.list.size = sizeof(FreqBandNrItem_t *);
 625    DU_ALLOC(ulnrfreq->freqBandListNr.list.array,ulnrfreq->freqBandListNr.list.size);
 626    if(ulnrfreq->freqBandListNr.list.array == NULLP)
 627    {
 628       return RFAILED;
 629    }
 630    for(idx=0;idx<ulnrfreq->freqBandListNr.list.count;idx++)
 631    {
 632       DU_ALLOC(ulnrfreq->freqBandListNr.list.array[idx],sizeof(FreqBandNrItem_t));
 633       if(ulnrfreq->freqBandListNr.list.array[idx] == NULLP)
 634       {
 635          return RFAILED;
 636       }
 637    }
 638    ulnrfreq->freqBandListNr.list.array[0]->freqBandIndicatorNr = \
 639                                                                  duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.fdd.ulNrFreqInfo.\
 640                                                                  freqBand[0].nrFreqBand;
 641    ulnrfreq->freqBandListNr.list.array[0]->supportedSULBandList.list.count = SUL_BAND_COUNT;
 642    return ROK;
 643 }
 644 /*******************************************************************
 645  *
 646  * @brief Builds Downlink NR Info
 647  *
 648  * @details
 649  *
 650  *    Function : BuildDLNRInfo
 651  *
 652  *    Functionality: Building Downlink NR Info
 653  *
 654  * @params[in] NRFreqInfo_t *dlnrfreq
 655  * @return ROK     - success
 656  *         RFAILED - failure
 657  *
 658  * ****************************************************************/
 659 uint8_t BuildDLNRInfo(NRFreqInfo_t *dlnrfreq)
 660 {
 661    uint8_t idx=0;
 662    dlnrfreq->nRARFCN = duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.\
 663                        fdd.dlNrFreqInfo.nrArfcn;
 664    dlnrfreq->freqBandListNr.list.count = 1;
 665    dlnrfreq->freqBandListNr.list.size = sizeof(FreqBandNrItem_t *);
 666    DU_ALLOC(dlnrfreq->freqBandListNr.list.array,dlnrfreq->freqBandListNr.list.size);
 667    if(dlnrfreq->freqBandListNr.list.array == NULLP)
 668    {
 669       return RFAILED;
 670    }
 671    for(idx=0;idx< dlnrfreq->freqBandListNr.list.count;idx++)
 672    {
 673       DU_ALLOC(dlnrfreq->freqBandListNr.list.array[idx],sizeof(FreqBandNrItem_t));
 674       if(dlnrfreq->freqBandListNr.list.array[idx] == NULLP)
 675       {
 676          return RFAILED;
 677       }
 678    }
 679    dlnrfreq->freqBandListNr.list.array[0]->freqBandIndicatorNr = \
 680                                                                  duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.fdd.dlNrFreqInfo.\
 681                                                                  freqBand[0].nrFreqBand;
 682    dlnrfreq->freqBandListNr.list.array[0]->supportedSULBandList.list.count = SUL_BAND_COUNT;
 683
 684    return ROK;
 685 }
 686
 687 /*******************************************************************
 688  *
 689  * @brief Builds NRCell ID
 690  *
 691  * @details
 692  *
 693  *    Function : BuildNrCellId
 694  *
 695  *    Functionality: Building the NR Cell ID
 696  *
 697  * @params[in] BIT_STRING_t *nrcell
 698  * @return ROK     - success
 699  *         RFAILED - failure
 700  *
 701  * ****************************************************************/
 702
 703 S16 BuildNrCellId(BIT_STRING_t *nrcell)
 704 {
 705    memset(nrcell->buf, 0, nrcell->size);
 706    nrcell->buf[4]   = 16;
 707    nrcell->bits_unused = 4;
 708    return ROK;
 709 }
 710
 711 /*******************************************************************
 712  *
 713  * @brief Builds Nrcgi
 714  *
 715  * @details
 716  *
 717  *    Function : BuildNrcgi
 718  *
 719  *    Functionality: Building the PLMN ID and NR Cell id
 720  *
 721  * @params[in] NRCGI_t *nrcgi
 722  * @return ROK     - success
 723  *         RFAILED - failure
 724  *
 725  * ****************************************************************/
 726 uint8_t BuildNrcgi(NRCGI_t *nrcgi)
 727 {
 728    uint8_t ret;
 729    uint8_t byteSize = 5;
 730    /* Allocate Buffer Memory */
 731    nrcgi->pLMN_Identity.size = PLMN_SIZE * sizeof(uint8_t);
 732    DU_ALLOC(nrcgi->pLMN_Identity.buf, nrcgi->pLMN_Identity.size);
 733    if(nrcgi->pLMN_Identity.buf == NULLP)
 734    {
 735       return RFAILED;
 736    }
 737    ret = buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrCgi.plmn,\
 738          nrcgi->pLMN_Identity.buf); // Building PLMN function
 739    if(ret != ROK)
 740    {
 741       return RFAILED;
 742    }
 743    /*nrCellIdentity*/
 744    nrcgi->nRCellIdentity.size = byteSize * sizeof(uint8_t);
 745    DU_ALLOC(nrcgi->nRCellIdentity.buf, nrcgi->nRCellIdentity.size);
 746    if(nrcgi->nRCellIdentity.buf == NULLP)
 747    {
 748       return RFAILED;
 749    }
 750    BuildNrCellId(&nrcgi->nRCellIdentity);
 751
 752    return ROK;
 753 }
 754 /*******************************************************************
 755  *
 756  * @brief Builds FiveGStac
 757  *
 758  * @details
 759  *
 760  *    Function : BuildFiveGSTac
 761  *
 762  *    Functionality: Building the FiveGSTac
 763  *
 764  * @params[in] OCTET_STRING_t *fivegsTac
 765  * @return ROK     - success
 766  *         RFAILED - failure
 767  *
 768  * ****************************************************************/
 769 uint8_t BuildFiveGSTac(Served_Cell_Information_t *servcell)
 770 {
 771    DU_ALLOC(servcell->fiveGS_TAC,sizeof(FiveGS_TAC_t));
 772    if(servcell->fiveGS_TAC == NULLP)
 773    {
 774       return RFAILED;
 775    }
 776    servcell->fiveGS_TAC->size = 3 * sizeof(uint8_t);
 777    DU_ALLOC(servcell->fiveGS_TAC->buf,\
 778          sizeof(servcell->fiveGS_TAC->size));
 779    if(servcell->fiveGS_TAC->buf == NULLP)
 780    {
 781       return RFAILED;
 782    }
 783    servcell->fiveGS_TAC->buf[0] = 0;
 784    servcell->fiveGS_TAC->buf[1] = 0;
 785    servcell->fiveGS_TAC->buf[2] = duCfgParam.srvdCellLst[0].duCellInfo.tac;
 786    return ROK;
 787 }
 788 /*******************************************************************
 789  *
 790  * @brief Builds NR Mode
 791  *
 792  * @details
 793  *
 794  *    Function : BuildNrMode
 795  *
 796  *    Functionality: Building the NR Mode
 797  *
 798  * @params[in] NR_Mode_Info_t *fdd
 799  * @return ROK     - success
 800  *         RFAILED - failure
 801  *
 802  * ****************************************************************/
 803 uint8_t BuildNrMode(NR_Mode_Info_t *mode)
 804 {
 805    uint8_t BuildDLNRInforet=0;
 806    uint8_t BuildULNRInforet=0;
 807    /* FDD Mode */
 808    mode->present = NR_Mode_Info_PR_fDD;
 809    if(mode->present == NR_Mode_Info_PR_fDD)
 810    {
 811       DU_ALLOC(mode->choice.fDD,sizeof(FDD_Info_t));
 812       if(mode->choice.fDD == NULLP)
 813       {
 814          return RFAILED;
 815       }
 816       BuildULNRInforet = BuildULNRInfo(&mode->choice.fDD->uL_NRFreqInfo);
 817       if(BuildULNRInforet != ROK)
 818       {
 819          return RFAILED;
 820       }
 821       BuildDLNRInforet = BuildDLNRInfo(&mode->choice.fDD->dL_NRFreqInfo);
 822       if(BuildDLNRInforet != ROK)
 823       {
 824          return RFAILED;
 825       }
 826    }
 827    mode->choice.fDD->uL_Transmission_Bandwidth.nRSCS = \
 828                                                        duCfgParam.srvdCellLst[0].duCellInfo.\
 829                                                        f1Mode.mode.fdd.ulTxBw.nrScs;
 830    mode->choice.fDD->uL_Transmission_Bandwidth.nRNRB = \
 831                                                        duCfgParam.srvdCellLst[0].duCellInfo.\
 832                                                        f1Mode.mode.fdd.ulTxBw.nrb;
 833    mode->choice.fDD->dL_Transmission_Bandwidth.nRSCS = \
 834                                                        duCfgParam.srvdCellLst[0].duCellInfo.\
 835                                                        f1Mode.mode.fdd.dlTxBw.nrScs;
 836    mode->choice.fDD->dL_Transmission_Bandwidth.nRNRB = \
 837                                                        duCfgParam.srvdCellLst[0].duCellInfo.\
 838                                                        f1Mode.mode.fdd.dlTxBw.nrb;
 839    return ROK;
 840 }
 841 /*******************************************************************
 842  *
 843  * @brief Builds IE Extensions for Served PLMNs
 844  *
 845  * @details
 846  *
 847  *    Function : BuildExtensions
 848  *
 849  *    Functionality: Building the IE Extensions
 850  *
 851  * @params[in] struct ProtocolExtensionContainer_4624P3 *buildextend
 852  * @return ROK     - success
 853  *         RFAILED - failure
 854  *
 855  * ****************************************************************/
 856 uint8_t BuildExtensions(ProtocolExtensionContainer_4624P3_t **ieExtend)
 857 {
 858    uint8_t idx;
 859    uint8_t plmnidx;
 860    uint8_t extensionCnt=1;
 861    uint8_t sliceId=0;
 862    uint8_t sdId;
 863    DU_ALLOC(*ieExtend,sizeof(ProtocolExtensionContainer_4624P3_t));
 864    if((*ieExtend) == NULLP)
 865    {
 866       return RFAILED;
 867    }
 868    (*ieExtend)->list.count = extensionCnt;
 869    (*ieExtend)->list.size = \
 870                             extensionCnt * sizeof(ServedPLMNs_ItemExtIEs_t *);
 871    DU_ALLOC((*ieExtend)->list.array,(*ieExtend)->list.size);
 872    if((*ieExtend)->list.array == NULLP)
 873    {
 874       return RFAILED;
 875    }
 876    for(plmnidx=0;plmnidx<extensionCnt;plmnidx++)
 877    {
 878       DU_ALLOC((*ieExtend)->list.array[plmnidx],\
 879             sizeof(ServedPLMNs_ItemExtIEs_t));
 880       if((*ieExtend)->list.array[plmnidx] == NULLP)
 881       {
 882          return RFAILED;
 883       }
 884    }
 885    idx = 0;
 886    (*ieExtend)->list.array[idx]->id = ProtocolIE_ID_id_TAISliceSupportList;
 887    (*ieExtend)->list.array[idx]->criticality = Criticality_ignore;
 888    (*ieExtend)->list.array[idx]->extensionValue.present = \
 889                                                           ServedPLMNs_ItemExtIEs__extensionValue_PR_SliceSupportList;
 890    (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 891       list.count = 1;
 892    (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 893       list.size = sizeof(SliceSupportItem_t *);
 894    DU_ALLOC((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 895          list.array,sizeof(SliceSupportItem_t *));
 896    if((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 897          list.array == NULLP)
 898    {
 899       return RFAILED;
 900    }
 901    DU_ALLOC((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 902          list.array[sliceId],sizeof(SliceSupportItem_t));
 903    if((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 904          list.array[sliceId] == NULLP)
 905    {
 906       return RFAILED;
 907    }
 908    (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 909       list.array[sliceId]->sNSSAI.sST.size = sizeof(uint8_t);
 910    DU_ALLOC((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList\
 911          .list.array[sliceId]->sNSSAI.sST.buf,(*ieExtend)->list.array[idx]->\
 912          extensionValue.choice.SliceSupportList.\
 913          list.array[sliceId]->sNSSAI.sST.size);
 914    if((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList\
 915          .list.array[sliceId]->sNSSAI.sST.buf == NULLP)
 916    {
 917       return RFAILED;
 918    }
 919    (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 920       list.array[sliceId]->sNSSAI.sST.buf[0] = 3;
 921    DU_ALLOC((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 922          list.array[sliceId]->sNSSAI.sD,sizeof(OCTET_STRING_t));
 923    if((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 924          list.array[sliceId]->sNSSAI.sD == NULLP)
 925    {
 926       return RFAILED;
 927    }
 928    (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 929       list.array[sliceId]->sNSSAI.sD->size = 3*sizeof(uint8_t);
 930    DU_ALLOC((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 931          list.array[sliceId]->sNSSAI.sD->buf,(*ieExtend)->list.array[idx]->extensionValue.choice.\
 932          SliceSupportList.list.array[sliceId]->sNSSAI.sD->size);
 933    if((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 934          list.array[sliceId]->sNSSAI.sD->buf == NULLP)
 935    {
 936       return RFAILED;
 937    }
 938    sdId = 0;
 939    (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 940       list.array[sliceId]->sNSSAI.sD->buf[sdId] = 3;
 941    sdId++;
 942    (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 943       list.array[sliceId]->sNSSAI.sD->buf[sdId] = 6;
 944    sdId++;
 945    (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 946       list.array[sliceId]->sNSSAI.sD->buf[sdId] = 9;
 947    return ROK;
 948 }
 949 /*******************************************************************
 950  *
 951  * @brief Builds Served PLMN
 952  *
 953  * @details
 954  *
 955  *    Function : BuildServedPlmn
 956  *
 957  *    Functionality: Building the Served PLMN
 958  *
 959  * @params[in] GNB_DU_Served_Cells_Item_t *srvCellItem
 960  * @return ROK     - success
 961  *         RFAILED - failure
 962  *
 963  * ****************************************************************/
 964 uint8_t  BuildServedPlmn(ServedPLMNs_List_t *srvplmn)
 965 {
 966    uint8_t  plmnidx;
 967    uint8_t  servPlmnCnt=1;
 968    uint8_t buildPlmnIdret=0;
 969    uint8_t BuildExtensionsret=0;
 970    srvplmn->list.count = servPlmnCnt;
 971    srvplmn->list.size = \
 972                         servPlmnCnt*sizeof(ServedPLMNs_Item_t *);
 973    DU_ALLOC(srvplmn->list.array,srvplmn->list.size);
 974    if(srvplmn->list.array == NULLP)
 975    {
 976       return RFAILED;
 977    }
 978    for(plmnidx=0; plmnidx<servPlmnCnt; plmnidx++)
 979    {
 980       DU_ALLOC(srvplmn->list.array[plmnidx],\
 981             sizeof(ServedPLMNs_Item_t));
 982       if(srvplmn->list.array[plmnidx] == NULLP)
 983       {
 984          return RFAILED;
 985       }
 986    }
 987    srvplmn->list.array[0]->pLMN_Identity.size = PLMN_SIZE * sizeof(uint8_t);
 988    DU_ALLOC(srvplmn->list.array[0]->pLMN_Identity.buf, srvplmn->list.array[0]->pLMN_Identity.size);
 989    buildPlmnIdret = buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrCgi.plmn,\
 990          srvplmn->list.array[0]->pLMN_Identity.buf);
 991    if(buildPlmnIdret!= ROK)
 992    {
 993       return RFAILED;
 994    }
 995    BuildExtensionsret = BuildExtensions(&srvplmn->list.array[0]->iE_Extensions);
 996    if(BuildExtensionsret!= ROK)
 997    {
 998       return RFAILED;
 999    }
1000    return ROK;
1001 }
1002 /*******************************************************************
1003  *
1004  * @brief Builds Served Cell List
1005  *
1006  * @details
1007  *
1008  *    Function : BuildServedCellList
1009  *
1010  *    Functionality: Building Served Cell List
1011  *
1012  * @params[in] PLMNID plmn
1013  * @return ROK     - success
1014  *         RFAILED - failure
1015  *
1016  * ****************************************************************/
1017
1018 uint8_t BuildServedCellList(GNB_DU_Served_Cells_List_t *duServedCell)
1019 {
1020    uint8_t  BuildNrcgiret=0;
1021    uint8_t  BuildFiveGSTacret=0;
1022    uint8_t  BuildServedPlmnret=0;
1023    uint8_t  BuildNrModeret=0;
1024    uint8_t  idx;
1025    uint8_t  plmnidx;
1026    uint8_t  plmnCnt=1;
1027    GNB_DU_Served_Cells_Item_t *srvCellItem;
1028    duServedCell->list.size = plmnCnt * sizeof(GNB_DU_Served_Cells_ItemIEs_t *);
1029    duServedCell->list.count = plmnCnt;
1030
1031    DU_ALLOC(duServedCell->list.array, duServedCell->list.size);
1032    if(duServedCell->list.array == NULLP)
1033    {
1034       return RFAILED;
1035    }
1036    for(plmnidx=0; plmnidx<plmnCnt; plmnidx++)
1037    {
1038       DU_ALLOC(duServedCell->list.array[plmnidx],\
1039             sizeof(GNB_DU_Served_Cells_ItemIEs_t));
1040       if(duServedCell->list.array[plmnidx] == NULLP)
1041       {
1042          return RFAILED;
1043       }
1044    }
1045    idx = 0;
1046    duServedCell->list.array[idx]->id = ProtocolIE_ID_id_GNB_DU_Served_Cells_Item;
1047    duServedCell->list.array[idx]->criticality = Criticality_reject;
1048    duServedCell->list.array[idx]->value.present = \
1049                                                   GNB_DU_Served_Cells_ItemIEs__value_PR_GNB_DU_Served_Cells_Item;
1050    srvCellItem = \
1051                  &duServedCell->list.array[idx]->value.choice.GNB_DU_Served_Cells_Item;
1052    /*nRCGI*/
1053    BuildNrcgiret = BuildNrcgi(&srvCellItem->served_Cell_Information.nRCGI);
1054    if(BuildNrcgiret != ROK)
1055    {
1056       return RFAILED;
1057    }
1058    /*nRPCI*/
1059    srvCellItem->served_Cell_Information.nRPCI = \
1060                                                 duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrPci;
1061
1062    /*fiveGS_TAC*/
1063    BuildFiveGSTacret = BuildFiveGSTac(&srvCellItem->served_Cell_Information);
1064    if(BuildFiveGSTacret != ROK)
1065    {
1066       return RFAILED;
1067    }
1068    /*Served PLMNs*/
1069    BuildServedPlmnret = BuildServedPlmn(&srvCellItem->served_Cell_Information.servedPLMNs);
1070    if(BuildServedPlmnret !=ROK)
1071    {
1072       return RFAILED;
1073    }
1074    /*nR Mode Info with FDD*/
1075    BuildNrModeret = BuildNrMode(&srvCellItem->served_Cell_Information.nR_Mode_Info);
1076    if(BuildNrModeret != ROK)
1077    {
1078       return RFAILED;
1079    }
1080    /*Measurement timing Config*/
1081    srvCellItem->served_Cell_Information.measurementTimingConfiguration.\
1082       size = sizeof(uint8_t);
1083    DU_ALLOC(srvCellItem->served_Cell_Information.\
1084          measurementTimingConfiguration.buf,srvCellItem->served_Cell_Information.measurementTimingConfiguration.size);
1085    if(srvCellItem->served_Cell_Information.\
1086          measurementTimingConfiguration.buf == NULLP)
1087    {
1088       return RFAILED;
1089    }
1090    srvCellItem->served_Cell_Information.measurementTimingConfiguration.buf[0] = \
1091                                                                                 duCfgParam.srvdCellLst[0].duCellInfo.measTimeCfg;
1092
1093    /* GNB DU System Information */
1094    DU_ALLOC(srvCellItem->gNB_DU_System_Information,
1095          sizeof(GNB_DU_System_Information_t));
1096    if(!srvCellItem->gNB_DU_System_Information)
1097    {
1098       return RFAILED;
1099    }
1100    /* MIB */
1101    srvCellItem->gNB_DU_System_Information->mIB_message.size = duCfgParam.srvdCellLst[0].duSysInfo.mibLen;
1102    DU_ALLOC(srvCellItem->gNB_DU_System_Information->mIB_message.buf,
1103          srvCellItem->gNB_DU_System_Information->mIB_message.size);
1104    if(!srvCellItem->gNB_DU_System_Information->mIB_message.buf)
1105    {
1106       return RFAILED;
1107    }
1108    memcpy(srvCellItem->gNB_DU_System_Information->mIB_message.buf, duCfgParam.srvdCellLst[0].duSysInfo.mibMsg, \
1109                    srvCellItem->gNB_DU_System_Information->mIB_message.size);
1110
1111    /* SIB1 */
1112    srvCellItem->gNB_DU_System_Information->sIB1_message.size =\
1113                                                               duCfgParam.srvdCellLst[0].duSysInfo.sib1Len;
1114
1115    DU_ALLOC(srvCellItem->gNB_DU_System_Information->sIB1_message.buf,
1116          srvCellItem->gNB_DU_System_Information->sIB1_message.size);
1117    if(!srvCellItem->gNB_DU_System_Information->sIB1_message.buf)
1118    {
1119       return RFAILED;
1120    }
1121    for(int x=0; x<srvCellItem->gNB_DU_System_Information->sIB1_message.size; x++)
1122    {
1123       srvCellItem->gNB_DU_System_Information->sIB1_message.buf[x]=\
1124                                                                   duCfgParam.srvdCellLst[0].duSysInfo.sib1Msg[x];
1125    }
1126    return ROK;
1127 }
1128 /*******************************************************************
1129  *
1130  * @brief Builds RRC Version
1131  *
1132  * @details
1133  *
1134  *    Function : BuildRrcVer
1135  *
1136  *    Functionality: Building RRC Version
1137  *
1138  * @params[in] int idx,int elementCnt,RRC_Version_t *rrcver
1139  * @return ROK     - success
1140  *         RFAILED - failure
1141  *
1142  * ****************************************************************/
1143 uint8_t BuildRrcVer(RRC_Version_t *rrcVer)
1144 {
1145    uint8_t rrcExt;
1146    uint8_t rrcLatest;
1147    rrcVer->latest_RRC_Version.size = sizeof(uint8_t);
1148    DU_ALLOC(rrcVer->latest_RRC_Version.buf,sizeof(uint8_t));
1149    if(rrcVer->latest_RRC_Version.buf == NULLP)
1150    {
1151       return RFAILED;
1152    }
1153    rrcVer->latest_RRC_Version.buf[0] = 0;
1154    rrcVer->latest_RRC_Version.bits_unused = 5;
1155    DU_ALLOC(rrcVer->iE_Extensions,sizeof(ProtocolExtensionContainer_4624P81_t));
1156    if(rrcVer->iE_Extensions == NULLP)
1157    {
1158       return RFAILED;
1159    }
1160    rrcVer->iE_Extensions->list.count = 1;
1161    rrcVer->iE_Extensions->list.size = sizeof(RRC_Version_ExtIEs_t *);
1162    DU_ALLOC(rrcVer->iE_Extensions->list.array,rrcVer->iE_Extensions->list.size);
1163    if(rrcVer->iE_Extensions->list.array == NULLP)
1164    {
1165       return RFAILED;
1166    }
1167    rrcExt = 0;
1168    DU_ALLOC(rrcVer->iE_Extensions->list.array[0],\
1169          sizeof(RRC_Version_ExtIEs_t));
1170    if(rrcVer->iE_Extensions->list.array[0] == NULLP)
1171    {
1172       return RFAILED;
1173    }
1174    rrcVer->iE_Extensions->list.array[rrcExt]->id = \
1175                                                    ProtocolIE_ID_id_latest_RRC_Version_Enhanced;
1176    rrcVer->iE_Extensions->list.array[rrcExt]->criticality = Criticality_reject;
1177    rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.present =\
1178                                                                       RRC_Version_ExtIEs__extensionValue_PR_Latest_RRC_Version_Enhanced;
1179    rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.choice\
1180       .Latest_RRC_Version_Enhanced.size = 3*sizeof(uint8_t);
1181    DU_ALLOC(rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.choice\
1182          .Latest_RRC_Version_Enhanced.buf,rrcVer->iE_Extensions->list.\
1183          array[rrcExt]->extensionValue.choice.Latest_RRC_Version_Enhanced.size);
1184    if(rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.choice\
1185          .Latest_RRC_Version_Enhanced.buf == NULLP)
1186    {
1187       return RFAILED;
1188    }
1189    rrcLatest = 0;
1190    rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.choice.\
1191       Latest_RRC_Version_Enhanced.buf[rrcLatest] = 15;
1192    rrcLatest++;
1193    rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.choice.\
1194       Latest_RRC_Version_Enhanced.buf[rrcLatest] = 5;
1195    rrcLatest++;
1196    rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.choice.\
1197       Latest_RRC_Version_Enhanced.buf[rrcLatest] = 0;
1198    return ROK;
1199 }
1200 /*******************************************************************
1201  *
1202  * @brief Sends F1 msg over SCTP
1203  *
1204  * @details
1205  *
1206  *    Function : SendF1APMsg
1207  *
1208  *    Functionality: Sends F1 msg over SCTP
1209  *
1210  * @params[in] Region region
1211  *             Pool pool
1212  * @return ROK     - success
1213  *         RFAILED - failure
1214  *
1215  * ****************************************************************/
1216 uint8_t SendF1APMsg(Region region, Pool pool)
1217 {
1218    Buffer *mBuf = NULLP;
1219
1220    if(ODU_GET_MSG_BUF(region, pool, &mBuf) == ROK)
1221    {
1222       if(ODU_ADD_POST_MSG_MULT((Data *)encBuf, encBufSize, mBuf) == ROK)
1223       {
1224             ODU_PRINT_MSG(mBuf, 0,0);
1225
1226             if(sctpSend(mBuf, F1_INTERFACE) != ROK)
1227             {
1228                DU_LOG("\nERROR  -->  F1AP : SCTP Send failed");
1229                ODU_PUT_MSG_BUF(mBuf);
1230                return RFAILED;
1231             }
1232       }
1233       else
1234       {
1235          DU_LOG("\nERROR  -->  F1AP : ODU_ADD_POST_MSG_MULT failed");
1236          ODU_PUT_MSG_BUF(mBuf);
1237          return RFAILED;
1238       }
1239       ODU_PUT_MSG_BUF(mBuf);
1240    }
1241    else
1242    {
1243       DU_LOG("\nERROR  -->  F1AP : Failed to allocate memory");
1244       return RFAILED;
1245    }
1246    return ROK;
1247 } /* SendF1APMsg */
1248
1249 /*******************************************************************
1250  *
1251  * @brief  deallocating the memory of function BuildAndSendF1SetupReq()
1252  *
1253  * @details
1254  *
1255  *    Function :  FreeRrcVer
1256  *
1257  *    Functionality: deallocating the memory of function BuildRrcVer
1258  *
1259  * @params[in] RRC_Version_t *rrcVer
1260  *
1261  * @return void
1262  *
1263  *****************************************************************/
1264 void FreeRrcVer(RRC_Version_t *rrcVer)
1265 {
1266    if(rrcVer->latest_RRC_Version.buf != NULLP)
1267    {
1268       if(rrcVer->iE_Extensions != NULLP)
1269       {
1270          if(rrcVer->iE_Extensions->list.array != NULLP)
1271          {
1272             if(rrcVer->iE_Extensions->list.array[0] != NULLP)
1273             {
1274                if(rrcVer->iE_Extensions->list.array[0]->extensionValue.choice.Latest_RRC_Version_Enhanced.buf
1275                      != NULLP)
1276                {
1277                   DU_FREE(rrcVer->iE_Extensions->list.array[0]->extensionValue.choice\
1278                         .Latest_RRC_Version_Enhanced.buf,rrcVer->iE_Extensions->list.\
1279                         array[0]->extensionValue.choice.Latest_RRC_Version_Enhanced.size);
1280                }
1281                DU_FREE(rrcVer->iE_Extensions->list.array[0],sizeof(RRC_Version_ExtIEs_t));
1282             }
1283             DU_FREE(rrcVer->iE_Extensions->list.array,sizeof(RRC_Version_ExtIEs_t*));
1284          }
1285          DU_FREE(rrcVer->iE_Extensions,sizeof(ProtocolExtensionContainer_4624P81_t));
1286       }
1287       DU_FREE(rrcVer->latest_RRC_Version.buf,rrcVer->latest_RRC_Version.size);
1288    }
1289 }
1290 /*******************************************************************
1291  *
1292  * @brief  deallocating the memory of function BuildAndSendF1SetupReq()
1293  *
1294  * @details
1295  *
1296  *    Function :  FreeServedCellList
1297  *
1298  *    Functionality:  deallocating the memory of function BuildServedCellList
1299
1300  *
1301  * @params[in] GNB_DU_Served_Cells_List_t *duServedCell
1302  *
1303  * @return void
1304  *
1305  * ****************************************************************/
1306 void FreeServedCellList( GNB_DU_Served_Cells_List_t *duServedCell)
1307 {
1308    uint8_t   plmnCnt=1;
1309    uint8_t  servId=0;
1310    uint8_t sliceId=0;
1311    uint8_t  ieId=0;
1312    uint8_t   extensionCnt=1;
1313    uint8_t plmnidx=0;
1314    GNB_DU_Served_Cells_Item_t *srvCellItem= &duServedCell->list.array[0]->value.choice.GNB_DU_Served_Cells_Item;
1315    if(duServedCell->list.array!=NULLP)
1316    {
1317       if(duServedCell->list.array[0]!=NULLP)
1318       {
1319          if(srvCellItem->served_Cell_Information.nRCGI.pLMN_Identity.buf!=NULLP)
1320          {
1321             if(srvCellItem->served_Cell_Information.nRCGI.nRCellIdentity.buf !=NULLP)
1322             {
1323                if(srvCellItem->served_Cell_Information.fiveGS_TAC!=NULLP)
1324                {
1325                   if(srvCellItem->served_Cell_Information.fiveGS_TAC->buf!=NULLP)
1326                   {
1327                      if(srvCellItem->served_Cell_Information.servedPLMNs.list.array!=NULLP)
1328                      {
1329                         if(srvCellItem->served_Cell_Information.servedPLMNs.list.array[0]!=NULLP)
1330                         {
1331                            if(srvCellItem->served_Cell_Information.servedPLMNs.list.array[servId]->pLMN_Identity.buf!=NULLP)
1332                            {
1333                               if(srvCellItem->served_Cell_Information.servedPLMNs.list.array[servId]->iE_Extensions!=NULLP)
1334                               {
1335                                  if(srvCellItem->served_Cell_Information.servedPLMNs.list.array[servId]->iE_Extensions->list.array!=NULLP)
1336                                  {
1337                                     if(srvCellItem->served_Cell_Information.servedPLMNs.list.array[servId]->iE_Extensions->list.array[0]!=NULLP)
1338                                     {
1339                                        if(srvCellItem->served_Cell_Information.servedPLMNs.list.array[servId]->iE_Extensions->list.array[0]->\
1340                                              extensionValue.choice.SliceSupportList.list.array!=NULLP)
1341                                        {
1342                                           if(srvCellItem->served_Cell_Information.servedPLMNs.list.array[servId]->iE_Extensions->list.array[0]->\
1343                                                 extensionValue.choice.SliceSupportList.list.array[sliceId]!= 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.sST.buf!=NULLP)
1347                                              {
1348                                                 if(srvCellItem->served_Cell_Information.servedPLMNs.list.array[servId]->iE_Extensions->list.array[0]->\
1349                                                       extensionValue.choice.SliceSupportList.list.array[sliceId]->sNSSAI.sD!=NULLP)
1350                                                 {
1351                                                    if(srvCellItem->served_Cell_Information.servedPLMNs.list.array[servId]->iE_Extensions->\
1352                                                          list.array[0]->extensionValue.choice.SliceSupportList.list.array[sliceId]->sNSSAI.sD->buf!=NULLP)
1353                                                    {
1354                                                       if(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD!=NULLP)
1355                                                       {
1356                                                          if(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD->uL_NRFreqInfo.\
1357                                                                freqBandListNr.list.array!=NULLP)
1358                                                          {
1359                                                             if(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD->uL_NRFreqInfo.\
1360                                                                   freqBandListNr.list.array[0]!=NULLP)
1361                                                             {
1362                                                                if(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD->dL_NRFreqInfo.\
1363                                                                      freqBandListNr.list.array)
1364                                                                {
1365                                                                   if(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD->dL_NRFreqInfo.\
1366                                                                         freqBandListNr.list.array[0]!=NULLP)
1367                                                                   {
1368                                                                      if(srvCellItem->served_Cell_Information.measurementTimingConfiguration.buf!=NULLP)
1369                                                                      {
1370                                                                         if(!srvCellItem->gNB_DU_System_Information)
1371                                                                         {
1372                                                                            if(srvCellItem->gNB_DU_System_Information->mIB_message.buf!=NULLP)
1373                                                                            {
1374                                                                               if(srvCellItem->gNB_DU_System_Information->sIB1_message.buf!=NULLP)
1375                                                                               {
1376                                                                                  DU_FREE(srvCellItem->gNB_DU_System_Information->sIB1_message.buf,\
1377                                                                                        srvCellItem->gNB_DU_System_Information->sIB1_message.size);
1378                                                                                  DU_FREE(duCfgParam.srvdCellLst[0].duSysInfo.sib1Msg,\
1379                                                                                        srvCellItem->gNB_DU_System_Information->sIB1_message.size);
1380                                                                               }
1381                                                                               DU_FREE(srvCellItem->gNB_DU_System_Information->mIB_message.buf,\
1382                                                                                     srvCellItem->gNB_DU_System_Information->mIB_message.size);
1383                                                                               DU_FREE(duCfgParam.srvdCellLst[0].duSysInfo.mibMsg,\
1384                                                                                     strlen((char*)duCfgParam.srvdCellLst[0].duSysInfo.mibMsg));
1385                                                                            }
1386                                                                            DU_FREE(srvCellItem->gNB_DU_System_Information,sizeof(GNB_DU_System_Information_t));
1387                                                                         }
1388                                                                         DU_FREE(srvCellItem->served_Cell_Information.measurementTimingConfiguration.buf,\
1389                                                                               srvCellItem->served_Cell_Information.measurementTimingConfiguration.size);
1390                                                                      }
1391                                                                      DU_FREE(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD->dL_NRFreqInfo.\
1392                                                                            freqBandListNr.list.array[0],sizeof(FreqBandNrItem_t));
1393                                                                   }
1394                                                                   DU_FREE(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD->dL_NRFreqInfo.\
1395                                                                         freqBandListNr.list.array,sizeof(FreqBandNrItem_t *));
1396                                                                }
1397                                                                DU_FREE(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD->uL_NRFreqInfo.freqBandListNr.\
1398                                                                      list.array[0],sizeof(FreqBandNrItem_t));
1399                                                             }
1400                                                             DU_FREE(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD->uL_NRFreqInfo.freqBandListNr.\
1401                                                                   list.array,sizeof(FreqBandNrItem_t*));
1402                                                          }
1403                                                          DU_FREE(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD,sizeof(FDD_Info_t));
1404                                                       }
1405                                                       DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.array[servId]->\
1406                                                             iE_Extensions->list.array[ieId]->extensionValue.choice.SliceSupportList.list.array[sliceId]->\
1407                                                             sNSSAI.sD->buf,srvCellItem->served_Cell_Information.servedPLMNs.list.array[servId]->iE_Extensions->
1408                                                             list.array[ieId]->extensionValue.choice.SliceSupportList.list.array[sliceId]->sNSSAI.sD->size);
1409                                                    }
1410                                                    DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.array[servId]->\
1411                                                          iE_Extensions->list.array[ieId]->extensionValue.choice.SliceSupportList.\
1412                                                          list.array[sliceId]->sNSSAI.sD,sizeof(OCTET_STRING_t));
1413                                                 }
1414                                                 DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.array[servId]->\
1415                                                       iE_Extensions->list.array[ieId]->extensionValue.choice.SliceSupportList.list.array[sliceId]->\
1416                                                       sNSSAI.sST.buf,sizeof(uint8_t));
1417                                              }
1418                                              DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.array[servId]->iE_Extensions->list.array[0]->\
1419                                                    extensionValue.choice.SliceSupportList.list.array[sliceId],sizeof(SliceSupportItem_t));
1420                                           }
1421                                           DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.array[servId]->iE_Extensions->list.array[0]->\
1422                                                 extensionValue.choice.SliceSupportList.list.array,sizeof(SliceSupportItem_t*));
1423                                        }
1424                                        DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.\
1425                                              array[servId]->iE_Extensions->list.array[plmnidx],sizeof(ServedPLMNs_ItemExtIEs_t));
1426                                     }
1427                                     DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.\
1428                                           array[servId]->iE_Extensions->list.array,\
1429                                           extensionCnt*sizeof(ServedPLMNs_ItemExtIEs_t*));
1430                                  }
1431                                  DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.\
1432                                        array[servId]->iE_Extensions,sizeof(ProtocolExtensionContainer_4624P3_t));
1433                               }
1434                               DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.\
1435                                     array[servId]->pLMN_Identity.buf,srvCellItem->served_Cell_Information.\
1436                                     servedPLMNs.list.array[servId]->pLMN_Identity.size
1437                                     * sizeof(uint8_t));
1438                            }
1439                            DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.array[plmnidx],\
1440                                  sizeof(ServedPLMNs_Item_t *));
1441                         }
1442                         DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.array,\
1443                               sizeof(ServedPLMNs_Item_t *));
1444                      }
1445                      DU_FREE(srvCellItem->served_Cell_Information.fiveGS_TAC->buf,\
1446                            sizeof(srvCellItem->served_Cell_Information.fiveGS_TAC->size));
1447                   }
1448                   DU_FREE(srvCellItem->served_Cell_Information.fiveGS_TAC,sizeof(FiveGS_TAC_t));
1449                }
1450                DU_FREE(srvCellItem->served_Cell_Information.nRCGI.nRCellIdentity.buf,\
1451                      srvCellItem->served_Cell_Information.nRCGI.nRCellIdentity.size *
1452                      sizeof(uint8_t));
1453             }
1454             DU_FREE(srvCellItem->served_Cell_Information.nRCGI.pLMN_Identity.buf,\
1455                   srvCellItem->served_Cell_Information.nRCGI.pLMN_Identity.size *
1456                   sizeof(uint8_t));
1457          }
1458          DU_FREE(duServedCell->list.array[plmnidx],sizeof(GNB_DU_Served_Cells_ItemIEs_t));
1459       }
1460       DU_FREE(duServedCell->list.array,plmnCnt*sizeof(GNB_DU_Served_Cells_ItemIEs_t*));
1461    }
1462 }
1463 /*******************************************************************
1464  *
1465  * @brief  deallocating the memory of function BuildAndSendF1SetupReq()
1466  *
1467  * @details
1468  *
1469  *    Function :  FreeF1SetupReq
1470  *
1471  *    Functionality:  deallocating the memory of function BuildAndSendF1SetupReq
1472  *
1473  * @params[in] F1AP_PDU_t *f1apMsg
1474  *
1475  * @return void
1476  *
1477  * ****************************************************************/
1478 void FreeF1SetupReq(F1AP_PDU_t *f1apMsg)
1479 {
1480    uint8_t ieIdx, ieIdx2;
1481    F1SetupRequest_t *f1SetupReq=NULLP;
1482
1483    if(f1apMsg != NULLP)
1484    {
1485       if(f1apMsg->choice.initiatingMessage != NULLP)
1486       {
1487          f1SetupReq = &f1apMsg->choice.initiatingMessage->value.choice.F1SetupRequest;
1488          if(f1SetupReq->protocolIEs.list.array != NULLP)
1489          {
1490             for(ieIdx = 0; ieIdx < f1SetupReq->protocolIEs.list.count; ieIdx++)
1491             {
1492                if(f1SetupReq->protocolIEs.list.array[ieIdx] != NULLP)
1493                {
1494                   switch(f1SetupReq->protocolIEs.list.array[ieIdx]->id)
1495                   {
1496                      case ProtocolIE_ID_id_TransactionID:
1497                         break;
1498                      case ProtocolIE_ID_id_gNB_DU_ID:
1499                         DU_FREE(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf,\
1500                               f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.size);
1501                         break;
1502                      case ProtocolIE_ID_id_gNB_DU_Name:
1503                         DU_FREE(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_Name.buf,\
1504                               strlen((char *)duCfgParam.duName));
1505                         break;
1506                      case ProtocolIE_ID_id_gNB_DU_Served_Cells_List:
1507                         FreeServedCellList(&f1SetupReq->protocolIEs.list.\
1508                               array[ieIdx]->value.choice.GNB_DU_Served_Cells_List);
1509                         break;
1510                      case ProtocolIE_ID_id_GNB_DU_RRC_Version:
1511                         FreeRrcVer(&f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.RRC_Version);
1512                         break;
1513                      default:
1514                         DU_LOG("\nERROR  -->  Invalid Event Type %ld", f1SetupReq->protocolIEs.list.array[ieIdx]->id);
1515                         break;
1516                   }
1517                }
1518                break;
1519             }
1520             for(ieIdx2=0; ieIdx2< ieIdx; ieIdx2++)
1521             {
1522                DU_FREE(f1SetupReq->protocolIEs.list.array[ieIdx2],sizeof(F1SetupRequestIEs_t));
1523             }
1524             DU_FREE(f1SetupReq->protocolIEs.list.array,\
1525                   f1SetupReq->protocolIEs.list.size);
1526          }
1527          DU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
1528       }
1529       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
1530    }
1531 }
1532 /*******************************************************************
1533  *
1534  * @brief Builds and Send the F1SetupRequest
1535  *
1536  * @details
1537  *
1538  *    Function : BuildAndSendF1SetupReq
1539  *
1540  * Functionality:Fills the F1SetupRequest
1541  *
1542  * @return ROK     - success
1543  *         RFAILED - failure
1544  *
1545  ******************************************************************/
1546 uint8_t BuildAndSendF1SetupReq()
1547 {
1548    uint8_t   ret, ieIdx, elementCnt;
1549    F1AP_PDU_t                 *f1apMsg = NULLP;
1550    F1SetupRequest_t           *f1SetupReq=NULLP;
1551    GNB_DU_Served_Cells_List_t *duServedCell=NULLP;
1552    RRC_Version_t              *rrcVer=NULLP;
1553    asn_enc_rval_t             encRetVal;        /* Encoder return value */
1554    ret= RFAILED;
1555
1556    DU_LOG("\nINFO   -->  F1AP : Building F1 Setup Request\n");
1557    do
1558    {
1559       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
1560       if(f1apMsg == NULLP)
1561       {
1562          break;
1563       }
1564       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
1565       DU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
1566       if(f1apMsg->choice.initiatingMessage == NULLP)
1567       {
1568          break;
1569       }
1570       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_F1Setup;
1571       f1apMsg->choice.initiatingMessage->criticality = Criticality_reject;
1572       f1apMsg->choice.initiatingMessage->value.present = \
1573                                                          InitiatingMessage__value_PR_F1SetupRequest;
1574
1575       f1SetupReq = &f1apMsg->choice.initiatingMessage->value.choice.F1SetupRequest;
1576
1577       elementCnt = (duCfgParam.duName != NULL) ? 5 : 4;
1578
1579       f1SetupReq->protocolIEs.list.count = elementCnt;
1580       f1SetupReq->protocolIEs.list.size = elementCnt * sizeof(F1SetupRequestIEs_t );
1581
1582       /* Initialize the F1Setup members */
1583       DU_ALLOC(f1SetupReq->protocolIEs.list.array,f1SetupReq->protocolIEs.list.size);
1584       if(f1SetupReq->protocolIEs.list.array == NULLP)
1585       {
1586          break;
1587       }
1588       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
1589       {
1590          DU_ALLOC(f1SetupReq->protocolIEs.list.array[ieIdx],\
1591                sizeof(F1SetupRequestIEs_t));
1592          if(f1SetupReq->protocolIEs.list.array[ieIdx] == NULLP)
1593          {
1594             break;
1595          }
1596       }
1597
1598       ieIdx = 0;
1599       /*TransactionID*/
1600       f1SetupReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_TransactionID;
1601       f1SetupReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
1602       f1SetupReq->protocolIEs.list.array[ieIdx]->value.present =\
1603                                                                F1SetupRequestIEs__value_PR_TransactionID;
1604       f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.TransactionID = \
1605                                                                              TRANS_ID;
1606
1607       /*DU ID*/
1608       ieIdx++;
1609       f1SetupReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_ID;
1610       f1SetupReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
1611       f1SetupReq->protocolIEs.list.array[ieIdx]->value.present = \
1612                                                                 F1SetupRequestIEs__value_PR_GNB_DU_ID;
1613       f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.size =\
1614                                                                              sizeof(uint8_t);
1615
1616       DU_ALLOC(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf,\
1617             f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.size);
1618       if(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf == \
1619             NULLP)
1620       {
1621          break;
1622       }
1623
1624       f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf[0] =\
1625          duCfgParam.duId;
1626
1627       /*DU Name*/
1628       if(duCfgParam.duName != NULL)
1629       {
1630          ieIdx++;
1631          f1SetupReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_Name;
1632          f1SetupReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_ignore;
1633          f1SetupReq->protocolIEs.list.array[ieIdx]->value.present = F1SetupRequestIEs__value_PR_GNB_DU_Name;
1634          f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_Name.size =\
1635             strlen((char *)duCfgParam.duName);
1636          DU_ALLOC(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.\
1637                GNB_DU_Name.buf, strlen((char *)duCfgParam.duName));
1638          if(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_Name.\
1639                buf == NULLP)
1640          {
1641             break;
1642          }
1643          strcpy((char*)f1SetupReq->protocolIEs.list.array[ieIdx]->value.\
1644                choice.GNB_DU_Name.buf,
1645                (char*)&duCfgParam.duName);
1646
1647       }
1648
1649       /*Served Cell list */
1650       ieIdx++;
1651       f1SetupReq->protocolIEs.list.array[ieIdx]->id = \
1652                                                      ProtocolIE_ID_id_gNB_DU_Served_Cells_List;
1653       f1SetupReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
1654       f1SetupReq->protocolIEs.list.array[ieIdx]->value.present = \
1655                                                                 F1SetupRequestIEs__value_PR_GNB_DU_Served_Cells_List;
1656       duServedCell = &f1SetupReq->protocolIEs.list.\
1657                      array[ieIdx]->value.choice.GNB_DU_Served_Cells_List;
1658       if(BuildServedCellList(duServedCell))
1659       {
1660          break;
1661       }
1662       /*RRC Version*/
1663       ieIdx++;
1664       f1SetupReq->protocolIEs.list.array[ieIdx]->id = \
1665                                                      ProtocolIE_ID_id_GNB_DU_RRC_Version ;
1666       f1SetupReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
1667       f1SetupReq->protocolIEs.list.array[ieIdx]->value.present = \
1668                                                                 F1SetupRequestIEs__value_PR_RRC_Version;
1669       rrcVer = &f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.RRC_Version;
1670       if(BuildRrcVer(rrcVer))
1671       {
1672          break;
1673       }
1674       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
1675
1676       /* Encode the F1SetupRequest type as APER */
1677       memset(encBuf, 0, ENC_BUF_MAX_LEN);
1678       encBufSize = 0;
1679       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
1680             encBuf);
1681
1682       /* Encode results */
1683       if(encRetVal.encoded == ENCODE_FAIL)
1684       {
1685          DU_LOG("\nERROR  -->  F1AP : Could not encode F1SetupRequest structure (at %s)\n",\
1686                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
1687          break;
1688       }
1689       else
1690       {
1691          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for F1SetupRequest\n");
1692          for(ieIdx=0; ieIdx< encBufSize; ieIdx++)
1693          {
1694             printf("%x",encBuf[ieIdx]);
1695          }
1696       }
1697
1698       /* Sending msg */
1699       if(SendF1APMsg(DU_APP_MEM_REGION, DU_POOL) != ROK)
1700       {
1701          DU_LOG("\nERROR  -->  F1AP : Sending F1 Setup request failed");
1702          break;
1703       }
1704
1705       ret=ROK;
1706       break;
1707    }while(true);
1708
1709    FreeF1SetupReq(f1apMsg);
1710
1711    return ret;
1712 }/* End of BuildAndSendF1SetupReq */
1713
1714 /*******************************************************************
1715  *
1716  * @brief Deallocating memory of BuildAndSendDUConfigUpdate
1717  *
1718  * @details
1719  *
1720  *    Function : FreeDUConfigUpdate
1721  *
1722  *    Functionality: Deallocating memory of variables allocated in
1723  *                    BuildAndSendDUConfigUpdate function
1724  *
1725  * @params[in]  F1AP_PDU_t *f1apDuCfg
1726  *
1727  * @return ROK     - void
1728  *
1729  * ****************************************************************/
1730 void FreeDUConfigUpdate(F1AP_PDU_t *f1apDuCfg)
1731 {
1732    uint8_t  i;
1733    uint8_t  idx;
1734    GNBDUConfigurationUpdate_t *duCfgUpdate = NULLP;
1735    Served_Cells_To_Modify_List_t  *cellsToModify;
1736    Served_Cells_To_Modify_Item_t *modifyItem;
1737    idx=0;
1738    i=1;
1739    if(f1apDuCfg != NULLP)
1740    {
1741       if(f1apDuCfg->choice.initiatingMessage != NULLP)
1742       {
1743          duCfgUpdate = &f1apDuCfg->choice.initiatingMessage->\
1744                        value.choice.GNBDUConfigurationUpdate;
1745          if(duCfgUpdate->protocolIEs.list.array != NULLP)
1746          {
1747             if(duCfgUpdate->protocolIEs.list.array[i] != NULLP)
1748             {
1749                cellsToModify = &duCfgUpdate->protocolIEs.list.array[i]->\
1750                                value.choice.Served_Cells_To_Modify_List;
1751                if(cellsToModify->list.array != NULLP)
1752                {
1753                   if(cellsToModify->list.array[idx] != NULLP)
1754                   {
1755                      modifyItem=&cellsToModify->list.array[idx]->value.choice.\
1756                                 Served_Cells_To_Modify_Item;
1757                      if(modifyItem->oldNRCGI.pLMN_Identity.buf != NULLP)
1758                      {
1759                         if(modifyItem->oldNRCGI.nRCellIdentity.buf != NULLP)
1760                         {
1761                            if(modifyItem->served_Cell_Information.nRCGI.pLMN_Identity.buf != NULLP)
1762                            {
1763                               if(modifyItem->served_Cell_Information.nRCGI.nRCellIdentity.buf
1764                                     != NULLP)
1765                               {
1766                                  if(modifyItem->served_Cell_Information.servedPLMNs.list.array\
1767                                        != NULLP)
1768                                  {
1769                                     if(!modifyItem->served_Cell_Information.servedPLMNs.list.array[idx])
1770                                     {
1771                                        if(modifyItem->served_Cell_Information.servedPLMNs.list.\
1772                                              array[idx]->pLMN_Identity.buf != NULLP)
1773                                        {
1774                                           if(modifyItem->served_Cell_Information.servedPLMNs.list.\
1775                                                 array[idx]->iE_Extensions!= NULLP)
1776                                           {
1777                                              if(modifyItem->served_Cell_Information.servedPLMNs.list.\
1778                                                    array[idx]->iE_Extensions->list.array != NULLP)
1779                                              {
1780                                                 if(modifyItem->served_Cell_Information.servedPLMNs.list.\
1781                                                       array[idx]->iE_Extensions->list.array[idx])
1782                                                 {
1783                                                    if(modifyItem->served_Cell_Information.servedPLMNs.list.array[idx]->\
1784                                                          iE_Extensions->list.array[idx]->extensionValue.choice.SliceSupportList.\
1785                                                          list.array !=NULLP)
1786                                                    {
1787                                                       if(modifyItem->served_Cell_Information.servedPLMNs.list.array[idx]->\
1788                                                             iE_Extensions->list.array[idx]->extensionValue.choice.SliceSupportList.\
1789                                                             list.array[idx]!=NULLP)
1790                                                       {
1791                                                          if(modifyItem->served_Cell_Information.servedPLMNs.list.array[idx]->\
1792                                                                iE_Extensions->list.array[idx]->extensionValue.choice.SliceSupportList.\
1793                                                                list.array[idx]->sNSSAI.sST.buf!=NULLP)
1794                                                          {
1795                                                             if(modifyItem->served_Cell_Information.servedPLMNs.list.array[idx]->\
1796                                                                   iE_Extensions->list.array[idx]->extensionValue.choice.SliceSupportList.\
1797                                                                   list.array[idx]->sNSSAI.sD != NULLP)
1798                                                             {
1799                                                                if(modifyItem->served_Cell_Information.servedPLMNs.list.array[idx]->\
1800                                                                      iE_Extensions->list.array[idx]->extensionValue.choice.SliceSupportList.\
1801                                                                      list.array[idx]->sNSSAI.sD->buf!=NULLP)
1802                                                                {
1803                                                                   if(modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD
1804                                                                         !=NULLP)
1805                                                                   {
1806                                                                      if(modifyItem->served_Cell_Information.nR_Mode_Info.choice.\
1807                                                                            fDD->uL_NRFreqInfo.freqBandListNr.list.array!=NULLP)
1808                                                                      {
1809                                                                         if(modifyItem->served_Cell_Information.nR_Mode_Info.choice.\
1810                                                                               fDD->uL_NRFreqInfo.freqBandListNr.list.array[idx]!=NULLP)
1811                                                                         {
1812                                                                            if(modifyItem->served_Cell_Information.nR_Mode_Info.choice.\
1813                                                                                  fDD->dL_NRFreqInfo.freqBandListNr.list.array !=NULLP)
1814                                                                            {
1815                                                                               if(modifyItem->served_Cell_Information.nR_Mode_Info.\
1816                                                                                     choice.fDD->dL_NRFreqInfo.freqBandListNr.list.\
1817                                                                                     array[idx]!= NULLP)
1818                                                                               {
1819                                                                                  if(modifyItem->served_Cell_Information.\
1820                                                                                        measurementTimingConfiguration.buf !=NULLP)
1821                                                                                  {
1822                                                                                     idx=2;
1823                                                                                     if(duCfgUpdate->protocolIEs.list.array[idx]->value.\
1824                                                                                           choice.GNB_DU_ID.buf!=NULLP)
1825                                                                                     {
1826                                                                                        DU_FREE(duCfgUpdate->protocolIEs.list.\
1827                                                                                              array[idx]->value.choice.GNB_DU_ID.buf,\
1828                                                                                              duCfgUpdate->protocolIEs.list.array[idx]->\
1829                                                                                              value.choice.GNB_DU_ID.size);
1830                                                                                     }
1831                                                                                     idx=0;
1832                                                                                     DU_FREE(modifyItem->served_Cell_Information.\
1833                                                                                           measurementTimingConfiguration.\
1834                                                                                           buf,modifyItem->served_Cell_Information.\
1835                                                                                           measurementTimingConfiguration.size);
1836                                                                                  }
1837                                                                                  DU_FREE(modifyItem->served_Cell_Information.\
1838                                                                                        nR_Mode_Info.choice.fDD->dL_NRFreqInfo.freqBandListNr.\
1839                                                                                        list.array[idx],sizeof(FreqBandNrItem_t));
1840                                                                               }
1841                                                                               DU_FREE(modifyItem->served_Cell_Information.nR_Mode_Info\
1842                                                                                     .choice.fDD->dL_NRFreqInfo.freqBandListNr.list.array,\
1843                                                                                     modifyItem->served_Cell_Information.nR_Mode_Info.\
1844                                                                                     choice.fDD->dL_NRFreqInfo.freqBandListNr.list.size);
1845                                                                            }
1846                                                                            DU_FREE(modifyItem->served_Cell_Information.nR_Mode_Info.\
1847                                                                                  choice.fDD->uL_NRFreqInfo.freqBandListNr.list.\
1848                                                                                  array[idx],sizeof(FreqBandNrItem_t));
1849                                                                         }
1850                                                                         DU_FREE(modifyItem->served_Cell_Information.nR_Mode_Info.\
1851                                                                               choice.\
1852                                                                               fDD->uL_NRFreqInfo.freqBandListNr.list.\
1853                                                                               array,modifyItem->served_Cell_Information.nR_Mode_Info.choice.\
1854                                                                               fDD->uL_NRFreqInfo.freqBandListNr.list.size);
1855                                                                      }
1856                                                                      DU_FREE(modifyItem->served_Cell_Information.nR_Mode_Info.choice.\
1857                                                                            fDD,sizeof(FDD_Info_t));
1858                                                                   }
1859                                                                   DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.\
1860                                                                         array[idx]->iE_Extensions->list.array[idx]->extensionValue.choice.\
1861                                                                         SliceSupportList.\
1862                                                                         list.array[idx]->sNSSAI.sD->buf,modifyItem->served_Cell_Information.\
1863                                                                         servedPLMNs.list.array[idx]->iE_Extensions->list.array[idx]->\
1864                                                                         extensionValue.choice.SliceSupportList.list.array[idx]->\
1865                                                                         sNSSAI.sD->size);
1866
1867                                                                }
1868                                                                DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.\
1869                                                                      array[idx]->\
1870                                                                      iE_Extensions->list.array[idx]->extensionValue.choice.SliceSupportList.\
1871                                                                      list.array[idx]->sNSSAI.sD,sizeof(OCTET_STRING_t));
1872                                                             }
1873                                                             DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.array[idx]->\
1874                                                                   iE_Extensions->list.array[idx]->extensionValue.choice.SliceSupportList.\
1875                                                                   list.array[idx]->sNSSAI.sST.buf,modifyItem->served_Cell_Information.\
1876                                                                   servedPLMNs.\
1877                                                                   list.array[idx]->iE_Extensions->list.array[idx]->extensionValue.choice.\
1878                                                                   SliceSupportList.list.array[idx]->sNSSAI.sST.size);
1879                                                          }
1880                                                          DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.array[idx]->\
1881                                                                iE_Extensions->list.array[idx]->extensionValue.choice.SliceSupportList.\
1882                                                                list.array[idx],sizeof(SliceSupportItem_t));
1883                                                       }
1884                                                       DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.array[idx]->\
1885                                                             iE_Extensions->list.array[idx]->extensionValue.choice.SliceSupportList.\
1886                                                             list.array,\
1887                                                             modifyItem->served_Cell_Information.servedPLMNs.list.array[idx]->\
1888                                                             iE_Extensions->list.array[idx]->extensionValue.choice.SliceSupportList.list.size);
1889                                                    }
1890                                                 }
1891                                                 for(i=0;i<modifyItem->served_Cell_Information.servedPLMNs.list.\
1892                                                       array[idx]->iE_Extensions->list.count;i++)
1893                                                 {
1894                                                    DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.\
1895                                                          array[idx]->iE_Extensions->list.array[i],\
1896                                                          sizeof(ServedPLMNs_ItemExtIEs_t ));
1897                                                 }
1898                                                 DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.\
1899                                                       array[idx]->iE_Extensions->list.array,modifyItem->served_Cell_Information.servedPLMNs.
1900                                                       list.array[idx]->iE_Extensions->list.size);
1901                                              }
1902                                              DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.\
1903                                                    array[idx]->iE_Extensions,sizeof(ProtocolExtensionContainer_4624P3_t));
1904                                           }
1905                                           DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.\
1906                                                 array[idx]->pLMN_Identity.buf,
1907                                                 modifyItem->served_Cell_Information.servedPLMNs.list.array[idx]->pLMN_Identity.size);
1908                                        }
1909                                     }
1910                                     for(i=0;i<modifyItem->served_Cell_Information.servedPLMNs.list.count;i++)
1911                                     {
1912                                        if(modifyItem->served_Cell_Information.servedPLMNs.list.array[i]
1913                                              != NULLP)
1914                                        {
1915                                           DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.array[i],\
1916                                                 sizeof(ServedPLMNs_Item_t));
1917                                        }
1918                                     }
1919                                     DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.array,\
1920                                           modifyItem->served_Cell_Information.servedPLMNs.list.size);
1921                                  }
1922                                  DU_FREE(modifyItem->served_Cell_Information.nRCGI.nRCellIdentity.buf,\
1923                                        modifyItem->served_Cell_Information.nRCGI.nRCellIdentity.size);
1924                               }
1925                               DU_FREE(modifyItem->served_Cell_Information.nRCGI.pLMN_Identity.buf,\
1926                                     modifyItem->served_Cell_Information.nRCGI.pLMN_Identity.size);
1927                            }
1928                            DU_FREE(modifyItem->oldNRCGI.nRCellIdentity.buf,\
1929                                  modifyItem->oldNRCGI.nRCellIdentity.size);
1930                         }
1931                         DU_FREE(modifyItem->oldNRCGI.pLMN_Identity.buf,\
1932                               modifyItem->oldNRCGI.pLMN_Identity.size);
1933                      }
1934                   }
1935                   for(i=0; i<cellsToModify->list.count ;i++)
1936                   {
1937                      if(cellsToModify->list.array[i] != NULLP)
1938                      {
1939                         DU_FREE(cellsToModify->list.array[i],\
1940                               sizeof(Served_Cells_To_Modify_ItemIEs_t));
1941                      }
1942                   }
1943                   DU_FREE(cellsToModify->list.array,cellsToModify->list.size);
1944                }
1945             }
1946             for(i=0;i<duCfgUpdate->protocolIEs.list.count;i++)
1947             {
1948                if(duCfgUpdate->protocolIEs.list.array[i] !=NULLP)
1949                {
1950                   DU_FREE(duCfgUpdate->protocolIEs.list.array[i],\
1951                         sizeof(GNBDUConfigurationUpdateIEs_t));
1952                }
1953             }
1954             DU_FREE(duCfgUpdate->protocolIEs.list.array,duCfgUpdate->protocolIEs.list.size);
1955          }
1956          DU_FREE(f1apDuCfg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
1957       }
1958       DU_FREE(f1apDuCfg, (Size)sizeof(F1AP_PDU_t));
1959    }
1960 }
1961
1962 /*******************************************************************
1963  *
1964  * @brief Fills Served Plmns required in ServCellInfo IE
1965  *
1966  * @details
1967  *
1968  *    Function : fillServedPlmns
1969  *
1970  *    Functionality: Fills Served Plmns required in ServCellInfo IE
1971  *
1972  * @params[in] Pointer to ServedPLMNs_List_t *
1973  *
1974  * @return ROK     - success
1975  *         RFAILED - failure
1976  *
1977  *****************************************************************/
1978
1979 uint8_t fillServedPlmns(ServedPLMNs_List_t *servedPlmn)
1980 {
1981    uint8_t ieIdx, ieListCnt;
1982
1983    servedPlmn->list.array[0]->pLMN_Identity.size = 3*sizeof(uint8_t);
1984    DU_ALLOC(servedPlmn->list.array[0]->pLMN_Identity.buf, servedPlmn->list.\
1985          array[0]->pLMN_Identity.size);
1986    if(servedPlmn->list.array[0]->pLMN_Identity.buf == NULLP)
1987    {
1988       return RFAILED;
1989    }
1990    buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.plmn[0],\
1991          servedPlmn->list.array[0]->pLMN_Identity.buf);
1992    DU_ALLOC(servedPlmn->list.array[0]->iE_Extensions,sizeof(ProtocolExtensionContainer_4624P3_t));
1993    if(servedPlmn->list.array[0]->iE_Extensions == NULLP)
1994    {
1995       return RFAILED;
1996    }
1997
1998    ieListCnt=1;
1999    servedPlmn->list.array[0]->iE_Extensions->list.count = ieListCnt;
2000    servedPlmn->list.array[0]->iE_Extensions->list.size = ieListCnt *sizeof(ServedPLMNs_ItemExtIEs_t *);
2001    DU_ALLOC(servedPlmn->list.array[0]->iE_Extensions->list.array,servedPlmn->list.array[0]->\
2002          iE_Extensions->list.size);
2003    if(servedPlmn->list.array[0]->iE_Extensions->list.array == NULLP)
2004    {
2005       return RFAILED;
2006    }
2007    for(ieIdx=0;ieIdx<ieListCnt;ieIdx++)
2008    {
2009       DU_ALLOC(servedPlmn->list.array[0]->iE_Extensions->list.array[ieIdx],\
2010             sizeof(ServedPLMNs_ItemExtIEs_t));
2011       if(servedPlmn->list.array[0]->iE_Extensions->list.array[ieIdx] == NULLP)
2012       {
2013          return RFAILED;
2014       }
2015    }
2016    //plmnIeExt = servedPlmn->list.array[0]->iE_Extensions;
2017    servedPlmn->list.array[0]->iE_Extensions->list.array[0]->id =ProtocolIE_ID_id_TAISliceSupportList;
2018    servedPlmn->list.array[0]->iE_Extensions->list.array[0]->criticality = Criticality_ignore;
2019    servedPlmn->list.array[0]->iE_Extensions->list.array[0]->extensionValue.present = \
2020       ServedPLMNs_ItemExtIEs__extensionValue_PR_SliceSupportList;
2021    servedPlmn->list.array[0]->iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2022       list.count = 1;
2023    servedPlmn->list.array[0]->\
2024       iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2025       list.size = sizeof(SliceSupportItem_t *);
2026    DU_ALLOC(servedPlmn->list.array[0]->\
2027          iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2028          list.array,servedPlmn->list.array[0]->\
2029          iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.list.size);
2030    if(servedPlmn->list.array[0]->\
2031          iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2032          list.array == NULLP)
2033    {
2034       return RFAILED;
2035    }
2036
2037    DU_ALLOC(servedPlmn->list.array[0]->\
2038          iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2039          list.array[0],sizeof( SliceSupportItem_t));
2040    if(servedPlmn->list.array[0]->\
2041          iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2042          list.array[0] == NULLP)
2043    {
2044       return RFAILED;
2045    }
2046    servedPlmn->list.array[0]->\
2047       iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2048       list.array[0]->sNSSAI.sST.size = sizeof(uint8_t);
2049    DU_ALLOC(servedPlmn->list.array[0]->\
2050          iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2051          list.array[0]->sNSSAI.sST.buf,servedPlmn->list.array[0]->\
2052          iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.list.array[0]->sNSSAI.sST.size);
2053    if(servedPlmn->list.array[0]->\
2054          iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2055          list.array[0]->sNSSAI.sST.buf == NULLP)
2056    {
2057       return RFAILED;
2058    }
2059    servedPlmn->list.array[0]->\
2060       iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2061       list.array[0]->sNSSAI.sST.buf[0] = 3;
2062    DU_ALLOC(servedPlmn->list.array[0]->\
2063          iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2064          list.array[0]->sNSSAI.sD,sizeof(OCTET_STRING_t));
2065    if(servedPlmn->list.array[0]->\
2066          iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2067          list.array[0]->sNSSAI.sD == NULLP)
2068    {
2069       return RFAILED;
2070    }
2071    servedPlmn->list.array[0]->\
2072       iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2073       list.array[0]->sNSSAI.sD->size = 3*sizeof(uint8_t);
2074    DU_ALLOC(servedPlmn->list.array[0]->\
2075          iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2076          list.array[0]->sNSSAI.sD->buf,servedPlmn->list.array[0]->\
2077          iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2078          list.array[0]->sNSSAI.sD->size);
2079    if(servedPlmn->list.array[0]->\
2080          iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2081          list.array[0]->sNSSAI.sD->buf == NULLP)
2082    {
2083       return RFAILED;
2084    }
2085    servedPlmn->list.array[0]->\
2086       iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2087       list.array[0]->sNSSAI.sD->buf[0] = 3;
2088    servedPlmn->list.array[0]->\
2089       iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2090       list.array[0]->sNSSAI.sD->buf[1] = 6;
2091    servedPlmn->list.array[0]->\
2092       iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2093       list.array[0]->sNSSAI.sD->buf[2] = 9;
2094    return ROK;
2095 }
2096
2097 /*******************************************************************
2098  *
2099  * @brief Fills Nr Fdd Info required in ServCellInfo IE
2100  *
2101  * @details
2102  *
2103  *    Function : fillNrFddInfo
2104  *
2105  *    Functionality: Fills Nr Fdd Info required in ServCellInfo IE
2106  *
2107  * @params[in] Pointer to NR_Mode_Info_t *
2108  *
2109  * @return ROK     - success
2110  *         RFAILED - failure
2111  *
2112  *****************************************************************/
2113
2114 uint8_t fillNrFddInfo(NR_Mode_Info_t *nrFdd)
2115 {
2116    nrFdd->choice.fDD->uL_NRFreqInfo.nRARFCN = duCfgParam.srvdCellLst[0].duCellInfo.\
2117       f1Mode.mode.fdd.ulNrFreqInfo.nrArfcn;
2118    nrFdd->choice.fDD->uL_NRFreqInfo.freqBandListNr.list.count = 1;
2119    nrFdd->choice.fDD->uL_NRFreqInfo.freqBandListNr.list.size = sizeof(FreqBandNrItem_t*);
2120    DU_ALLOC(nrFdd->choice.fDD->uL_NRFreqInfo.freqBandListNr.list.\
2121          array, nrFdd->choice.fDD->uL_NRFreqInfo.freqBandListNr.list.size);
2122    if(nrFdd->choice.fDD->uL_NRFreqInfo.freqBandListNr.list.array == NULLP)
2123    {
2124       return RFAILED;
2125    }
2126    DU_ALLOC(nrFdd->choice.fDD->uL_NRFreqInfo.freqBandListNr.list.array[0], \
2127       sizeof(FreqBandNrItem_t));
2128    if(nrFdd->choice.fDD->uL_NRFreqInfo.freqBandListNr.list.array[0] == NULLP)
2129    {
2130       return RFAILED;
2131    }
2132    nrFdd->choice.fDD->uL_NRFreqInfo.freqBandListNr.list.array[0]->freqBandIndicatorNr = \
2133       duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.fdd.ulNrFreqInfo.\
2134       freqBand[0].nrFreqBand;
2135    nrFdd->choice.fDD->uL_NRFreqInfo.freqBandListNr.list.array[0]->supportedSULBandList.list.count=0;
2136    nrFdd->choice.fDD->dL_NRFreqInfo.nRARFCN = duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.fdd.\
2137       dlNrFreqInfo.nrArfcn;
2138    nrFdd->choice.fDD->dL_NRFreqInfo.freqBandListNr.list.count = 1;
2139    nrFdd->choice.fDD->dL_NRFreqInfo.freqBandListNr.list.size = sizeof(FreqBandNrItem_t *);
2140    DU_ALLOC(nrFdd->choice.fDD->dL_NRFreqInfo.freqBandListNr.list.array,nrFdd->\
2141          choice.fDD->dL_NRFreqInfo.freqBandListNr.list.size);
2142    if(nrFdd->choice.fDD->dL_NRFreqInfo.freqBandListNr.list.array == NULLP)
2143    {
2144       return RFAILED;
2145    }
2146    DU_ALLOC(nrFdd->choice.fDD->dL_NRFreqInfo.freqBandListNr.list.array[0],\
2147          sizeof(FreqBandNrItem_t));
2148    if(nrFdd->choice.fDD->dL_NRFreqInfo.freqBandListNr.list.array[0] == NULLP)
2149    {
2150       return RFAILED;
2151    }
2152    nrFdd->choice.fDD->dL_NRFreqInfo.freqBandListNr.list.array[0]->freqBandIndicatorNr = \
2153       duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.fdd.dlNrFreqInfo.\
2154       freqBand[0].nrFreqBand;
2155    nrFdd->choice.fDD->dL_NRFreqInfo.freqBandListNr.list.array[0]->supportedSULBandList.list.count=0;
2156
2157    /*Transmission Bandwidth*/
2158    nrFdd->choice.fDD->uL_Transmission_Bandwidth.nRSCS = duCfgParam.srvdCellLst[0].duCellInfo.\
2159       f1Mode.mode.fdd.ulTxBw.nrScs;
2160    nrFdd->choice.fDD->uL_Transmission_Bandwidth.nRNRB = duCfgParam.srvdCellLst[0].duCellInfo.\
2161       f1Mode.mode.fdd.ulTxBw.nrb;
2162    nrFdd->choice.fDD->dL_Transmission_Bandwidth.nRSCS = duCfgParam.srvdCellLst[0].duCellInfo.\
2163       f1Mode.mode.fdd.dlTxBw.nrScs;
2164    nrFdd->choice.fDD->dL_Transmission_Bandwidth.nRNRB = duCfgParam.srvdCellLst[0].duCellInfo.\
2165       f1Mode.mode.fdd.dlTxBw.nrb;
2166
2167    return ROK;
2168 }
2169
2170 /*******************************************************************
2171  *
2172  * @brief Fills ServCellInfo IE
2173  *
2174  * @details
2175  *
2176  *    Function : fillServedCellInfo
2177  *
2178  *    Functionality: Fills ServCellInfo
2179  *
2180  * @params[in] Pointer to Served_Cell_Information_t *
2181  *
2182  * @return ROK     - success
2183  *         RFAILED - failure
2184  *
2185  *****************************************************************/
2186
2187 uint8_t fillServedCellInfo(Served_Cell_Information_t *srvCellInfo)
2188 {
2189    uint8_t tmp, ieIdx, ieListCnt;
2190
2191    /*nRCGI*/
2192    srvCellInfo->nRCGI.pLMN_Identity.size =3*sizeof(uint8_t);
2193    DU_ALLOC(srvCellInfo->nRCGI.pLMN_Identity.buf,\
2194          srvCellInfo->nRCGI.pLMN_Identity.size);
2195    if(srvCellInfo->nRCGI.pLMN_Identity.buf == NULLP)
2196    {
2197       return RFAILED;
2198    }
2199    buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrCgi.plmn,\
2200          srvCellInfo->nRCGI.pLMN_Identity.buf);
2201    srvCellInfo->nRCGI.nRCellIdentity.size =5*sizeof(uint8_t);
2202    DU_ALLOC(srvCellInfo->nRCGI.nRCellIdentity.buf,\
2203          srvCellInfo->nRCGI.nRCellIdentity.size);
2204    if(srvCellInfo->nRCGI.nRCellIdentity.buf == NULLP)
2205    {
2206       return RFAILED;
2207    }
2208    for (tmp = 0 ; tmp < srvCellInfo->\
2209          nRCGI.nRCellIdentity.size-1 ; tmp++)
2210    {
2211       srvCellInfo->nRCGI.nRCellIdentity.buf[tmp] = 0;
2212    }
2213    srvCellInfo->nRCGI.nRCellIdentity.buf[4] = 16;
2214    srvCellInfo->nRCGI.nRCellIdentity.bits_unused =4;
2215
2216    /*nRPCI*/
2217    srvCellInfo->nRPCI = duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrPci;
2218
2219    /*servedPLMNs*/
2220    ieListCnt = 1;
2221    srvCellInfo->servedPLMNs.list.count = ieListCnt;
2222    srvCellInfo->servedPLMNs.list.size = ieListCnt*sizeof(ServedPLMNs_Item_t *);
2223    DU_ALLOC(srvCellInfo->servedPLMNs.list.array,\
2224          srvCellInfo->servedPLMNs.list.size);
2225    if(srvCellInfo->servedPLMNs.list.array == NULLP)
2226    {
2227       return RFAILED;
2228    }
2229    for(ieIdx=0; ieIdx < ieListCnt; ieIdx++)
2230    {
2231       DU_ALLOC(srvCellInfo->servedPLMNs.list.array[ieIdx],\
2232             sizeof(ServedPLMNs_Item_t));
2233       if(srvCellInfo->servedPLMNs.list.array[ieIdx]== NULLP)
2234       {
2235          return RFAILED;
2236       }
2237    }
2238    if(fillServedPlmns(&srvCellInfo->servedPLMNs))
2239    {
2240       return RFAILED;
2241    }
2242
2243    /*nR Mode Info with FDD*/
2244    srvCellInfo->nR_Mode_Info.present = NR_Mode_Info_PR_fDD;
2245    DU_ALLOC(srvCellInfo->nR_Mode_Info.choice.fDD,\
2246          sizeof(FDD_Info_t));
2247    if(srvCellInfo->nR_Mode_Info.choice.fDD == NULLP)
2248    {
2249       return RFAILED;
2250    }
2251    if(fillNrFddInfo(&srvCellInfo->nR_Mode_Info))
2252       return RFAILED;
2253
2254    /*Measurement timing Config*/
2255    srvCellInfo->measurementTimingConfiguration.size = sizeof(uint8_t);
2256    DU_ALLOC(srvCellInfo->measurementTimingConfiguration.\
2257          buf,srvCellInfo->measurementTimingConfiguration.size);
2258    if(srvCellInfo->measurementTimingConfiguration.buf == NULLP)
2259    {
2260       return RFAILED;
2261    }
2262    srvCellInfo->measurementTimingConfiguration.\
2263          buf[0] = duCfgParam.srvdCellLst[0].duCellInfo.measTimeCfg;
2264
2265    return ROK;
2266 }
2267
2268 /*******************************************************************
2269  *
2270  * @brief Fills ServCellToModItem IE
2271  *
2272  * @details
2273  *
2274  *    Function : fillServCellToModItem
2275  *
2276  *    Functionality: Fills ServCellToModItem IE
2277  *
2278  * @params[in] Pointer to Served_Cells_To_Modify_Item_t *
2279  *
2280  * @return ROK     - success
2281  *         RFAILED - failure
2282  *
2283  *****************************************************************/
2284
2285 uint8_t fillServCellToModItem(Served_Cells_To_Modify_Item_t *modifyItem)
2286 {
2287    uint8_t ieIdx;
2288
2289    /*pLMN_Identity*/
2290    modifyItem->oldNRCGI.pLMN_Identity.size = 3*sizeof(uint8_t);
2291    DU_ALLOC(modifyItem->oldNRCGI.pLMN_Identity.buf,modifyItem->oldNRCGI.pLMN_Identity.size);
2292    if(modifyItem->oldNRCGI.pLMN_Identity.buf == NULLP)
2293    {
2294       return RFAILED;
2295    }
2296    buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrCgi.plmn,\
2297          modifyItem->oldNRCGI.pLMN_Identity.buf);
2298
2299    /*nRCellIdentity*/
2300    modifyItem->oldNRCGI.nRCellIdentity.size = 5*sizeof(uint8_t);
2301    DU_ALLOC(modifyItem->oldNRCGI.nRCellIdentity.buf,\
2302          modifyItem->oldNRCGI.nRCellIdentity.size);
2303    if(modifyItem->oldNRCGI.nRCellIdentity.buf == NULLP)
2304    {
2305       return RFAILED;
2306    }
2307    for(ieIdx = 0; ieIdx < modifyItem->oldNRCGI.nRCellIdentity.size-1; ieIdx++)
2308    {
2309       modifyItem->oldNRCGI.nRCellIdentity.buf[ieIdx] = 0;
2310    }
2311    modifyItem->oldNRCGI.nRCellIdentity.buf[4] = 16;
2312    modifyItem->oldNRCGI.nRCellIdentity.bits_unused = 4;
2313
2314    if(fillServedCellInfo(&modifyItem->served_Cell_Information))
2315       return RFAILED;
2316    else
2317       return ROK;
2318 }
2319
2320 /*******************************************************************
2321  *
2322  * @brief Builds ServCellToModList
2323  *
2324  * @details
2325  *
2326  *    Function : buildServCellToModList
2327  *
2328  *    Functionality: Builds the serv cell to Mod List
2329  *
2330  * @params[in] Pointer to Served_Cells_To_Modify_List_t *
2331  *
2332  * @return ROK     - success
2333  *         RFAILED - failure
2334  *
2335  *****************************************************************/
2336
2337 uint8_t buildServCellToModList(Served_Cells_To_Modify_List_t *cellsToModify)
2338 {
2339    uint8_t ieListCnt, ieIdx;
2340    Served_Cells_To_Modify_Item_t *modifyItem = NULLP;
2341
2342    ieListCnt = 1;
2343    cellsToModify->list.count = ieListCnt;
2344    cellsToModify->list.size = ieListCnt*sizeof(Served_Cells_To_Modify_ItemIEs_t *);
2345    DU_ALLOC(cellsToModify->list.array,cellsToModify->list.size);
2346    if(cellsToModify->list.array == NULLP)
2347    {
2348       return RFAILED;
2349    }
2350    for(ieIdx=0; ieIdx< ieListCnt; ieIdx++)
2351    {
2352       DU_ALLOC(cellsToModify->list.array[ieIdx],sizeof(Served_Cells_To_Modify_ItemIEs_t));
2353       if(cellsToModify->list.array[ieIdx] == NULLP)
2354       {
2355          return RFAILED;
2356       }
2357    }
2358    cellsToModify->list.array[0]->id = ProtocolIE_ID_id_Served_Cells_To_Modify_Item;
2359    cellsToModify->list.array[0]->criticality = Criticality_reject;
2360    cellsToModify->list.array[0]->value.present =\
2361       Served_Cells_To_Modify_ItemIEs__value_PR_Served_Cells_To_Modify_Item;
2362    modifyItem=&cellsToModify->list.array[0]->value.choice.Served_Cells_To_Modify_Item;
2363
2364    if(fillServCellToModItem(modifyItem))
2365       return RFAILED;
2366    else
2367       return ROK;
2368 }
2369
2370 /*******************************************************************
2371  *
2372  * @brief Builds and sends the DUConfigUpdate
2373  *
2374  * @details
2375  *
2376  *    Function : BuildAndSendDUConfigUpdate
2377  *
2378  *    Functionality: Constructs the DU Update message and sends
2379  *                   it to the CU through SCTP.
2380  *
2381  * @params[in] void **buf,Buffer to which encoded pattern is written into
2382  * @params[in] int *size,size of buffer
2383  *
2384  * @return ROK     - success
2385  *         RFAILED - failure
2386  *
2387  * ****************************************************************/
2388 uint8_t BuildAndSendDUConfigUpdate()
2389 {
2390    uint8_t ret, ieIdx, elementCnt;
2391    F1AP_PDU_t                 *f1apDuCfg = NULLP;
2392    GNBDUConfigurationUpdate_t *duCfgUpdate = NULLP;
2393    asn_enc_rval_t encRetVal;     /* Encoder return value */
2394    memset(&encRetVal, 0, sizeof(asn_enc_rval_t));
2395    ret= RFAILED;
2396
2397    while(true)
2398    {
2399       DU_LOG("\nINFO   -->  F1AP : Building DU config update\n");
2400       /* Allocate the memory for F1DuCfg */
2401       DU_ALLOC(f1apDuCfg, sizeof(F1AP_PDU_t));
2402       if(f1apDuCfg == NULLP)
2403       {
2404          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
2405          break;
2406       }
2407
2408       f1apDuCfg->present = F1AP_PDU_PR_initiatingMessage;
2409       DU_ALLOC(f1apDuCfg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
2410       if(f1apDuCfg->choice.initiatingMessage == NULLP)
2411       {
2412          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
2413          break;
2414       }
2415
2416       f1apDuCfg->choice.initiatingMessage->procedureCode = \
2417                                                            ProcedureCode_id_gNBDUConfigurationUpdate;
2418       f1apDuCfg->choice.initiatingMessage->criticality = Criticality_reject;
2419       f1apDuCfg->choice.initiatingMessage->value.present = \
2420                                                            InitiatingMessage__value_PR_GNBDUConfigurationUpdate;
2421       duCfgUpdate = &f1apDuCfg->choice.initiatingMessage->value.\
2422                     choice.GNBDUConfigurationUpdate;
2423       elementCnt = 3;
2424       duCfgUpdate->protocolIEs.list.count = elementCnt;
2425       duCfgUpdate->protocolIEs.list.size = \
2426                                            elementCnt * sizeof(GNBDUConfigurationUpdateIEs_t*);
2427
2428       /* Initialize the F1Setup members */
2429       DU_ALLOC(duCfgUpdate->protocolIEs.list.array,duCfgUpdate->protocolIEs.list.size);
2430       if(duCfgUpdate->protocolIEs.list.array == NULLP)
2431       {
2432          DU_LOG("ERROR  -->  F1AP : Memory allocation for F1RequestIEs failed");
2433          break;
2434       }
2435       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
2436       {
2437          DU_ALLOC(duCfgUpdate->protocolIEs.list.array[ieIdx],sizeof(GNBDUConfigurationUpdateIEs_t));
2438          if(duCfgUpdate->protocolIEs.list.array[ieIdx] == NULLP)
2439          {
2440             break;
2441          }
2442       }
2443
2444       /*TransactionID*/
2445       ieIdx = 0;
2446       duCfgUpdate->protocolIEs.list.array[ieIdx]->id=ProtocolIE_ID_id_TransactionID;
2447       duCfgUpdate->protocolIEs.list.array[ieIdx]->criticality= Criticality_reject;
2448       duCfgUpdate->protocolIEs.list.array[ieIdx]->value.present = \
2449          GNBDUConfigurationUpdateIEs__value_PR_TransactionID;
2450       duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.TransactionID = TRANS_ID;
2451
2452       /*Served Cell to Modify */
2453       ieIdx++;
2454       duCfgUpdate->protocolIEs.list.array[ieIdx]->id = \
2455                                                       ProtocolIE_ID_id_Served_Cells_To_Modify_List;
2456       duCfgUpdate->protocolIEs.list.array[ieIdx]->criticality =Criticality_reject;
2457       duCfgUpdate->protocolIEs.list.array[ieIdx]->value.present = \
2458          GNBDUConfigurationUpdateIEs__value_PR_Served_Cells_To_Modify_List;
2459       if(buildServCellToModList(&duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.\
2460          Served_Cells_To_Modify_List))
2461          break;
2462
2463       // NOTE :GNB DU SYS INFO:MIB AND SIB1 INFORMATION TO BE BUILT AND FILLED HERE
2464       /*GNB DU ID */
2465       ieIdx++;
2466       duCfgUpdate->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_ID;
2467       duCfgUpdate->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
2468       duCfgUpdate->protocolIEs.list.array[ieIdx]->value.present = \
2469         GNBDUConfigurationUpdateIEs__value_PR_GNB_DU_ID;
2470       duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.size = sizeof(uint8_t);
2471       DU_ALLOC(duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf,\
2472             duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.size);
2473       if(duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf == NULLP)
2474       {
2475          break;
2476       }
2477       duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf[0] = duCfgParam.duId;
2478
2479       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apDuCfg);
2480
2481       /* Encode the DU Config Update type as APER */
2482       memset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
2483       encBufSize = 0;
2484       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apDuCfg, PrepFinalEncBuf, encBuf);
2485
2486       /* Checking encode results */
2487       if(encRetVal.encoded == ENCODE_FAIL)
2488       {
2489          DU_LOG("ERROR  -->  F1AP : Could not encode DUConfigUpdate structure (at %s)\n",\
2490          encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
2491          break;
2492       }
2493       else
2494       {
2495          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for DUConfigUpdate\n");
2496          for(ieIdx =0; ieIdx < encBufSize; ieIdx++)
2497          {
2498             printf("%x",encBuf[ieIdx]);
2499          }
2500       }
2501       /* Sending msg */
2502       if(SendF1APMsg(DU_APP_MEM_REGION, DU_POOL) != ROK)
2503       {
2504          DU_LOG("\nERROR  -->  F1AP : Sending GNB-DU Config Update failed");
2505          break;
2506       }
2507
2508       ret = ROK;
2509       break;
2510    }
2511    FreeDUConfigUpdate(f1apDuCfg);
2512
2513    return ret;
2514 }
2515
2516
2517 /*******************************************************************
2518  *
2519  * @brief free the ULRRCMessageTransfer
2520  *
2521  * @details
2522  *
2523  *    Function : FreeULRRCMessageTransfer
2524  *
2525  *    Functionality: Deallocating the memory of variable allocated in
2526  *                      FreeULRRCMessageTransfer
2527  *
2528  * @params[in]
2529  *
2530  * @return ROK     - void
2531  *
2532  ******************************************************************/
2533 void FreeULRRCMessageTransfer( F1AP_PDU_t *f1apMsg)
2534 {
2535    uint8_t idx1;
2536    ULRRCMessageTransfer_t  *ulRRCMsg;
2537
2538    if(f1apMsg != NULLP)
2539    {
2540       if(f1apMsg->choice.initiatingMessage != NULLP)
2541       {
2542          ulRRCMsg = &f1apMsg->choice.initiatingMessage->value.choice.ULRRCMessageTransfer;
2543          if(ulRRCMsg->protocolIEs.list.array != NULLP)
2544          {
2545             for(idx1=0;idx1<ulRRCMsg->protocolIEs.list.count;idx1++)
2546             {
2547                if(ulRRCMsg->protocolIEs.list.array[idx1] != NULLP)
2548                {
2549                   if(ulRRCMsg->protocolIEs.list.array[idx1]->value.present ==
2550                         ULRRCMessageTransferIEs__value_PR_RRCContainer)
2551                   {
2552                      DU_FREE(ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.buf,
2553                            ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.size);
2554                   }
2555                   DU_FREE(ulRRCMsg->protocolIEs.list.array[idx1],sizeof(ULRRCMessageTransferIEs_t));
2556                }
2557             }
2558             DU_FREE(ulRRCMsg->protocolIEs.list.array,ulRRCMsg->protocolIEs.list.size );
2559          }
2560          DU_FREE(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
2561       }
2562       DU_FREE(f1apMsg,sizeof(F1AP_PDU_t));
2563    }
2564 }
2565 /*******************************************************************
2566  *
2567  * @brief Builds and sends the ULRRCMessageTransfer
2568  *
2569  * @details
2570  *
2571  *    Function : BuildAndSendULRRCMessageTransfer
2572  *
2573  *    Functionality: Constructs the UL RRC Message Transfer and sends
2574  *                   it to the CU through SCTP.
2575  *
2576  * @params[in]
2577  *
2578  * @return ROK     - success
2579  *         RFAILED - failure
2580  *
2581  * ****************************************************************/
2582 uint8_t BuildAndSendULRRCMessageTransfer(DuUeCb  ueCb, uint8_t lcId, \
2583       uint16_t msgLen, uint8_t *rrcMsg)
2584 {
2585    uint8_t   elementCnt =0;
2586    uint8_t   idx1 =0;
2587    uint8_t   idx =0;
2588    F1AP_PDU_t                   *f1apMsg = NULLP;
2589    ULRRCMessageTransfer_t       *ulRRCMsg = NULLP;
2590    asn_enc_rval_t               encRetVal;        /* Encoder return value */
2591    uint8_t ret =RFAILED;
2592
2593    memset(&encRetVal, 0, sizeof(asn_enc_rval_t));
2594
2595    while(true)
2596    {
2597       DU_LOG("\n INFO   -->  F1AP : Building UL RRC Message Transfer Message\n");
2598
2599       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
2600       if(f1apMsg == NULLP)
2601       {
2602          DU_LOG(" ERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
2603          break;
2604       }
2605       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
2606       DU_ALLOC(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
2607       if(f1apMsg->choice.initiatingMessage == NULLP)
2608       {
2609          DU_LOG(" ERROR  -->  F1AP : Memory allocation for      F1AP-PDU failed");
2610          break;
2611       }
2612       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_ULRRCMessageTransfer;
2613       f1apMsg->choice.initiatingMessage->criticality = Criticality_ignore;
2614       f1apMsg->choice.initiatingMessage->value.present = \
2615                                                          InitiatingMessage__value_PR_ULRRCMessageTransfer;
2616       ulRRCMsg =
2617          &f1apMsg->choice.initiatingMessage->value.choice.ULRRCMessageTransfer;
2618       elementCnt = 4;
2619       ulRRCMsg->protocolIEs.list.count = elementCnt;
2620       ulRRCMsg->protocolIEs.list.size = \
2621                                         elementCnt * sizeof(ULRRCMessageTransferIEs_t *);
2622
2623       /* Initialize the F1Setup members */
2624       DU_ALLOC(ulRRCMsg->protocolIEs.list.array, ulRRCMsg->protocolIEs.list.size);
2625       if(ulRRCMsg->protocolIEs.list.array == NULLP)
2626       {
2627          DU_LOG(" ERROR  -->  F1AP : Memory allocation for UL RRC MessageTransferIEs failed");
2628          break;
2629       }
2630       for(idx=0; idx<elementCnt; idx++)
2631       {
2632          DU_ALLOC(ulRRCMsg->protocolIEs.list.array[idx],sizeof(ULRRCMessageTransferIEs_t));
2633          if(ulRRCMsg->protocolIEs.list.array[idx] == NULLP)
2634          {
2635             break;
2636          }
2637       }
2638
2639       idx1 = 0;
2640
2641       /*GNB CU UE F1AP ID*/
2642       ulRRCMsg->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
2643       ulRRCMsg->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
2644       ulRRCMsg->protocolIEs.list.array[idx1]->value.present = \
2645                                                               ULRRCMessageTransferIEs__value_PR_GNB_CU_UE_F1AP_ID;
2646       ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.GNB_CU_UE_F1AP_ID = ueCb.gnbCuUeF1apId;
2647
2648       /*GNB DU UE F1AP ID*/
2649       idx1++;
2650       ulRRCMsg->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
2651       ulRRCMsg->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
2652       ulRRCMsg->protocolIEs.list.array[idx1]->value.present = \
2653                                                               ULRRCMessageTransferIEs__value_PR_GNB_DU_UE_F1AP_ID;
2654       ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.GNB_DU_UE_F1AP_ID = ueCb.gnbDuUeF1apId;
2655
2656       /*SRBID*/
2657       idx1++;
2658       ulRRCMsg->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_SRBID;
2659       ulRRCMsg->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
2660       ulRRCMsg->protocolIEs.list.array[idx1]->value.present = \
2661                                                               ULRRCMessageTransferIEs__value_PR_SRBID;
2662       ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.SRBID = lcId;
2663
2664       /*RRCContainer*/
2665       idx1++;
2666       ulRRCMsg->protocolIEs.list.array[idx1]->id  = ProtocolIE_ID_id_RRCContainer;
2667       ulRRCMsg->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
2668       ulRRCMsg->protocolIEs.list.array[idx1]->value.present = \
2669                                                               ULRRCMessageTransferIEs__value_PR_RRCContainer;
2670       ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.size = msgLen;
2671       DU_ALLOC(ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.buf,
2672             ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.size)
2673       if(!ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.buf)
2674       {
2675          DU_LOG(" ERROR  -->  F1AP : Memory allocation for BuildAndSendULRRCMessageTransfer failed");
2676          break;
2677       }
2678       memset(ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.buf, 0, msgLen);
2679       memcpy(ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.buf, \
2680             rrcMsg, ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.size);
2681
2682       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
2683
2684       /* Encode the F1SetupRequest type as APER */
2685       memset(encBuf, 0, ENC_BUF_MAX_LEN);
2686       encBufSize = 0;
2687       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
2688             encBuf);
2689       /* Encode results */
2690       if(encRetVal.encoded == ENCODE_FAIL)
2691       {
2692          DU_LOG( "\nERROR  -->  F1AP : Could not encode ULRRCMessageTransfer structure (at %s)\n",\
2693                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
2694          break;
2695       }
2696       else
2697       {
2698          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for ULRRCMessageTransfer\n");
2699          for(int i=0; i< encBufSize; i++)
2700          {
2701             printf("%x",encBuf[i]);
2702          }
2703       }
2704
2705       /* Sending  msg  */
2706       if(SendF1APMsg(DU_APP_MEM_REGION,DU_POOL) !=      ROK)
2707       {
2708          DU_LOG("\nERROR  -->   F1AP : Sending  UL RRC Message Transfer Failed");
2709          break;
2710       }
2711       ret = ROK;
2712       break;
2713    }
2714    FreeULRRCMessageTransfer(f1apMsg);
2715
2716    return ret;
2717 }/* End of BuildAndSendULRRCMessageTransfer*/
2718
2719 /*******************************************************************
2720  *
2721  * @brief Builds tag config
2722  *
2723  * @details
2724  *
2725  *    Function : BuildTagConfig
2726  *
2727  *    Functionality: Builds tag config in MacCellGroupConfig
2728  *
2729  * @params[in] TAG_Config *tag_Config
2730  *
2731  * @return ROK     - success
2732  *         RFAILED - failure
2733  *
2734  * ****************************************************************/
2735 uint8_t BuildTagConfig(struct TAG_Config *tagConfig)
2736 {
2737    struct TAG_Config__tag_ToAddModList *tagList;
2738    uint8_t                     idx, elementCnt;
2739
2740    tagConfig->tag_ToReleaseList = NULLP;
2741    tagConfig->tag_ToAddModList = NULLP;
2742    DU_ALLOC(tagConfig->tag_ToAddModList, sizeof(struct TAG_Config__tag_ToAddModList));
2743    if(!tagConfig->tag_ToAddModList)
2744    {
2745       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildTagConfig");
2746       return RFAILED;
2747    }
2748
2749    elementCnt = 1; //ODU_VALUE_ONE;
2750    tagList = tagConfig->tag_ToAddModList;
2751    tagList->list.count = elementCnt;
2752    tagList->list.size  =  elementCnt * sizeof(struct TAG *);
2753
2754    tagList->list.array = NULLP;
2755    DU_ALLOC(tagList->list.array, tagList->list.size);
2756    if(!tagList->list.array)
2757    {
2758       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildTagConfig");
2759       return RFAILED;
2760    }
2761
2762    for(idx=0; idx<tagList->list.count; idx++)
2763    {
2764       tagList->list.array[idx] = NULLP;
2765       DU_ALLOC(tagList->list.array[idx], sizeof(struct TAG));
2766       if(!tagList->list.array[idx])
2767       {
2768          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildTagConfig");
2769          return RFAILED;
2770       }
2771    }
2772
2773    idx = 0;
2774    tagList->list.array[idx]->tag_Id = TAG_ID;
2775    tagList->list.array[idx]->timeAlignmentTimer = TIME_ALIGNMENT_TMR;
2776
2777    return ROK;
2778 }
2779
2780 /*******************************************************************
2781  *
2782  * @brief Builds PHR Config
2783  *
2784  * @details
2785  *
2786  *    Function : BuildPhrConfig
2787  *
2788  *    Functionality: Builds phrConfig in MacCellGroupConfig
2789  *
2790  * @params[in] PHR Config *
2791  *
2792  * @return ROK     - success
2793  *         RFAILED - failure
2794  *
2795  * ****************************************************************/
2796 uint8_t BuildPhrConfig(struct MAC_CellGroupConfig__phr_Config *phrConfig)
2797 {
2798
2799    phrConfig->present = MAC_CellGroupConfig__phr_Config_PR_setup;
2800    phrConfig->choice.setup = NULLP;
2801    DU_ALLOC(phrConfig->choice.setup, sizeof(struct PHR_Config));
2802    if(!phrConfig->choice.setup)
2803    {
2804       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildPhrConfig");
2805       return RFAILED;
2806    }
2807
2808    phrConfig->choice.setup->phr_PeriodicTimer        = PHR_PERIODIC_TMR;
2809    phrConfig->choice.setup->phr_ProhibitTimer        = PHR_PROHIBHIT_TMR;
2810    phrConfig->choice.setup->phr_Tx_PowerFactorChange = PHR_PWR_FACTOR_CHANGE;
2811    phrConfig->choice.setup->multiplePHR              = false;
2812    phrConfig->choice.setup->dummy                    = false;
2813    phrConfig->choice.setup->phr_Type2OtherCell       = false;
2814    phrConfig->choice.setup->phr_ModeOtherCG          = PHR_MODE_OTHER_CG;
2815
2816    return ROK;
2817 }
2818
2819 /*******************************************************************
2820  *
2821  * @brief Builds BSR Config
2822  *
2823  * @details
2824  *
2825  *    Function : BuildBsrConfig
2826  *
2827  *    Functionality: Builds BuildBsrConfig in MacCellGroupConfig
2828  *
2829  * @params[in] BSR_Config *bsrConfig
2830  *
2831  * @return ROK     - success
2832  *         RFAILED - failure
2833  *
2834  * ****************************************************************/
2835 uint8_t BuildBsrConfig(struct BSR_Config *bsrConfig)
2836 {
2837    bsrConfig->periodicBSR_Timer = PERIODIC_BSR_TMR;
2838    bsrConfig->retxBSR_Timer     = RETX_BSR_TMR;
2839    bsrConfig->logicalChannelSR_DelayTimer = NULLP;
2840
2841    return ROK;
2842 }
2843
2844 /*******************************************************************
2845  *
2846  * @brief Builds scheduling request config
2847  *
2848  * @details
2849  *
2850  *    Function : BuildSchedulingReqConfig
2851  *
2852  *    Functionality: Builds BuildSchedulingReqConfig in MacCellGroupConfig
2853  *
2854  * @params[in] SchedulingRequestConfig *schedulingRequestConfig
2855  *
2856  * @return ROK     - success
2857  *         RFAILED - failure
2858  *
2859  * ****************************************************************/
2860 uint8_t BuildSchedulingReqConfig(struct SchedulingRequestConfig *schedulingRequestConfig)
2861 {
2862    struct SchedulingRequestConfig__schedulingRequestToAddModList *schReqList;
2863    uint8_t                     idx, elementCnt;
2864
2865    schedulingRequestConfig->schedulingRequestToAddModList = NULLP;
2866    DU_ALLOC(schedulingRequestConfig->schedulingRequestToAddModList,
2867          sizeof(struct SchedulingRequestConfig__schedulingRequestToAddModList));
2868    if(!schedulingRequestConfig->schedulingRequestToAddModList)
2869    {
2870       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSchedulingReqConfig");
2871       return RFAILED;
2872    }
2873
2874    elementCnt = 1; //ODU_VALUE_ONE;
2875    schReqList = schedulingRequestConfig->schedulingRequestToAddModList;
2876    schReqList->list.count = elementCnt;
2877    schReqList->list.size  = elementCnt * sizeof(struct SchedulingRequestToAddMod *);
2878
2879    schReqList->list.array = NULLP;
2880    DU_ALLOC(schReqList->list.array, schReqList->list.size);
2881    if(!schReqList->list.array)
2882    {
2883       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSchedulingReqConfig");
2884       return RFAILED;
2885    }
2886
2887    for(idx=0;idx<schReqList->list.count; idx++)
2888    {
2889       schReqList->list.array[idx] = NULLP;
2890       DU_ALLOC(schReqList->list.array[idx], sizeof(struct SchedulingRequestToAddMod));
2891       if(!schReqList->list.array[idx])
2892       {
2893          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSchedulingReqConfig");
2894          return RFAILED;
2895       }
2896    }
2897
2898    idx = 0;
2899    schReqList->list.array[idx]->schedulingRequestId = SCH_REQ_ID;
2900
2901    schReqList->list.array[idx]->sr_ProhibitTimer = NULLP;
2902    DU_ALLOC(schReqList->list.array[idx]->sr_ProhibitTimer, sizeof(long));
2903    if(!schReqList->list.array[idx]->sr_ProhibitTimer)
2904    {
2905       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSchedulingReqConfig");
2906       return RFAILED;
2907    }
2908    *(schReqList->list.array[idx]->sr_ProhibitTimer) = SR_PROHIBIT_TMR;
2909    schReqList->list.array[idx]->sr_TransMax = SR_TRANS_MAX;
2910    schedulingRequestConfig->schedulingRequestToReleaseList = NULLP;
2911
2912    return ROK;
2913 }
2914
2915 /*******************************************************************
2916  *
2917  * @brief Builds RLC Config
2918  *
2919  * @details
2920  *
2921  *    Function : BuildRlcConfig
2922  *
2923  *    Functionality: Builds RLC Config in BuildRlcBearerToAddModList
2924  *
2925  * @params[in] RLC_Config *rlcConfig
2926  *
2927  * @return ROK     - success
2928  *         RFAILED - failure
2929  *
2930  * ****************************************************************/
2931 uint8_t BuildRlcConfig(struct RLC_Config *rlcConfig)
2932 {
2933
2934    rlcConfig->present = RLC_Config_PR_am;
2935
2936    rlcConfig->choice.am = NULLP;
2937    DU_ALLOC(rlcConfig->choice.am, sizeof(struct RLC_Config__am));
2938    if(!rlcConfig->choice.am)
2939    {
2940       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfig");
2941       return RFAILED;
2942    }
2943
2944    /* UL */
2945    rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength = NULLP;
2946    DU_ALLOC(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
2947    if(!rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength)
2948    {
2949       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfig");
2950       return RFAILED;
2951    }
2952    *(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength) = SN_FIELD_LEN;
2953    rlcConfig->choice.am->ul_AM_RLC.t_PollRetransmit  = T_POLL_RETRANSMIT;
2954    rlcConfig->choice.am->ul_AM_RLC.pollPDU           = POLL_PDU;
2955    rlcConfig->choice.am->ul_AM_RLC.pollByte          = POLL_BYTE;
2956    rlcConfig->choice.am->ul_AM_RLC.maxRetxThreshold  = MAX_RETX_THRESHOLD;
2957
2958    /* DL */
2959    rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength = NULLP;
2960    DU_ALLOC(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
2961    if(!rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength)
2962    {
2963       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfig");
2964       return RFAILED;
2965    }
2966    *(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength) = SN_FIELD_LEN;
2967    rlcConfig->choice.am->dl_AM_RLC.t_Reassembly      = T_REASSEMBLY;
2968    rlcConfig->choice.am->dl_AM_RLC.t_StatusProhibit  = T_STATUS_PROHIBHIT;
2969
2970    return ROK;
2971 }
2972
2973 /*******************************************************************
2974  *
2975  * @brief Builds MAC LC Config
2976  *
2977  * @details
2978  *
2979  *    Function : BuildMacLCConfig
2980  *
2981  *    Functionality: Builds MAC LC Config in BuildRlcBearerToAddModList
2982  *
2983  * @params[in] struct LogicalChannelConfig macLcConfig
2984  *
2985  * @return ROK     - success
2986  *         RFAILED - failure
2987  *
2988  * ****************************************************************/
2989 uint8_t BuildMacLCConfig(struct LogicalChannelConfig *macLcConfig)
2990 {
2991
2992    macLcConfig->ul_SpecificParameters = NULLP;
2993    DU_ALLOC(macLcConfig->ul_SpecificParameters, sizeof(struct LogicalChannelConfig__ul_SpecificParameters));
2994    if(!macLcConfig->ul_SpecificParameters)
2995    {
2996       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacLCConfig");
2997       return RFAILED;
2998    }
2999
3000    macLcConfig->ul_SpecificParameters->priority = MAC_LC_PRIORITY;
3001    macLcConfig->ul_SpecificParameters->prioritisedBitRate =     PRIORTISIED_BIT_RATE;
3002    macLcConfig->ul_SpecificParameters->bucketSizeDuration =     BUCKET_SIZE_DURATION;
3003    macLcConfig->ul_SpecificParameters->allowedServingCells = NULLP;
3004    macLcConfig->ul_SpecificParameters->allowedSCS_List = NULLP;
3005    macLcConfig->ul_SpecificParameters->maxPUSCH_Duration = NULLP;
3006    macLcConfig->ul_SpecificParameters->configuredGrantType1Allowed = NULLP;
3007
3008    macLcConfig->ul_SpecificParameters->logicalChannelGroup = NULLP;
3009    DU_ALLOC(macLcConfig->ul_SpecificParameters->logicalChannelGroup,    sizeof(long));
3010    if(!macLcConfig->ul_SpecificParameters->logicalChannelGroup)
3011    {
3012       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacLCConfig");
3013       return RFAILED;
3014    }
3015    *(macLcConfig->ul_SpecificParameters->logicalChannelGroup) = LC_GRP;
3016
3017    macLcConfig->ul_SpecificParameters->schedulingRequestID = NULLP;
3018    DU_ALLOC(macLcConfig->ul_SpecificParameters->schedulingRequestID,    sizeof(SchedulingRequestId_t));
3019    if(!macLcConfig->ul_SpecificParameters->schedulingRequestID)
3020    {
3021       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacLCConfig");
3022       return RFAILED;
3023    }
3024    *(macLcConfig->ul_SpecificParameters->schedulingRequestID) = SCH_REQ_ID;
3025
3026    macLcConfig->ul_SpecificParameters->logicalChannelSR_Mask = false;
3027    macLcConfig->ul_SpecificParameters->logicalChannelSR_DelayTimerApplied = false;
3028    macLcConfig->ul_SpecificParameters->bitRateQueryProhibitTimer = NULLP;
3029
3030    return ROK;
3031 }
3032
3033 /*******************************************************************
3034  *
3035  * @brief Builds RLC Bearer to Add/Mod list
3036  *
3037  * @details
3038  *
3039  *    Function :BuildRlcBearerToAddModList
3040  *
3041  *    Functionality: Builds RLC Bearer to Add/Mod list in DuToCuRrcContainer
3042  *
3043  * @params[in] rlc_BearerToAddModList
3044  *
3045  * @return ROK     - success
3046  *         RFAILED - failure
3047  *
3048  * ****************************************************************/
3049 uint8_t BuildRlcBearerToAddModList(struct CellGroupConfigRrc__rlc_BearerToAddModList *rlcBearerList)
3050 {
3051    uint8_t                     idx, elementCnt;
3052
3053    elementCnt = 1;
3054    rlcBearerList->list.count = elementCnt;
3055    rlcBearerList->list.size  = elementCnt * sizeof(struct RLC_BearerConfig *);
3056
3057    rlcBearerList->list.array = NULLP;
3058    DU_ALLOC(rlcBearerList->list.array, rlcBearerList->list.size);
3059    if(!rlcBearerList->list.array)
3060    {
3061       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
3062       return RFAILED;
3063    }
3064
3065    for(idx=0; idx<rlcBearerList->list.count; idx++)
3066    {
3067       rlcBearerList->list.array[idx] = NULLP;
3068       DU_ALLOC(rlcBearerList->list.array[idx], sizeof(struct RLC_BearerConfig));
3069       if(!rlcBearerList->list.array[idx])
3070       {
3071          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
3072          return RFAILED;
3073       }
3074    }
3075
3076    idx = 0;
3077    rlcBearerList->list.array[idx]->logicalChannelIdentity = SRB1_LCID;
3078
3079    DU_ALLOC(rlcBearerList->list.array[idx]->servedRadioBearer, \
3080       sizeof(struct RLC_BearerConfig__servedRadioBearer));
3081    if(!rlcBearerList->list.array[idx]->servedRadioBearer)
3082    {
3083       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
3084       return RFAILED;
3085    }
3086
3087    rlcBearerList->list.array[idx]->servedRadioBearer->present = \
3088       RLC_BearerConfig__servedRadioBearer_PR_srb_Identity;
3089    rlcBearerList->list.array[idx]->servedRadioBearer->choice.srb_Identity = \
3090       SRB1_LCID;
3091
3092    rlcBearerList->list.array[idx]->reestablishRLC = NULLP;
3093    rlcBearerList->list.array[idx]->rlc_Config = NULLP;
3094    DU_ALLOC(rlcBearerList->list.array[idx]->rlc_Config, sizeof(struct RLC_Config));
3095    if(!rlcBearerList->list.array[idx]->rlc_Config)
3096    {
3097       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
3098       return RFAILED;
3099    }
3100
3101    if(BuildRlcConfig(rlcBearerList->list.array[idx]->rlc_Config) != ROK)
3102    {
3103       DU_LOG("\nERROR  -->  F1AP : BuildRlcConfig failed");
3104       return RFAILED;
3105    }
3106
3107    rlcBearerList->list.array[idx]->mac_LogicalChannelConfig = NULLP;
3108    DU_ALLOC(rlcBearerList->list.array[idx]->mac_LogicalChannelConfig, \
3109       sizeof(struct LogicalChannelConfig));
3110    if(!rlcBearerList->list.array[idx]->mac_LogicalChannelConfig)
3111    {
3112       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
3113       return RFAILED;
3114    }
3115
3116    if(BuildMacLCConfig(rlcBearerList->list.array[idx]->mac_LogicalChannelConfig) != ROK)
3117    {
3118       DU_LOG("\nERROR  -->  F1AP : BuildMacLCConfig failed");
3119       return RFAILED;
3120    }
3121
3122    return ROK;
3123 }
3124
3125 /*******************************************************************
3126  *
3127  * @brief Build Control resource set to add/modify list
3128  *
3129  * @details
3130  *
3131  *    Function : BuildControlRSetToAddModList
3132  *
3133  *    Functionality: Build Control resource set to add/modify list
3134  *
3135  * @params[in]
3136  * struct PDCCH_Config__controlResourceSetToAddModList *controlRSetList
3137  *
3138  * @return ROK     - success
3139  *         RFAILED - failure
3140  *
3141  * ****************************************************************/
3142    uint8_t BuildControlRSetToAddModList
3143 (
3144  struct PDCCH_Config__controlResourceSetToAddModList *controlRSetList
3145  )
3146 {
3147    uint8_t idx;
3148    uint8_t elementCnt;
3149    uint8_t numBytes, bitsUnused;
3150    struct ControlResourceSet *controlRSet;
3151    uint8_t freqDomainResource[FREQ_DOM_RSRC_SIZE] = {0};
3152    uint8_t coreset0EndPrb, coreset1StartPrb, coreset1NumPrb;
3153
3154
3155    elementCnt = 1;
3156    controlRSetList->list.count = elementCnt;
3157    controlRSetList->list.size = \
3158                                 elementCnt * sizeof(struct ControlResourceSet *);
3159
3160    controlRSetList->list.array = NULLP;
3161    DU_ALLOC(controlRSetList->list.array, controlRSetList->list.size);
3162    if(!controlRSetList->list.array)
3163    {
3164       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3165       return RFAILED;
3166    }
3167
3168    for(idx = 0; idx < elementCnt; idx++)
3169    {
3170       controlRSetList->list.array[idx] = NULLP;
3171       DU_ALLOC(controlRSetList->list.array[idx], sizeof(struct ControlResourceSet));
3172       if(!controlRSetList->list.array[idx])
3173       {
3174          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3175          return RFAILED;
3176       }
3177    }
3178
3179    idx=0;
3180    controlRSet = controlRSetList->list.array[idx];
3181
3182    controlRSet->controlResourceSetId = PDCCH_CTRL_RSRC_SET_ONE_ID;
3183
3184    /* size 6 bytes
3185     * 3 LSBs unsued
3186     * Bit string stored ff0000000000
3187     */
3188    numBytes = 6;
3189    bitsUnused = 3;
3190    controlRSet->frequencyDomainResources.size = numBytes * sizeof(uint8_t);
3191
3192    controlRSet->frequencyDomainResources.buf = NULLP;
3193    DU_ALLOC(controlRSet->frequencyDomainResources.buf, \
3194          controlRSet->frequencyDomainResources.size);
3195    if(!controlRSet->frequencyDomainResources.buf)
3196    {
3197       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3198       return RFAILED;
3199    }
3200
3201    memset(controlRSet->frequencyDomainResources.buf, 0, FREQ_DOM_RSRC_SIZE);
3202    coreset0EndPrb = CORESET0_END_PRB;
3203    coreset1StartPrb = coreset0EndPrb + 6;
3204    coreset1NumPrb = CORESET1_NUM_PRB;
3205    /* calculate the PRBs */
3206    freqDomRscAllocType0(((coreset1StartPrb)/6), (coreset1NumPrb/6), freqDomainResource);
3207    memcpy(controlRSet->frequencyDomainResources.buf, freqDomainResource, FREQ_DOM_RSRC_SIZE);
3208    controlRSet->frequencyDomainResources.bits_unused = bitsUnused;
3209
3210    controlRSet->duration = PDCCH_CTRL_RSRC_SET_ONE_DURATION;
3211    controlRSet->cce_REG_MappingType.present = \
3212                                               ControlResourceSet__cce_REG_MappingType_PR_nonInterleaved;
3213
3214    controlRSet->precoderGranularity = PDCCH_CTRL_RSRC_SET_ONE_PRECOD_GRANULARITY;
3215    controlRSet->tci_StatesPDCCH_ToAddList = NULLP;
3216    controlRSet->tci_StatesPDCCH_ToReleaseList = NULLP;
3217    controlRSet->tci_PresentInDCI = NULLP;
3218 #if 0
3219    uint8_t tciStateIdx;
3220
3221    DU_ALLOC(controlRset->tci_StatesPDCCH_ToAddList, \
3222          sizeof(struct ControlResourceSet__tci_StatesPDCCH_ToAddList));
3223    if(!controlRset->tci_StatesPDCCH_ToAddList)
3224    {
3225       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3226       return RFAILED;
3227    }
3228
3229    elementCnt = 1;
3230    controlRset->tci_StatesPDCCH_ToAddList->list.count = elementCnt;
3231    controlRset->tci_StatesPDCCH_ToAddList->list.size = elementCnt * sizeof(TCI_StateId_t *);
3232    DU_ALLOC(controlRset->tci_StatesPDCCH_ToAddList->list.array, \
3233          controlRset->tci_StatesPDCCH_ToAddList->list.size)
3234       if(!controlRset->tci_StatesPDCCH_ToAddList->list.array)
3235       {
3236          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3237          return RFAILED;
3238       }
3239
3240    for(tciStateIdx = 0; tciStateIdx <elementCntl; tciStateIdx++)
3241    {
3242       DU_ALLOC(controlRset->tci_StatesPDCCH_ToAddList->list.array[tciStateIdx], sizeof(TCI_StateId_t));
3243       if(!controlRset->tci_StatesPDCCH_ToAddList->list.array[tciStateIdx])
3244       {
3245          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3246          return RFAILED;
3247       }
3248    }
3249
3250    tciStateIdx = 0;
3251    /* TODO */
3252    *(controlRset->tci_StatesPDCCH_ToAddList->list.array[tciStateIdx]);
3253
3254    DU_ALLOC(controlRset->tci_PresentInDCI, sizeof(long));
3255    if(!controlRset->tci_PresentInDCI)
3256    {
3257       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3258       return RFAILED;
3259    }
3260    /* TODO */
3261    *(controlRset->tci_PresentInDCI);
3262 #endif
3263
3264    controlRSet->pdcch_DMRS_ScramblingID = NULLP;
3265    DU_ALLOC(controlRSet->pdcch_DMRS_ScramblingID, sizeof(long));
3266    if(!controlRSet->pdcch_DMRS_ScramblingID)
3267    {
3268       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3269       return RFAILED;
3270    }
3271    *(controlRSet->pdcch_DMRS_ScramblingID) = SCRAMBLING_ID;
3272
3273    return ROK;
3274 } /* End BuildControlRSetToAddModList */
3275
3276 /*******************************************************************
3277  *
3278  * @brief Build search space to add/modify list
3279  *
3280  * @details
3281  *
3282  *    Function : BuildSearchSpcToAddModList
3283  *
3284  *    Functionality: Build search space to add/modify list
3285  *
3286  * @params[in]
3287  * @return ROK     - success
3288  *         RFAILED - failure
3289  *
3290  * ****************************************************************/
3291    uint8_t BuildSearchSpcToAddModList
3292 (
3293  struct PDCCH_Config__searchSpacesToAddModList *searchSpcList
3294  )
3295 {
3296    uint8_t idx;
3297    uint8_t numBytes;
3298    uint8_t byteIdx;
3299    uint8_t bitsUnused;
3300    uint8_t elementCnt;
3301    struct SearchSpace *searchSpc;
3302
3303    elementCnt = 1;
3304    searchSpcList->list.count = elementCnt;
3305    searchSpcList->list.size = elementCnt * sizeof(struct SearchSpace *);
3306
3307    searchSpcList->list.array = NULLP;
3308    DU_ALLOC(searchSpcList->list.array, searchSpcList->list.size);
3309    if(!searchSpcList->list.array)
3310    {
3311       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3312       return RFAILED;
3313    }
3314
3315    for(idx = 0; idx < elementCnt; idx++)
3316    {
3317       searchSpcList->list.array[idx] = NULLP;
3318       DU_ALLOC(searchSpcList->list.array[idx], sizeof(struct SearchSpace));
3319       if(!searchSpcList->list.array[idx])
3320       {
3321          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3322          return RFAILED;
3323       }
3324    }
3325
3326    idx = 0;
3327    searchSpc = searchSpcList->list.array[idx];
3328
3329    searchSpc->searchSpaceId = PDCCH_SRCH_SPC_TWO_ID;
3330
3331    searchSpc->controlResourceSetId = NULLP;
3332    DU_ALLOC(searchSpc->controlResourceSetId, sizeof(ControlResourceSetId_t));
3333    if(!searchSpc->controlResourceSetId)
3334    {
3335       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3336       return RFAILED;
3337    }
3338    *(searchSpc->controlResourceSetId) = PDCCH_CTRL_RSRC_SET_ONE_ID;
3339
3340    searchSpc->monitoringSlotPeriodicityAndOffset = NULLP;
3341    DU_ALLOC(searchSpc->monitoringSlotPeriodicityAndOffset, \
3342          sizeof(struct SearchSpace__monitoringSlotPeriodicityAndOffset));
3343    if(!searchSpc->monitoringSlotPeriodicityAndOffset)
3344    {
3345       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3346       return RFAILED;
3347    }
3348    searchSpc->monitoringSlotPeriodicityAndOffset->present = \
3349                                                             SearchSpace__monitoringSlotPeriodicityAndOffset_PR_sl1;
3350
3351    searchSpc->duration = NULLP;
3352    searchSpc->monitoringSymbolsWithinSlot = NULLP;
3353    DU_ALLOC(searchSpc->monitoringSymbolsWithinSlot, sizeof(BIT_STRING_t));
3354    if(!searchSpc->monitoringSymbolsWithinSlot)
3355    {
3356       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3357       return RFAILED;
3358    }
3359
3360    /* Values taken from reference logs :
3361     * size 2 bytes
3362     * 2 LSBs unsued
3363     * Bit string stores 8000
3364     */
3365    numBytes = 2;
3366    bitsUnused = 2;
3367
3368    searchSpc->monitoringSymbolsWithinSlot->size = numBytes * sizeof(uint8_t);
3369    searchSpc->monitoringSymbolsWithinSlot->buf = NULLP;
3370    DU_ALLOC(searchSpc->monitoringSymbolsWithinSlot->buf, \
3371          searchSpc->monitoringSymbolsWithinSlot->size);
3372    if(!searchSpc->monitoringSymbolsWithinSlot->buf)
3373    {
3374       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3375       return RFAILED;
3376    }
3377
3378    byteIdx = 0;
3379    searchSpc->monitoringSymbolsWithinSlot->buf[byteIdx++] = \
3380                                                             PDCCH_SYMBOL_WITHIN_SLOT /* setting MSB to 128 i.e. 0x80 */;
3381    searchSpc->monitoringSymbolsWithinSlot->buf[byteIdx++] = 0;
3382    searchSpc->monitoringSymbolsWithinSlot->bits_unused = bitsUnused;
3383
3384    searchSpc->nrofCandidates = NULLP;
3385    DU_ALLOC(searchSpc->nrofCandidates, sizeof(struct SearchSpace__nrofCandidates));
3386    if(!searchSpc->nrofCandidates)
3387    {
3388       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3389       return RFAILED;
3390    }
3391
3392    searchSpc->nrofCandidates->aggregationLevel1 = \
3393                                                   PDCCH_SRCH_SPC_TWO_AGG_LVL1_CANDIDATE;
3394    searchSpc->nrofCandidates->aggregationLevel2 = \
3395                                                   PDCCH_SRCH_SPC_TWO_AGG_LVL2_CANDIDATE;
3396    searchSpc->nrofCandidates->aggregationLevel4 = \
3397                                                   PDCCH_SRCH_SPC_TWO_AGG_LVL4_CANDIDATE;
3398    searchSpc->nrofCandidates->aggregationLevel8 = \
3399                                                   PDCCH_SRCH_SPC_TWO_AGG_LVL8_CANDIDATE;
3400    searchSpc->nrofCandidates->aggregationLevel16 = \
3401                                                    PDCCH_SRCH_SPC_TWO_AGG_LVL16_CANDIDATE;
3402
3403    searchSpc->searchSpaceType = NULLP;
3404    DU_ALLOC(searchSpc->searchSpaceType, sizeof(struct SearchSpace__searchSpaceType));
3405    if(!searchSpc->searchSpaceType)
3406    {
3407       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3408       return RFAILED;
3409    }
3410
3411    searchSpc->searchSpaceType->present = SearchSpace__searchSpaceType_PR_ue_Specific;
3412
3413    searchSpc->searchSpaceType->choice.ue_Specific = NULLP;
3414    DU_ALLOC(searchSpc->searchSpaceType->choice.ue_Specific, \
3415          sizeof(struct SearchSpace__searchSpaceType__ue_Specific));
3416    if(!searchSpc->searchSpaceType->choice.ue_Specific)
3417    {
3418       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3419       return RFAILED;
3420    }
3421    searchSpc->searchSpaceType->choice.ue_Specific->dci_Formats = \
3422                                                                  PDCCH_SRCH_SPC_TWO_UE_SPEC_DCI_FORMAT;
3423
3424    return ROK;
3425 }/* End BuildSearchSpcToAddModList */
3426
3427 /*******************************************************************
3428  *
3429  * @brief Builds BWP DL dedicated PDCCH config
3430  *
3431  * @details
3432  *
3433  *    Function : BuildBWPDlDedPdcchCfg
3434  *
3435  *    Functionality: Builds BWP DL dedicated PDCCH config
3436  *
3437  * @params[in] struct PDCCH_Config *pdcchCfg
3438  *
3439  * @return ROK     - success
3440  *         RFAILED - failure
3441  *
3442  * ****************************************************************/
3443 uint8_t BuildBWPDlDedPdcchCfg(struct PDCCH_Config *pdcchCfg)
3444 {
3445    pdcchCfg->controlResourceSetToAddModList = NULLP;
3446    DU_ALLOC(pdcchCfg->controlResourceSetToAddModList, \
3447          sizeof(struct PDCCH_Config__controlResourceSetToAddModList));
3448    if(!pdcchCfg->controlResourceSetToAddModList)
3449    {
3450       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdcchCfg");
3451       return RFAILED;
3452    }
3453
3454    if(BuildControlRSetToAddModList(pdcchCfg->controlResourceSetToAddModList) != ROK)
3455    {
3456       return RFAILED;
3457    }
3458
3459    pdcchCfg->controlResourceSetToReleaseList = NULLP;
3460
3461    pdcchCfg->searchSpacesToAddModList = NULLP;
3462    DU_ALLOC(pdcchCfg->searchSpacesToAddModList, \
3463          sizeof(struct PDCCH_Config__searchSpacesToAddModList));
3464    if(!pdcchCfg->searchSpacesToAddModList)
3465    {
3466       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdcchCfg");
3467       return RFAILED;
3468    }
3469
3470    if(BuildSearchSpcToAddModList(pdcchCfg->searchSpacesToAddModList) != ROK)
3471    {
3472       return RFAILED;
3473    }
3474
3475    pdcchCfg->searchSpacesToReleaseList = NULLP;
3476    pdcchCfg->downlinkPreemption = NULLP;
3477    pdcchCfg->tpc_PUSCH = NULLP;
3478    pdcchCfg->tpc_PUCCH = NULLP;
3479    pdcchCfg->tpc_SRS = NULLP;
3480
3481    return ROK;
3482 }
3483
3484 /*******************************************************************
3485  *
3486  * @brief Builds DMRS DL PDSCH Mapping type A
3487  *
3488  * @details
3489  *
3490  *    Function : BuildDMRSDLPdschMapTypeA
3491  *
3492  *    Functionality: Builds DMRS DL PDSCH Mapping type A
3493  *
3494  * @params[in]
3495  * struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA *dmrsDlCfg
3496  * @return ROK     - success
3497  *         RFAILED - failure
3498  *
3499  * ****************************************************************/
3500    uint8_t BuildDMRSDLPdschMapTypeA
3501 (
3502  struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA *dmrsDlCfg
3503  )
3504 {
3505    dmrsDlCfg->present = PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA_PR_setup;
3506    dmrsDlCfg->choice.setup = NULLP;
3507    DU_ALLOC(dmrsDlCfg->choice.setup, sizeof(struct DMRS_DownlinkConfig));
3508    if(!dmrsDlCfg->choice.setup)
3509    {
3510       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
3511       return RFAILED;
3512    }
3513
3514    dmrsDlCfg->choice.setup->dmrs_Type = NULLP;
3515    dmrsDlCfg->choice.setup->dmrs_AdditionalPosition = NULLP;
3516    DU_ALLOC(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition, sizeof(long));
3517    if(!dmrsDlCfg->choice.setup->dmrs_AdditionalPosition)
3518    {
3519       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSDLPdschMapTypeA");
3520       return RFAILED;
3521    }
3522    *(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition) = DMRS_ADDITIONAL_POS;
3523
3524    dmrsDlCfg->choice.setup->maxLength = NULLP;
3525    dmrsDlCfg->choice.setup->scramblingID0 = NULLP;
3526    dmrsDlCfg->choice.setup->scramblingID1 = NULLP;
3527    dmrsDlCfg->choice.setup->phaseTrackingRS = NULLP;
3528
3529    return ROK;
3530 }
3531
3532 /*******************************************************************
3533  *
3534  * @brief Builds TCI states to add/modify list
3535  *
3536  * @details
3537  *
3538  *    Function : BuildTCIStatesToAddModList
3539  *
3540  *    Functionality:Builds TCI states to add/modify list
3541  *
3542  * @params[in]
3543  * struct PDSCH_Config__tci_StatesToAddModList *tciStatesList
3544  *
3545  * @return ROK     - success
3546  *         RFAILED - failure
3547  *
3548  * ****************************************************************/
3549 uint8_t BuildTCIStatesToAddModList(struct PDSCH_Config__tci_StatesToAddModList *tciStatesList)
3550 {
3551    return ROK;
3552 }
3553
3554 /*******************************************************************
3555  *
3556  * @brief Builds PDSCH time domain allocation list
3557  *
3558  * @details
3559  *
3560  *    Function : BuildPdschTimeDomAllocList
3561  *
3562  *    Functionality: Builds PDSCH time domain allocation list
3563  *
3564  * @params[in]
3565  * struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList
3566  *
3567  * @return ROK     - success
3568  *         RFAILED - failure
3569  *
3570  * ****************************************************************/
3571    uint8_t BuildPdschTimeDomAllocList
3572 (
3573  struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList
3574  )
3575 {
3576    uint8_t idx;
3577    uint8_t elementCnt;
3578    struct PDSCH_TimeDomainResourceAllocation *timeDomAlloc;
3579
3580    timeDomAllocList->present = \
3581                                PDSCH_Config__pdsch_TimeDomainAllocationList_PR_setup;
3582
3583    timeDomAllocList->choice.setup = NULLP;
3584    DU_ALLOC(timeDomAllocList->choice.setup, \
3585          sizeof(struct PDSCH_TimeDomainResourceAllocationList));
3586    if(!timeDomAllocList->choice.setup)
3587    {
3588       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
3589       return RFAILED;
3590    }
3591
3592    elementCnt = 1;
3593    timeDomAllocList->choice.setup->list.count = elementCnt;
3594    timeDomAllocList->choice.setup->list.size = \
3595                                                elementCnt * sizeof(struct PDSCH_TimeDomainResourceAllocation *);
3596
3597    timeDomAllocList->choice.setup->list.array = NULLP;
3598    DU_ALLOC(timeDomAllocList->choice.setup->list.array, \
3599          timeDomAllocList->choice.setup->list.size);
3600    if(!timeDomAllocList->choice.setup->list.array)
3601    {
3602       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
3603       return RFAILED;
3604    }
3605
3606    for(idx = 0; idx < elementCnt; idx++)
3607    {
3608       timeDomAllocList->choice.setup->list.array[idx] = NULLP;
3609       DU_ALLOC(timeDomAllocList->choice.setup->list.array[idx], \
3610             sizeof(struct PDSCH_TimeDomainResourceAllocation));
3611       if(!timeDomAllocList->choice.setup->list.array[idx])
3612       {
3613          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
3614          return RFAILED;
3615       }
3616    }
3617
3618    idx = 0;
3619    timeDomAlloc = timeDomAllocList->choice.setup->list.array[idx];
3620
3621    timeDomAlloc->k0 = NULLP;
3622    timeDomAlloc->mappingType = PDSCH_MAPPING_TYPE_A;
3623    timeDomAlloc->startSymbolAndLength = \
3624                                         calcSliv(PDSCH_START_SYMBOL, PDSCH_LENGTH_SYMBOL);
3625
3626    return ROK;
3627 }
3628
3629 /*******************************************************************
3630  *
3631  * @brief Builds PDSCH PRB Bundling type
3632  *
3633  * @details
3634  *
3635  *    Function : BuildPdschPrbBundlingType
3636  *
3637  *    Functionality: Builds PDSCH PRB Bundling type
3638  *
3639  * @params[in]
3640  * struct PDSCH_Config__prb_BundlingType *prbBndlType
3641  *
3642  * @return ROK     - success
3643  *         RFAILED - failure
3644  *
3645  * ****************************************************************/
3646    uint8_t BuildPdschPrbBundlingType
3647 (
3648  struct PDSCH_Config__prb_BundlingType *prbBndlType
3649  )
3650 {
3651    prbBndlType->present = PDSCH_Config__prb_BundlingType_PR_staticBundling;
3652
3653    prbBndlType->choice.staticBundling = NULLP;
3654    DU_ALLOC(prbBndlType->choice.staticBundling, \
3655          sizeof(struct PDSCH_Config__prb_BundlingType__staticBundling));
3656    if(!prbBndlType->choice.staticBundling)
3657    {
3658       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschPrbBundlingType");
3659       return RFAILED;
3660    }
3661    prbBndlType->choice.staticBundling->bundleSize = NULLP;
3662
3663    return ROK;
3664 }
3665
3666 /*******************************************************************
3667  *
3668  * @brief Builds BWP DL dedicated PDSCH config
3669  *
3670  * @details
3671  *
3672  *    Function : BuildBWPDlDedPdschCfg
3673  *
3674  *    Functionality: Builds BWP DL dedicated PDSCH config
3675  *
3676  * @params[in] struct PDSCH_Config *pdschCfg
3677  *
3678  * @return ROK     - success
3679  *         RFAILED - failure
3680  *
3681  * ****************************************************************/
3682 uint8_t BuildBWPDlDedPdschCfg(struct PDSCH_Config *pdschCfg)
3683 {
3684    pdschCfg->dataScramblingIdentityPDSCH = NULLP;
3685
3686    pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA = NULLP;
3687    DU_ALLOC(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA, \
3688          sizeof(struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA));
3689    if(!pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA)
3690    {
3691       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
3692       return RFAILED;
3693    }
3694
3695    if(BuildDMRSDLPdschMapTypeA(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA) != ROK)
3696    {
3697       return RFAILED;
3698    }
3699
3700    pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeB = NULLP;
3701    pdschCfg->tci_StatesToAddModList = NULLP;
3702    pdschCfg->tci_StatesToReleaseList = NULLP;
3703    pdschCfg->vrb_ToPRB_Interleaver = NULLP;
3704 #if 0
3705    DU_ALLOC(pdschCfg->tci_StatesToAddModList, sizeof(struct PDSCH_Config__tci_StatesToAddModList));
3706    if(!pdschCfg->tci_StatesToAddModList)
3707    {
3708       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
3709       return RFAILED;
3710    }
3711    if(BuildTCIStatesToAddModList(pdschCfg->tci_StatesToAddModList) != ROK)
3712    {
3713       return RFAILED;
3714    }
3715 #endif
3716
3717    pdschCfg->resourceAllocation = RES_ALLOC_TYPE;
3718
3719    pdschCfg->pdsch_TimeDomainAllocationList = NULLP;
3720    DU_ALLOC(pdschCfg->pdsch_TimeDomainAllocationList, \
3721          sizeof(struct PDSCH_Config__pdsch_TimeDomainAllocationList));
3722    if(!pdschCfg->pdsch_TimeDomainAllocationList)
3723    {
3724       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
3725       return RFAILED;
3726    }
3727
3728    if(BuildPdschTimeDomAllocList(pdschCfg->pdsch_TimeDomainAllocationList) != ROK)
3729    {
3730       return RFAILED;
3731    }
3732
3733    pdschCfg->pdsch_AggregationFactor = NULLP;
3734    pdschCfg->rateMatchPatternToAddModList = NULLP;
3735    pdschCfg->rateMatchPatternToReleaseList = NULLP;
3736    pdschCfg->rateMatchPatternGroup1 = NULLP;
3737    pdschCfg->rateMatchPatternGroup2 = NULLP;
3738    pdschCfg->rbg_Size = PDSCH_RBG_SIZE;
3739    pdschCfg->mcs_Table = NULLP;
3740
3741    pdschCfg->maxNrofCodeWordsScheduledByDCI = NULLP;
3742    DU_ALLOC(pdschCfg->maxNrofCodeWordsScheduledByDCI, sizeof(long));
3743    if(!pdschCfg->maxNrofCodeWordsScheduledByDCI)
3744    {
3745       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
3746       return RFAILED;
3747    }
3748    *(pdschCfg->maxNrofCodeWordsScheduledByDCI) = PDSCH_MAX_CODEWORD_SCH_BY_DCI;
3749
3750    if(BuildPdschPrbBundlingType(&pdschCfg->prb_BundlingType) != ROK)
3751    {
3752       return RFAILED;
3753    }
3754
3755    pdschCfg->zp_CSI_RS_ResourceToAddModList = NULLP;
3756    pdschCfg->zp_CSI_RS_ResourceToReleaseList = NULLP;
3757    pdschCfg->aperiodic_ZP_CSI_RS_ResourceSetsToAddModList = NULLP;
3758    pdschCfg->aperiodic_ZP_CSI_RS_ResourceSetsToReleaseList = NULLP;
3759    pdschCfg->sp_ZP_CSI_RS_ResourceSetsToAddModList = NULLP;
3760    pdschCfg->sp_ZP_CSI_RS_ResourceSetsToReleaseList = NULLP;
3761    pdschCfg->p_ZP_CSI_RS_ResourceSet = NULLP;
3762
3763    return ROK;
3764 }
3765
3766 /*******************************************************************
3767  *
3768  * @brief Builds intitial DL BWP
3769  * @details
3770  *
3771  *    Function : BuildInitialDlBWP
3772  *
3773  *    Functionality: Builds intitial DL BWP in spCellCfgDed
3774  *
3775  * @params[in] BWP_DownlinkDedicated_t *dlBwp
3776  *
3777  * @return ROK     - success
3778  *         RFAILED - failure
3779  *
3780  * ****************************************************************/
3781 uint8_t BuildInitialDlBWP(BWP_DownlinkDedicated_t *dlBwp)
3782 {
3783    dlBwp->pdcch_Config = NULLP;
3784    DU_ALLOC(dlBwp->pdcch_Config, sizeof(struct BWP_DownlinkDedicated__pdcch_Config));
3785    if(!dlBwp->pdcch_Config)
3786    {
3787       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failure in BuildInitialDlBWP");
3788       return RFAILED;
3789    }
3790    dlBwp->pdcch_Config->present = BWP_DownlinkDedicated__pdcch_Config_PR_setup;
3791
3792    dlBwp->pdcch_Config->choice.setup = NULLP;
3793    DU_ALLOC(dlBwp->pdcch_Config->choice.setup, sizeof(struct PDCCH_Config));
3794    if(!dlBwp->pdcch_Config->choice.setup)
3795    {
3796       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failure in BuildInitialDlBWP");
3797       return RFAILED;
3798    }
3799    if(BuildBWPDlDedPdcchCfg(dlBwp->pdcch_Config->choice.setup) != ROK)
3800    {
3801       return RFAILED;
3802    }
3803
3804    dlBwp->pdsch_Config = NULLP;
3805    DU_ALLOC(dlBwp->pdsch_Config, sizeof(struct BWP_DownlinkDedicated__pdsch_Config));
3806    if(!dlBwp->pdsch_Config)
3807    {
3808       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failure in BuildInitialDlBWP");
3809       return RFAILED;
3810    }
3811    dlBwp->pdsch_Config->present = BWP_DownlinkDedicated__pdsch_Config_PR_setup;
3812
3813    dlBwp->pdsch_Config->choice.setup = NULLP;
3814    DU_ALLOC(dlBwp->pdsch_Config->choice.setup, sizeof(struct PDSCH_Config));
3815    if(!dlBwp->pdsch_Config->choice.setup)
3816    {
3817       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failure in BuildInitialDlBWP");
3818       return RFAILED;
3819    }
3820
3821    if(BuildBWPDlDedPdschCfg(dlBwp->pdsch_Config->choice.setup) != ROK)
3822    {
3823       return RFAILED;
3824    }
3825
3826    dlBwp->sps_Config = NULLP;
3827    dlBwp->radioLinkMonitoringConfig = NULLP;
3828    return ROK;
3829 }
3830
3831 /*******************************************************************
3832  *
3833  * @brief Builds DMRS UL Pusch Mapping type A
3834  *
3835  * @details
3836  *
3837  *    Function : BuildDMRSULPuschMapTypeA
3838  *
3839  *    Functionality: Builds DMRS UL Pusch Mapping type A
3840  *
3841  * @params[in]
3842  *    struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA *dmrsUlCfg
3843  * @return ROK     - success
3844  *         RFAILED - failure
3845  *
3846  * ****************************************************************/
3847    uint8_t BuildDMRSULPuschMapTypeA
3848 (
3849  struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA *dmrsUlCfg
3850  )
3851 {
3852    dmrsUlCfg->present = PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA_PR_setup;
3853    dmrsUlCfg->choice.setup= NULLP;
3854    DU_ALLOC(dmrsUlCfg->choice.setup, sizeof(DMRS_UplinkConfig_t));
3855    if(!dmrsUlCfg->choice.setup)
3856    {
3857       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
3858       return RFAILED;
3859    }
3860
3861    dmrsUlCfg->choice.setup->dmrs_Type = NULLP;
3862    dmrsUlCfg->choice.setup->dmrs_AdditionalPosition = NULLP;
3863    DU_ALLOC(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition, sizeof(long));
3864    if(!dmrsUlCfg->choice.setup->dmrs_AdditionalPosition)
3865    {
3866       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
3867       return RFAILED;
3868    }
3869    *(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition) = DMRS_ADDITIONAL_POS;
3870
3871    dmrsUlCfg->choice.setup->phaseTrackingRS = NULLP;
3872    dmrsUlCfg->choice.setup->maxLength = NULLP;
3873    dmrsUlCfg->choice.setup->transformPrecodingDisabled = NULLP;
3874    DU_ALLOC(dmrsUlCfg->choice.setup->transformPrecodingDisabled, \
3875          sizeof(struct DMRS_UplinkConfig__transformPrecodingDisabled));
3876    if(!dmrsUlCfg->choice.setup->transformPrecodingDisabled)
3877    {
3878       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
3879       return RFAILED;
3880    }
3881
3882    dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0 = NULLP;
3883    DU_ALLOC(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0,\
3884          sizeof(long));
3885    if(!dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0)
3886    {
3887       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
3888       return RFAILED;
3889    }
3890    *(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0) = SCRAMBLING_ID;
3891
3892    dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID1 = NULLP;
3893    dmrsUlCfg->choice.setup->transformPrecodingEnabled = NULLP;
3894    return ROK;
3895 }
3896
3897 /*******************************************************************
3898  *
3899  * @brief Build PUSCH time domain allocation list
3900  *
3901  * @details
3902  *
3903  *    Function : BuildPuschTimeDomAllocList
3904  *
3905  *    Functionality: Build PUSCH time domain allocation list
3906  *
3907  * @params[in]
3908  * struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList
3909  *
3910  * @return ROK     - success
3911  *         RFAILED - failure
3912  *
3913  * ****************************************************************/
3914    uint8_t BuildPuschTimeDomAllocList
3915 (
3916  struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList
3917  )
3918 {
3919    uint8_t idx;
3920    uint8_t elementCnt;
3921    PUSCH_TimeDomainResourceAllocation_t  *timeDomAlloc;
3922
3923    timeDomAllocList->present = PUSCH_Config__pusch_TimeDomainAllocationList_PR_setup;
3924    timeDomAllocList->choice.setup = NULLP;
3925    DU_ALLOC(timeDomAllocList->choice.setup, \
3926          sizeof(struct PUSCH_TimeDomainResourceAllocationList));
3927    if(!timeDomAllocList->choice.setup)
3928    {
3929       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
3930       return RFAILED;
3931    }
3932
3933    elementCnt = 1;
3934    timeDomAllocList->choice.setup->list.count = elementCnt;
3935    timeDomAllocList->choice.setup->list.size = \
3936                                                elementCnt * sizeof(PUSCH_TimeDomainResourceAllocation_t *);
3937    timeDomAllocList->choice.setup->list.array = NULLP;
3938    DU_ALLOC(timeDomAllocList->choice.setup->list.array, \
3939          timeDomAllocList->choice.setup->list.size);
3940    if(!timeDomAllocList->choice.setup->list.array)
3941    {
3942       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
3943       return RFAILED;
3944    }
3945
3946    for(idx = 0; idx < elementCnt; idx++)
3947    {
3948       timeDomAllocList->choice.setup->list.array[idx] = NULLP;
3949       DU_ALLOC(timeDomAllocList->choice.setup->list.array[idx],\
3950             sizeof(PUSCH_TimeDomainResourceAllocation_t));
3951       if(!timeDomAllocList->choice.setup->list.array[idx])
3952       {
3953          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
3954          return RFAILED;
3955       }
3956    }
3957
3958    idx = 0;
3959    timeDomAlloc = timeDomAllocList->choice.setup->list.array[idx];
3960    DU_ALLOC(timeDomAlloc->k2, sizeof(long));
3961    if(!timeDomAlloc->k2)
3962    {
3963       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
3964       return RFAILED;
3965    }
3966    *(timeDomAlloc->k2) = PUSCH_K2;
3967    timeDomAlloc->mappingType = PUSCH_MAPPING_TYPE_A;
3968    timeDomAlloc->startSymbolAndLength = calcSliv(PUSCH_START_SYMBOL, PUSCH_LENGTH_SYMBOL);
3969    return ROK;
3970 }
3971
3972 /*******************************************************************
3973  *
3974  * @brief Builds BWP UL dedicated PUSCH Config
3975  *
3976  * @details
3977  *
3978  *    Function : BuildBWPUlDedPuschCfg
3979  *
3980  *    Functionality:
3981  *      Builds BWP UL dedicated PUSCH Config
3982  *
3983  * @params[in] : PUSCH_Config_t *puschCfg
3984  *
3985  * @return ROK     - success
3986  *         RFAILED - failure
3987  *
3988  * ****************************************************************/
3989 uint8_t BuildBWPUlDedPuschCfg(PUSCH_Config_t *puschCfg)
3990 {
3991    puschCfg->dataScramblingIdentityPUSCH = NULLP;
3992    DU_ALLOC(puschCfg->dataScramblingIdentityPUSCH, sizeof(long));
3993    if(!puschCfg->dataScramblingIdentityPUSCH)
3994    {
3995       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
3996       return RFAILED;
3997    }
3998    *(puschCfg->dataScramblingIdentityPUSCH) = SCRAMBLING_ID;
3999
4000    puschCfg->txConfig = NULLP;
4001    puschCfg->dmrs_UplinkForPUSCH_MappingTypeA = NULLP;
4002    DU_ALLOC(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA, \
4003          sizeof(struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA));
4004    if(!puschCfg->dmrs_UplinkForPUSCH_MappingTypeA)
4005    {
4006       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
4007       return RFAILED;
4008    }
4009
4010    if(BuildDMRSULPuschMapTypeA(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA) != ROK)
4011    {
4012       return RFAILED;
4013    }
4014
4015    puschCfg->dmrs_UplinkForPUSCH_MappingTypeB = NULLP;
4016    puschCfg->pusch_PowerControl = NULLP;
4017    puschCfg->frequencyHopping = NULLP;
4018    puschCfg->frequencyHoppingOffsetLists = NULLP;
4019    puschCfg->resourceAllocation = RES_ALLOC_TYPE;
4020
4021    puschCfg->pusch_TimeDomainAllocationList = NULLP;
4022    DU_ALLOC(puschCfg->pusch_TimeDomainAllocationList, \
4023          sizeof(struct PUSCH_Config__pusch_TimeDomainAllocationList));
4024    if(!puschCfg->pusch_TimeDomainAllocationList)
4025    {
4026       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
4027       return RFAILED;
4028    }
4029
4030    if(BuildPuschTimeDomAllocList(puschCfg->pusch_TimeDomainAllocationList) != ROK)
4031    {
4032       return RFAILED;
4033    }
4034
4035    puschCfg->pusch_AggregationFactor = NULLP;
4036    puschCfg->mcs_Table = NULLP;
4037    puschCfg->mcs_TableTransformPrecoder = NULLP;
4038    puschCfg->transformPrecoder = NULLP;
4039    DU_ALLOC(puschCfg->transformPrecoder, sizeof(long));
4040    if(!puschCfg->transformPrecoder)
4041    {
4042       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
4043       return RFAILED;
4044    }
4045    *(puschCfg->transformPrecoder) = PUSCH_TRANSFORM_PRECODER;
4046
4047    puschCfg->codebookSubset = NULLP;
4048    puschCfg->maxRank = NULLP;
4049    puschCfg->rbg_Size = NULLP;
4050    puschCfg->uci_OnPUSCH = NULLP;
4051    puschCfg->tp_pi2BPSK = NULLP;
4052
4053    return ROK;
4054 }
4055
4056 /*******************************************************************
4057  *
4058  * @brief Fills SRS resource to add/modify list
4059  *
4060  * @details
4061  *
4062  *    Function : BuildSrsRsrcAddModList
4063  *
4064  *    Functionality: Fills SRS resource to add/modify list
4065  *
4066  * @params[in]
4067  * @return ROK     - success
4068  *         RFAILED - failure
4069  *
4070  * ****************************************************************/
4071 uint8_t BuildSrsRsrcAddModList(struct SRS_Config__srs_ResourceToAddModList *resourceList)
4072 {
4073    uint8_t   elementCnt;
4074    uint8_t   rsrcIdx;
4075
4076    elementCnt = 1;
4077    resourceList->list.count = elementCnt;
4078    resourceList->list.size = elementCnt * sizeof(SRS_Resource_t *);
4079    resourceList->list.array = NULLP;
4080    DU_ALLOC(resourceList->list.array, resourceList->list.size);
4081    if(!resourceList->list.array)
4082    {
4083       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcAddModList");
4084       return RFAILED;
4085    }
4086
4087    for(rsrcIdx = 0; rsrcIdx < resourceList->list.count; rsrcIdx++)
4088    {
4089       DU_ALLOC(resourceList->list.array[rsrcIdx], sizeof(SRS_Resource_t));
4090       if(!resourceList->list.array[rsrcIdx])
4091       {
4092          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcAddModList");
4093          return RFAILED;
4094       }
4095    }
4096
4097    rsrcIdx = 0;
4098    resourceList->list.array[rsrcIdx]->srs_ResourceId = SRS_RSRC_ID;
4099    resourceList->list.array[rsrcIdx]->nrofSRS_Ports = SRS_Resource__nrofSRS_Ports_port1;
4100    resourceList->list.array[rsrcIdx]->transmissionComb.present = SRS_Resource__transmissionComb_PR_n2;
4101
4102    resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2 = NULLP;
4103    DU_ALLOC(resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2, \
4104          sizeof(struct SRS_Resource__transmissionComb__n2));
4105    if(!resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2)
4106    {
4107       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcAddModList");
4108       return RFAILED;
4109    }
4110    resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2->combOffset_n2\
4111       = SRS_COMB_OFFSET_N2;
4112    resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2->cyclicShift_n2\
4113       = SRS_CYCLIC_SHIFT_N2;
4114
4115    resourceList->list.array[rsrcIdx]->resourceMapping.startPosition = \
4116                                                                       PUSCH_START_SYMBOL;
4117    resourceList->list.array[rsrcIdx]->resourceMapping.nrofSymbols =  \
4118                                                                      SRS_Resource__resourceMapping__nrofSymbols_n1;
4119    resourceList->list.array[rsrcIdx]->resourceMapping.repetitionFactor = \
4120                                                                          SRS_Resource__resourceMapping__repetitionFactor_n1;
4121
4122    resourceList->list.array[rsrcIdx]->freqDomainPosition = SRS_FREQ_DOM_POS;
4123    resourceList->list.array[rsrcIdx]->freqDomainShift = SRS_FREQ_DOM_SHIFT;
4124    resourceList->list.array[rsrcIdx]->freqHopping.c_SRS = C_SRS;
4125    resourceList->list.array[rsrcIdx]->freqHopping.b_SRS = B_SRS;
4126    resourceList->list.array[rsrcIdx]->freqHopping.b_hop = B_HOP;
4127    resourceList->list.array[rsrcIdx]->groupOrSequenceHopping = \
4128                                                                SRS_Resource__groupOrSequenceHopping_neither;
4129
4130    /* Setting resource type to aperiodic for intergration purposes */
4131    resourceList->list.array[rsrcIdx]->resourceType.present = \
4132                                                              SRS_Resource__resourceType_PR_aperiodic;
4133    resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic = NULLP;
4134    DU_ALLOC(resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic,
4135          sizeof(struct SRS_Resource__resourceType__aperiodic));
4136    if(!resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic)
4137    {
4138       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcAddModList");
4139       return RFAILED;
4140    }
4141    resourceList->list.array[rsrcIdx]->sequenceId = SRS_SEQ_ID;
4142
4143    return ROK;
4144 }
4145
4146 /*******************************************************************
4147  *
4148  * @brief Build SRS resource set Add/mod list
4149  *
4150  * @details
4151  *
4152  *    Function : BuildSrsRsrcSetAddModList
4153  *
4154  *    Functionality: Build SRS resource set Add/mod list
4155  *
4156  * @params[in]
4157  * @return ROK     - success
4158  *         RFAILED - failure
4159  *
4160  * ****************************************************************/
4161    uint8_t BuildSrsRsrcSetAddModList
4162 (
4163  struct SRS_Config__srs_ResourceSetToAddModList *rsrcSetList
4164  )
4165 {
4166    uint8_t  elementCnt;
4167    uint8_t  rSetIdx;
4168    uint8_t  rsrcIdx;
4169    struct SRS_ResourceSet__srs_ResourceIdList *rsrcIdList;
4170
4171    elementCnt = 1;
4172    rsrcSetList->list.count = elementCnt;
4173    rsrcSetList->list.size = elementCnt * sizeof(SRS_ResourceSet_t *);
4174    rsrcSetList->list.array = NULLP;
4175    DU_ALLOC(rsrcSetList->list.array, rsrcSetList->list.size);
4176    if(!rsrcSetList->list.array)
4177    {
4178       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
4179       return RFAILED;
4180    }
4181
4182    for(rSetIdx = 0; rSetIdx < rsrcSetList->list.count; rSetIdx++)
4183    {
4184       DU_ALLOC(rsrcSetList->list.array[rSetIdx], sizeof(SRS_ResourceSet_t));
4185       if(!rsrcSetList->list.array[rSetIdx])
4186       {
4187          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
4188          return RFAILED;
4189       }
4190    }
4191
4192    rSetIdx = 0;
4193    rsrcSetList->list.array[rSetIdx]->srs_ResourceSetId = SRS_RSET_ID;
4194
4195    /* Fill Resource Id list in resource set */
4196    rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList = NULLP;
4197    DU_ALLOC(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList,\
4198          sizeof(struct SRS_ResourceSet__srs_ResourceIdList));
4199    if(!rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList)
4200    {
4201       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
4202       return RFAILED;
4203    }
4204
4205    elementCnt = 1;
4206    rsrcIdList = rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList;
4207    rsrcIdList->list.count = elementCnt;
4208    rsrcIdList->list.size = elementCnt * sizeof(SRS_ResourceId_t *);
4209    rsrcIdList->list.array = NULLP;
4210    DU_ALLOC(rsrcIdList->list.array, rsrcIdList->list.size);
4211    if(!rsrcIdList->list.array)
4212    {
4213       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
4214       return RFAILED;
4215    }
4216
4217    for(rsrcIdx = 0; rsrcIdx < rsrcIdList->list.count; rsrcIdx++)
4218    {
4219       DU_ALLOC(rsrcIdList->list.array[rsrcIdx], sizeof(SRS_ResourceId_t));
4220       if(!rsrcIdList->list.array[rsrcIdx])
4221       {
4222          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
4223          return RFAILED;
4224       }
4225    }
4226
4227    rsrcIdx = 0;
4228    *rsrcIdList->list.array[rsrcIdx] = SRS_RSRC_ID;
4229
4230    /* Fill resource type */
4231    rsrcSetList->list.array[rSetIdx]->resourceType.present = \
4232                                                             SRS_ResourceSet__resourceType_PR_aperiodic;
4233
4234    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic = NULLP;
4235    DU_ALLOC(rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic, \
4236          sizeof(struct SRS_ResourceSet__resourceType__aperiodic));
4237    if(!rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic)
4238    {
4239       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
4240       return RFAILED;
4241    }
4242    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic->aperiodicSRS_ResourceTrigger \
4243       = APERIODIC_SRS_RESRC_TRIGGER;
4244
4245    /* TODO : Fill values for below IEs as expected by Viavi */
4246    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic->csi_RS = NULLP;
4247    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic->slotOffset = NULLP;
4248
4249
4250    rsrcSetList->list.array[rSetIdx]->usage = SRS_ResourceSet__usage_codebook;
4251    rsrcSetList->list.array[rSetIdx]->alpha = NULLP;
4252    rsrcSetList->list.array[rSetIdx]->p0 = NULLP;
4253    rsrcSetList->list.array[rSetIdx]->pathlossReferenceRS = NULLP;
4254    rsrcSetList->list.array[rSetIdx]->srs_PowerControlAdjustmentStates = NULLP;
4255
4256    return ROK;
4257 }
4258
4259 /*******************************************************************
4260  *
4261  * @brief Builds BWP UL dedicated SRS Config
4262  *
4263  * @details
4264  *
4265  *    Function : BuildBWPUlDedSrsCfg
4266  *
4267  *    Functionality: Builds BWP UL dedicated SRS Config
4268  *
4269  * @params[in] SRS Config
4270  * @return ROK     - success
4271  *         RFAILED - failure
4272  *
4273  * ****************************************************************/
4274 uint8_t BuildBWPUlDedSrsCfg(SRS_Config_t *srsCfg)
4275 {
4276    srsCfg->srs_ResourceSetToReleaseList = NULLP;
4277    srsCfg->srs_ResourceSetToAddModList = NULLP;
4278    DU_ALLOC(srsCfg->srs_ResourceSetToAddModList, \
4279          sizeof(struct SRS_Config__srs_ResourceSetToAddModList));
4280    if(!srsCfg->srs_ResourceSetToAddModList)
4281    {
4282       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedSrsCfg");
4283       return RFAILED;
4284    }
4285    if(BuildSrsRsrcSetAddModList(srsCfg->srs_ResourceSetToAddModList) != ROK)
4286    {
4287       return RFAILED;
4288    }
4289
4290    srsCfg->srs_ResourceToReleaseList = NULLP;
4291
4292    /* Resource to Add/Modify list */
4293    srsCfg->srs_ResourceToAddModList = NULLP;
4294    DU_ALLOC(srsCfg->srs_ResourceToAddModList, \
4295          sizeof(struct SRS_Config__srs_ResourceToAddModList));
4296    if(!srsCfg->srs_ResourceToAddModList)
4297    {
4298       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedSrsCfg");
4299       return RFAILED;
4300    }
4301
4302    if(BuildSrsRsrcAddModList(srsCfg->srs_ResourceToAddModList) != ROK)
4303    {
4304       return RFAILED;
4305    }
4306
4307    srsCfg->tpc_Accumulation = NULLP;
4308
4309    return ROK;
4310 }
4311
4312
4313
4314 /*******************************************************************
4315  *
4316  * @brief Builds Pusch Serving cell Config
4317  *
4318  * @details
4319  *
4320  *    Function : BuildPuschSrvCellCfg
4321  *
4322  *    Functionality: Builds Pusch Serving cell Config
4323  *
4324  * @params[in] struct UplinkConfig__pusch_ServingCellConfig *puschCfg
4325  *
4326  * @return ROK     - success
4327  *         RFAILED - failure
4328  *
4329  * ****************************************************************/
4330 uint8_t BuildPuschSrvCellCfg(struct UplinkConfig__pusch_ServingCellConfig *puschCfg)
4331 {
4332    puschCfg->present = UplinkConfig__pusch_ServingCellConfig_PR_setup;
4333    puschCfg->choice.setup = NULLP;
4334    DU_ALLOC(puschCfg->choice.setup, sizeof(struct PUSCH_ServingCellConfig));
4335    if(!puschCfg->choice.setup)
4336    {
4337       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
4338       return RFAILED;
4339    }
4340
4341    puschCfg->choice.setup->codeBlockGroupTransmission = NULLP;
4342    puschCfg->choice.setup->rateMatching = NULLP;
4343    puschCfg->choice.setup->xOverhead = NULLP;
4344    puschCfg->choice.setup->ext1 = NULLP;
4345    DU_ALLOC(puschCfg->choice.setup->ext1, sizeof(struct PUSCH_ServingCellConfig__ext1));
4346    if(!puschCfg->choice.setup->ext1)
4347    {
4348       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
4349       return RFAILED;
4350    }
4351
4352    puschCfg->choice.setup->ext1->maxMIMO_Layers = NULLP;
4353    DU_ALLOC(puschCfg->choice.setup->ext1->maxMIMO_Layers, sizeof(long));
4354    if(!puschCfg->choice.setup->ext1->maxMIMO_Layers)
4355    {
4356       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
4357       return RFAILED;
4358    }
4359    *(puschCfg->choice.setup->ext1->maxMIMO_Layers) = PUSCH_MAX_MIMO_LAYERS;
4360
4361    puschCfg->choice.setup->ext1->processingType2Enabled= NULLP;
4362    DU_ALLOC(puschCfg->choice.setup->ext1->processingType2Enabled,sizeof(BOOLEAN_t));
4363    if(!puschCfg->choice.setup->ext1->processingType2Enabled)
4364    {
4365       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
4366       return RFAILED;
4367    }
4368    *(puschCfg->choice.setup->ext1->processingType2Enabled) = PUSCH_PROCESS_TYPE2_ENABLED;
4369    return ROK;
4370 }
4371
4372 /*******************************************************************
4373  *
4374  * @brief Builds inital UL BWP
4375  *
4376  * @details
4377  *
4378  *    Function : BuildInitialUlBWP
4379  *
4380  *    Functionality: Builds initial UL BWP
4381  *
4382  * @params[in] BWP_UplinkDedicated_t *ulBwp
4383  * @return ROK     - success
4384  *         RFAILED - failure
4385  *
4386  * ****************************************************************/
4387 uint8_t BuildInitialUlBWP(BWP_UplinkDedicated_t *ulBwp)
4388 {
4389    ulBwp->pucch_Config = NULLP;
4390
4391    /* Fill BWP UL dedicated PUSCH config */
4392    ulBwp->pusch_Config = NULLP;
4393    DU_ALLOC(ulBwp->pusch_Config, sizeof(struct BWP_UplinkDedicated__pusch_Config));
4394    if(!ulBwp->pusch_Config)
4395    {
4396       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
4397       return RFAILED;
4398    }
4399
4400    ulBwp->pusch_Config->present = BWP_UplinkDedicated__pusch_Config_PR_setup;
4401    ulBwp->pusch_Config->choice.setup = NULLP;
4402    DU_ALLOC(ulBwp->pusch_Config->choice.setup, sizeof(PUSCH_Config_t));
4403    if(!ulBwp->pusch_Config->choice.setup)
4404    {
4405       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
4406       return RFAILED;
4407    }
4408
4409    if(BuildBWPUlDedPuschCfg(ulBwp->pusch_Config->choice.setup) != ROK)
4410    {
4411       return RFAILED;
4412    }
4413
4414    ulBwp->configuredGrantConfig = NULLP;
4415
4416    /* Fill BPW UL dedicated SRS config */
4417    ulBwp->srs_Config = NULLP;
4418    DU_ALLOC(ulBwp->srs_Config, sizeof(struct BWP_UplinkDedicated__srs_Config));
4419    if(!ulBwp->srs_Config)
4420    {
4421       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
4422       return RFAILED;
4423    }
4424
4425    ulBwp->srs_Config->present = BWP_UplinkDedicated__srs_Config_PR_setup;
4426    ulBwp->srs_Config->choice.setup = NULLP;
4427    DU_ALLOC(ulBwp->srs_Config->choice.setup, sizeof(SRS_Config_t));
4428    if(!ulBwp->srs_Config->choice.setup)
4429    {
4430       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
4431       return RFAILED;
4432    }
4433
4434    if(BuildBWPUlDedSrsCfg(ulBwp->srs_Config->choice.setup) != ROK)
4435    {
4436       return RFAILED;
4437    }
4438
4439    ulBwp->beamFailureRecoveryConfig = NULLP;
4440
4441    return ROK;
4442 }
4443
4444 /*******************************************************************
4445  *
4446  * @brief Builds UL config
4447  * @details
4448  *
4449  *    Function : BuildUlCfg
4450  *
4451  *    Functionality: Builds UL config in spCellCfgDed
4452  *
4453  * @params[in] UplinkConfig_t *ulCfg
4454  *
4455  * @return ROK     - success
4456  *         RFAILED - failure
4457  *
4458  * ****************************************************************/
4459 uint8_t BuildUlCfg(UplinkConfig_t *ulCfg)
4460 {
4461    ulCfg->initialUplinkBWP = NULLP;
4462    DU_ALLOC(ulCfg->initialUplinkBWP, sizeof(BWP_UplinkDedicated_t));
4463    if(!ulCfg->initialUplinkBWP)
4464    {
4465       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failed in BuildUlCfg");
4466       return RFAILED;
4467    }
4468
4469    if(BuildInitialUlBWP(ulCfg->initialUplinkBWP) != ROK)
4470    {
4471       return RFAILED;
4472    }
4473
4474    ulCfg->uplinkBWP_ToReleaseList = NULLP;
4475    ulCfg->uplinkBWP_ToAddModList = NULLP;
4476    ulCfg->firstActiveUplinkBWP_Id = NULLP;
4477    DU_ALLOC(ulCfg->firstActiveUplinkBWP_Id, sizeof(BWP_Id_t));
4478    if(!ulCfg->firstActiveUplinkBWP_Id)
4479    {
4480       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failed in BuildUlCfg");
4481       return RFAILED;
4482    }
4483    *(ulCfg->firstActiveUplinkBWP_Id) = ACTIVE_UL_BWP_ID;
4484
4485    ulCfg->pusch_ServingCellConfig = NULLP;
4486    DU_ALLOC(ulCfg->pusch_ServingCellConfig, \
4487          sizeof(struct UplinkConfig__pusch_ServingCellConfig));
4488    if(!ulCfg->pusch_ServingCellConfig)
4489    {
4490       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failed in BuildUlCfg");
4491       return RFAILED;
4492    }
4493
4494    if(BuildPuschSrvCellCfg(ulCfg->pusch_ServingCellConfig) != ROK)
4495    {
4496       return RFAILED;
4497    }
4498
4499    ulCfg->carrierSwitching = NULLP;
4500    ulCfg->ext1 = NULLP;
4501    return ROK;
4502 }
4503
4504 /*******************************************************************
4505  *
4506  * @brief Builds PDSCH serving cell config
4507  * @details
4508  *
4509  *    Function : BuildPdschSrvCellCfg
4510  *
4511  *    Functionality: Builds PDSCH serving cell config in spCellCfgDed
4512  *
4513  * @params[in] struct ServingCellConfig__pdsch_ServingCellConfig *pdschCfg
4514  *
4515  * @return ROK     - success
4516  *         RFAILED - failure
4517  *
4518  * ****************************************************************/
4519 uint8_t BuildPdschSrvCellCfg(struct ServingCellConfig__pdsch_ServingCellConfig *pdschCfg)
4520 {
4521    pdschCfg->present =  ServingCellConfig__pdsch_ServingCellConfig_PR_setup;
4522    pdschCfg->choice.setup = NULLP;
4523    DU_ALLOC(pdschCfg->choice.setup, sizeof( struct PDSCH_ServingCellConfig));
4524    if(!pdschCfg->choice.setup)
4525    {
4526       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschSrvCellCfg");
4527       return RFAILED;
4528    }
4529
4530    pdschCfg->choice.setup->codeBlockGroupTransmission = NULLP;
4531    pdschCfg->choice.setup->xOverhead = NULLP;
4532    pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH = NULLP;
4533    DU_ALLOC(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH, sizeof(long));
4534    if(!pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH)
4535    {
4536       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschSrvCellCfg");
4537       return RFAILED;
4538    }
4539    *(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH)= PDSCH_NUM_HARQ_PROC;
4540    pdschCfg->choice.setup->pucch_Cell = NULLP;
4541    pdschCfg->choice.setup->ext1 = NULLP;
4542
4543    return ROK;
4544 }
4545
4546 /*******************************************************************
4547  *
4548  * @brief Builds CSI Meas config
4549  * @details
4550  *
4551  *    Function : BuildCsiMeasCfg
4552  *
4553  *    Functionality: Builds CSI Meas config in spCellCfgDed
4554  *
4555  * @params[in] struct ServingCellConfig__csi_MeasConfig *csiMeasCfg
4556  *
4557  * @return ROK     - success
4558  *         RFAILED - failure
4559  *
4560  * ****************************************************************/
4561 uint8_t BuildCsiMeasCfg(struct ServingCellConfig__csi_MeasConfig *csiMeasCfg)
4562 {
4563
4564    return ROK;
4565 }
4566
4567 /*******************************************************************
4568  *
4569  * @brief Builds Spcell config dedicated
4570  * @details
4571  *
4572  *    Function : BuildSpCellCfgDed
4573  *
4574  *    Functionality: Builds sp cell config dedicated in spCellCfg
4575  *
4576  * @params[in] ServingCellConfig_t srvCellCfg
4577  *
4578  * @return ROK     - success
4579  *         RFAILED - failure
4580  *
4581  * ****************************************************************/
4582 uint8_t BuildSpCellCfgDed(ServingCellConfig_t *srvCellCfg)
4583 {
4584    srvCellCfg->tdd_UL_DL_ConfigurationDedicated = NULLP;
4585    DU_ALLOC(srvCellCfg->tdd_UL_DL_ConfigurationDedicated, sizeof(TDD_UL_DL_ConfigDedicated_t));
4586    if(!srvCellCfg->tdd_UL_DL_ConfigurationDedicated)
4587    {
4588       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
4589       return RFAILED;
4590    }
4591
4592    srvCellCfg->initialDownlinkBWP = NULLP;
4593    DU_ALLOC(srvCellCfg->initialDownlinkBWP, sizeof(BWP_DownlinkDedicated_t));
4594    if(!srvCellCfg->initialDownlinkBWP)
4595    {
4596       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
4597       return RFAILED;
4598    }
4599
4600    if(BuildInitialDlBWP(srvCellCfg->initialDownlinkBWP) != ROK)
4601    {
4602       DU_LOG("\nERROR  -->  F1AP : BuildInitialDlBWP failed");
4603       return RFAILED;
4604    }
4605    srvCellCfg->downlinkBWP_ToReleaseList = NULLP;
4606    srvCellCfg->downlinkBWP_ToAddModList = NULLP;
4607
4608    srvCellCfg->firstActiveDownlinkBWP_Id = NULLP;
4609    DU_ALLOC(srvCellCfg->firstActiveDownlinkBWP_Id, sizeof(long));
4610    if(!srvCellCfg->firstActiveDownlinkBWP_Id)
4611    {
4612       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
4613       return RFAILED;
4614    }
4615    *(srvCellCfg->firstActiveDownlinkBWP_Id) = ACTIVE_DL_BWP_ID;
4616
4617    srvCellCfg->bwp_InactivityTimer = NULLP;
4618
4619    srvCellCfg->defaultDownlinkBWP_Id = NULLP;
4620    DU_ALLOC(srvCellCfg->defaultDownlinkBWP_Id, sizeof(long));
4621    if(!srvCellCfg->defaultDownlinkBWP_Id)
4622    {
4623       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
4624       return RFAILED;
4625    }
4626    *(srvCellCfg->defaultDownlinkBWP_Id) = ACTIVE_DL_BWP_ID;
4627
4628    srvCellCfg->uplinkConfig = NULLP;
4629    DU_ALLOC(srvCellCfg->uplinkConfig, sizeof(UplinkConfig_t));
4630    if(!srvCellCfg->uplinkConfig)
4631    {
4632       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
4633       return RFAILED;
4634    }
4635
4636    if(BuildUlCfg(srvCellCfg->uplinkConfig) != ROK)
4637    {
4638       DU_LOG("\nERROR  -->  F1AP : BuildUlCfg failed");
4639       return RFAILED;
4640    }
4641    srvCellCfg->supplementaryUplink = NULLP;
4642    srvCellCfg->pdcch_ServingCellConfig = NULLP;
4643
4644    srvCellCfg->pdsch_ServingCellConfig = NULLP;
4645    DU_ALLOC(srvCellCfg->pdsch_ServingCellConfig, sizeof(struct  ServingCellConfig__pdsch_ServingCellConfig));
4646    if(!srvCellCfg->pdsch_ServingCellConfig)
4647    {
4648       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
4649       return RFAILED;
4650    }
4651
4652    if(BuildPdschSrvCellCfg(srvCellCfg->pdsch_ServingCellConfig) != ROK)
4653    {
4654       DU_LOG("\nERROR  -->  F1AP : BuildPdschSrvCellCfg failed");
4655       return RFAILED;
4656    }
4657
4658    srvCellCfg->csi_MeasConfig = NULLP;
4659 #if 0
4660    DU_ALLOC(srvCellCfg->csi_MeasConfig, sizeof(struct   ServingCellConfig__csi_MeasConfig))
4661       if(!srvCellCfg->csi_MeasConfig)
4662       {
4663          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
4664          return RFAILED;
4665       }
4666
4667    if(BuildCsiMeasCfg(srvCellCfg->csi_MeasConfig) != ROK)
4668    {
4669       DU_LOG("\nF1AP : BuildCsiMeasCfg failed");
4670       return RFAILED;
4671    }
4672 #endif
4673    srvCellCfg->sCellDeactivationTimer = NULLP;
4674    srvCellCfg->crossCarrierSchedulingConfig = NULLP;
4675    srvCellCfg->tag_Id = TAG_ID;
4676    srvCellCfg->dummy = NULLP;
4677    srvCellCfg->pathlossReferenceLinking = NULLP;
4678    srvCellCfg->servingCellMO = NULLP;
4679    srvCellCfg->ext1 = NULLP;
4680
4681    return ROK;
4682 }
4683 /*******************************************************************
4684  *
4685  * @brief Builds Spcell config
4686  *
4687  * @details
4688  *
4689  *    Function : BuildSpCellCfg
4690  *
4691  *    Functionality: Builds sp cell config in DuToCuRrcContainer
4692  *
4693  * @params[in] SpCellConfig_t spCellCfg
4694  *
4695  * @return ROK     - success
4696  *         RFAILED - failure
4697  *
4698  * ****************************************************************/
4699 uint8_t BuildSpCellCfg(SpCellConfig_t *spCellCfg)
4700 {
4701
4702    spCellCfg->servCellIndex = NULLP;
4703    DU_ALLOC(spCellCfg->servCellIndex, sizeof(long));
4704    if(!spCellCfg->servCellIndex)
4705    {
4706       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfg");
4707       return RFAILED;
4708    }
4709    *(spCellCfg->servCellIndex) = SERV_CELL_IDX;
4710
4711    spCellCfg->reconfigurationWithSync = NULLP;
4712    spCellCfg->rlf_TimersAndConstants = NULLP;
4713    spCellCfg->rlmInSyncOutOfSyncThreshold = NULLP;
4714    DU_ALLOC(spCellCfg->rlmInSyncOutOfSyncThreshold, sizeof(long));
4715    if(!spCellCfg->rlmInSyncOutOfSyncThreshold)
4716    {
4717       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfg");
4718       return RFAILED;
4719    }
4720    *(spCellCfg->rlmInSyncOutOfSyncThreshold) = RLM_SYNC_OUT_SYNC_THRESHOLD;
4721
4722    spCellCfg->spCellConfigDedicated = NULLP;
4723    DU_ALLOC(spCellCfg->spCellConfigDedicated, sizeof(ServingCellConfig_t));
4724    if(!spCellCfg->spCellConfigDedicated)
4725    {
4726       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfg");
4727       return RFAILED;
4728    }
4729    if(BuildSpCellCfgDed(spCellCfg->spCellConfigDedicated) != ROK)
4730    {
4731       DU_LOG("\nERROR  -->  F1AP : BuildSpCellCfgDed failed");
4732       return RFAILED;
4733    }
4734    return ROK;
4735 }
4736 /*******************************************************************
4737  *
4738  * @brief Builds Phy cell group config
4739  *
4740  * @details
4741  *
4742  *    Function : BuildPhyCellGrpCfg
4743  *
4744  *    Functionality: Builds Phy cell group config in DuToCuRrcContainer
4745  *
4746  * @params[in] PhysicalCellGroupConfig_t *phyCellGrpCfg
4747  *
4748  * @return ROK     - success
4749  *         RFAILED - failure
4750  *
4751  * ****************************************************************/
4752 uint8_t BuildPhyCellGrpCfg(PhysicalCellGroupConfig_t *phyCellGrpCfg)
4753 {
4754    phyCellGrpCfg->harq_ACK_SpatialBundlingPUCCH = NULLP;
4755    phyCellGrpCfg->harq_ACK_SpatialBundlingPUSCH = NULLP;
4756
4757    phyCellGrpCfg->p_NR_FR1 = NULLP;
4758    DU_ALLOC(phyCellGrpCfg->p_NR_FR1, sizeof(long));
4759    if(!phyCellGrpCfg->p_NR_FR1)
4760    {
4761       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildPhyCellGrpCfg");
4762       return RFAILED;
4763    }
4764    *(phyCellGrpCfg->p_NR_FR1)             = P_NR_FR1;
4765    phyCellGrpCfg->pdsch_HARQ_ACK_Codebook = PDSCH_HARQ_ACK_CODEBOOK;
4766    phyCellGrpCfg->tpc_SRS_RNTI = NULLP;
4767    phyCellGrpCfg->tpc_PUCCH_RNTI = NULLP;
4768    phyCellGrpCfg->tpc_PUSCH_RNTI = NULLP;
4769    phyCellGrpCfg->sp_CSI_RNTI = NULLP;
4770    phyCellGrpCfg->cs_RNTI = NULLP;
4771    phyCellGrpCfg->ext1 = NULLP;
4772    phyCellGrpCfg->ext2 = NULLP;
4773
4774    return ROK;
4775 }
4776 /*******************************************************************
4777  *
4778  * @brief Builds Mac cell group config
4779  *
4780  * @details
4781  *
4782  *    Function : BuildMacCellGrpCfg
4783  *
4784  *    Functionality: Builds Mac cell group config in DuToCuRrcContainer
4785  *
4786  * @params[in] MAC_CellGroupConfig_t *macCellGrpCfg
4787  *
4788  * @return ROK     - success
4789  *         RFAILED - failure
4790  *
4791  * ****************************************************************/
4792 uint8_t BuildMacCellGrpCfg(MAC_CellGroupConfig_t *macCellGrpCfg)
4793 {
4794    macCellGrpCfg->drx_Config = NULLP;
4795    macCellGrpCfg->schedulingRequestConfig = NULLP;
4796    DU_ALLOC(macCellGrpCfg->schedulingRequestConfig, sizeof(struct SchedulingRequestConfig));
4797    if(!macCellGrpCfg->schedulingRequestConfig)
4798    {
4799       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacCellGrpCfg");
4800       return RFAILED;
4801    }
4802
4803    if(BuildSchedulingReqConfig(macCellGrpCfg->schedulingRequestConfig) != ROK)
4804    {
4805       DU_LOG("\nERROR  -->  F1AP : BuildSchedulingReqConfig failed");
4806       return RFAILED;
4807    }
4808
4809    macCellGrpCfg->bsr_Config = NULLP;
4810    DU_ALLOC(macCellGrpCfg->bsr_Config, sizeof(struct BSR_Config));
4811    if(!macCellGrpCfg->bsr_Config)
4812    {
4813       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacCellGrpCfg");
4814       return RFAILED;
4815    }
4816
4817    if(BuildBsrConfig(macCellGrpCfg->bsr_Config) != ROK)
4818    {
4819       DU_LOG("\nERROR  -->  F1AP : BuildBsrConfig failed");
4820       return RFAILED;
4821    }
4822
4823    macCellGrpCfg->tag_Config = NULLP;
4824    DU_ALLOC(macCellGrpCfg->tag_Config, sizeof(struct TAG_Config));
4825    if(!macCellGrpCfg->tag_Config)
4826    {
4827       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacCellGrpCfg");
4828       return RFAILED;
4829    }
4830
4831    if(BuildTagConfig(macCellGrpCfg->tag_Config) != ROK)
4832    {
4833       DU_LOG("\nERROR  -->  F1AP : BuildTagConfig failed");
4834       return RFAILED;
4835    }
4836
4837    macCellGrpCfg->phr_Config = NULLP;
4838    DU_ALLOC(macCellGrpCfg->phr_Config, sizeof(struct MAC_CellGroupConfig__phr_Config));
4839    if(!macCellGrpCfg->phr_Config)
4840    {
4841       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacCellGrpCfg");
4842       return RFAILED;
4843    }
4844
4845    if(BuildPhrConfig(macCellGrpCfg->phr_Config) != ROK)
4846    {
4847       DU_LOG("\nERROR  -->  F1AP : BuildPhrConfig failed");
4848       return RFAILED;
4849    }
4850
4851    macCellGrpCfg->skipUplinkTxDynamic = false;
4852    macCellGrpCfg->ext1 = NULLP;
4853
4854    return ROK;
4855 }
4856 /*******************************************************************
4857  *
4858  * @brief Frees memeory allocated for SearchSpcToAddModList
4859  *
4860  * @details
4861  *
4862  *    Function : FreeSearchSpcToAddModList
4863  *
4864  *    Functionality: Deallocating memory of SearchSpcToAddModList
4865  *
4866  * @params[in] struct PDCCH_Config__searchSpacesToAddModList *searchSpcList
4867  *
4868  * @return void
4869  *
4870  4221 * ****************************************************************/
4871 void FreeSearchSpcToAddModList(struct PDCCH_Config__searchSpacesToAddModList *searchSpcList)
4872 {
4873    uint8_t idx1=0;
4874    uint8_t idx2=0;
4875    struct  SearchSpace *searchSpc=NULLP;
4876
4877    if(searchSpcList->list.array)
4878    {
4879       if(searchSpcList->list.array[idx2])
4880       {
4881          searchSpc = searchSpcList->list.array[idx2];
4882          if(searchSpc->controlResourceSetId)
4883          {
4884             if(searchSpc->monitoringSlotPeriodicityAndOffset)
4885             {
4886                if(searchSpc->monitoringSymbolsWithinSlot)
4887                {
4888                   if(searchSpc->monitoringSymbolsWithinSlot->buf)
4889                   {
4890                      if(searchSpc->nrofCandidates)
4891                      {
4892                         if(searchSpc->searchSpaceType)
4893                         {
4894                            DU_FREE(searchSpc->searchSpaceType->choice.ue_Specific,\
4895                                  sizeof(struct SearchSpace__searchSpaceType__ue_Specific));
4896                            DU_FREE(searchSpc->searchSpaceType, sizeof(struct
4897                                     SearchSpace__searchSpaceType));
4898                         }
4899                         DU_FREE(searchSpc->nrofCandidates,
4900                               sizeof(struct SearchSpace__nrofCandidates));
4901                      }
4902                      DU_FREE(searchSpc->monitoringSymbolsWithinSlot->buf, \
4903                            searchSpc->monitoringSymbolsWithinSlot->size);
4904                   }
4905                   DU_FREE(searchSpc->monitoringSymbolsWithinSlot,
4906                         sizeof(BIT_STRING_t));
4907                }
4908                DU_FREE(searchSpc->monitoringSlotPeriodicityAndOffset, \
4909                      sizeof(struct SearchSpace__monitoringSlotPeriodicityAndOffset));
4910             }
4911             DU_FREE(searchSpc->controlResourceSetId,
4912                   sizeof(ControlResourceSetId_t));
4913          }
4914       }
4915       for(idx1 = 0; idx1 < searchSpcList->list.count; idx1++)
4916       {
4917          DU_FREE(searchSpcList->list.array[idx1],
4918                sizeof(struct SearchSpace));
4919       }
4920       DU_FREE(searchSpcList->list.array,searchSpcList->list.size);
4921    }
4922 }
4923 /*******************************************************************
4924  *
4925  * @brief Frees memory allocated for PdschTimeDomAllocList
4926  *
4927  * @details
4928  *
4929  *    Function : FreePdschTimeDomAllocList
4930  *
4931  *    Functionality: Deallocating memory of PdschTimeDomAllocList
4932  *
4933  * @params[in] struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList
4934  *
4935  * @return void
4936  *
4937  4221 * ****************************************************************/
4938 void FreePdschTimeDomAllocList( struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList)
4939 {
4940    uint8_t idx1=0;
4941
4942    if(timeDomAllocList->choice.setup)
4943    {
4944       if(timeDomAllocList->choice.setup->list.array)
4945       {
4946          for(idx1 = 0; idx1 <timeDomAllocList->choice.setup->list.count ; idx1++)
4947          {
4948             DU_FREE(timeDomAllocList->choice.setup->list.array[idx1],
4949                   sizeof(struct PDSCH_TimeDomainResourceAllocation));
4950          }
4951          DU_FREE(timeDomAllocList->choice.setup->list.array, \
4952                timeDomAllocList->choice.setup->list.size);
4953       }
4954       DU_FREE(timeDomAllocList->choice.setup,\
4955             sizeof(struct PDSCH_TimeDomainResourceAllocationList));
4956    }
4957 }
4958 /*******************************************************************
4959  *
4960  * @brief Frees memory allocated for PuschTimeDomAllocList
4961  *
4962  *@details
4963  *
4964  *    Function : FreePuschTimeDomAllocList
4965  *
4966  *    Functionality: Deallocating memory of PuschTimeDomAllocList
4967  *
4968  * @params[in] PUSCH_Config_t *puschCfg
4969  *
4970  * @return void
4971  *
4972  * ****************************************************************/
4973 void FreePuschTimeDomAllocList(PUSCH_Config_t *puschCfg)
4974 {
4975    uint8_t idx1=0;
4976    uint8_t idx2=0;
4977    struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList_t=NULLP;
4978
4979    if(puschCfg->pusch_TimeDomainAllocationList)
4980    {
4981       timeDomAllocList_t=puschCfg->pusch_TimeDomainAllocationList;
4982       if(timeDomAllocList_t->choice.setup)
4983       {
4984          if(timeDomAllocList_t->choice.setup->list.array)
4985          {
4986             DU_FREE(timeDomAllocList_t->choice.setup->list.array[idx2]->k2, sizeof(long));
4987             for(idx1 = 0; idx1<timeDomAllocList_t->choice.setup->list.count; idx1++)
4988             {
4989                DU_FREE(timeDomAllocList_t->choice.setup->list.array[idx1],\
4990                      sizeof(PUSCH_TimeDomainResourceAllocation_t));
4991             }
4992             DU_FREE(timeDomAllocList_t->choice.setup->list.array, \
4993                   timeDomAllocList_t->choice.setup->list.size);
4994          }
4995          DU_FREE(timeDomAllocList_t->choice.setup, \
4996                sizeof(struct PUSCH_TimeDomainResourceAllocationList));
4997       }
4998       DU_FREE(puschCfg->transformPrecoder, sizeof(long));
4999       DU_FREE(puschCfg->pusch_TimeDomainAllocationList, \
5000             sizeof(struct PUSCH_Config__pusch_TimeDomainAllocationList));
5001    }
5002
5003 }
5004 /*******************************************************************
5005  *
5006  * @brief Frees memory allocated for InitialUlBWP
5007  *
5008  * @details
5009  *
5010  *    Function : FreeInitialUlBWP
5011  *
5012  *    Functionality: Deallocating memory of InitialUlBWP
5013  *
5014  * @params[in] BWP_UplinkDedicated_t *ulBwp
5015  *
5016  * @return void
5017  *
5018  * ****************************************************************/
5019 void FreeInitialUlBWP(BWP_UplinkDedicated_t *ulBwp)
5020 {
5021    uint8_t  rSetIdx, rsrcIdx;
5022    SRS_Config_t   *srsCfg = NULLP;
5023    PUSCH_Config_t *puschCfg = NULLP;
5024    struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA *dmrsUlCfg = NULLP;
5025    struct SRS_Config__srs_ResourceSetToAddModList *rsrcSetList = NULLP;
5026    struct SRS_ResourceSet__srs_ResourceIdList *rsrcIdList = NULLP;
5027    struct SRS_Config__srs_ResourceToAddModList *resourceList = NULLP;
5028
5029    if(ulBwp->pusch_Config)
5030    {
5031       if(ulBwp->pusch_Config->choice.setup)
5032       {
5033          puschCfg=ulBwp->pusch_Config->choice.setup;
5034          if(puschCfg->dataScramblingIdentityPUSCH)
5035          {
5036             if(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA)
5037             {
5038                FreePuschTimeDomAllocList(puschCfg);
5039                dmrsUlCfg=puschCfg->dmrs_UplinkForPUSCH_MappingTypeA;
5040                if(dmrsUlCfg->choice.setup)
5041                {
5042                   if(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition)
5043                   {
5044                      if(dmrsUlCfg->choice.setup->transformPrecodingDisabled)
5045                      {
5046                         DU_FREE(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0,\
5047                               sizeof(long));
5048                         DU_FREE(dmrsUlCfg->choice.setup->transformPrecodingDisabled,
5049                               sizeof(struct DMRS_UplinkConfig__transformPrecodingDisabled));
5050                      }
5051                      DU_FREE(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition,
5052                            sizeof(long));
5053                   }
5054                   DU_FREE(dmrsUlCfg->choice.setup,sizeof(DMRS_UplinkConfig_t));
5055                }
5056                DU_FREE(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA, \
5057                      sizeof(struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA));
5058             }
5059             DU_FREE(puschCfg->dataScramblingIdentityPUSCH, sizeof(long));
5060          }
5061          DU_FREE(ulBwp->pusch_Config->choice.setup, sizeof(PUSCH_Config_t));
5062       }
5063       DU_FREE(ulBwp->pusch_Config, sizeof(struct BWP_UplinkDedicated__pusch_Config));
5064
5065       /* Free SRS-Config */
5066       if(ulBwp->srs_Config)
5067       {
5068          if(ulBwp->srs_Config->choice.setup)
5069          {
5070             srsCfg = ulBwp->srs_Config->choice.setup;
5071
5072             /* Free Resource Set to add/mod list */
5073             if(srsCfg->srs_ResourceSetToAddModList)
5074             {
5075                rsrcSetList = srsCfg->srs_ResourceSetToAddModList;
5076                if(rsrcSetList->list.array)
5077                {
5078                   rSetIdx = 0;
5079
5080                   /* Free SRS resource Id list in this SRS resource set */
5081                   if(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList)
5082                   {
5083                      rsrcIdList = rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList;
5084
5085                      if(rsrcIdList->list.array)
5086                      {
5087                         for(rsrcIdx = 0; rsrcIdx < rsrcIdList->list.count; rsrcIdx++)
5088                         {
5089                            DU_FREE(rsrcIdList->list.array[rsrcIdx], sizeof(SRS_ResourceId_t));
5090                         }
5091                         DU_FREE(rsrcIdList->list.array, rsrcIdList->list.size);
5092                      }
5093                      DU_FREE(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList,\
5094                            sizeof(struct SRS_ResourceSet__srs_ResourceIdList));
5095                   }
5096
5097                   /* Free resource type info for this SRS resource set */
5098                   DU_FREE(rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic, \
5099                         sizeof(struct SRS_ResourceSet__resourceType__aperiodic));
5100
5101                   /* Free memory for each resource set */
5102                   for(rSetIdx = 0; rSetIdx < rsrcSetList->list.count; rSetIdx++)
5103                   {
5104                      DU_FREE(rsrcSetList->list.array[rSetIdx], sizeof(SRS_ResourceSet_t));
5105                   }
5106                   DU_FREE(rsrcSetList->list.array, rsrcSetList->list.size);
5107                }
5108                DU_FREE(srsCfg->srs_ResourceSetToAddModList, \
5109                      sizeof(struct SRS_Config__srs_ResourceSetToAddModList));
5110             }
5111
5112             /* Free resource to add/modd list */
5113             if(srsCfg->srs_ResourceToAddModList)
5114             {
5115                resourceList = srsCfg->srs_ResourceToAddModList;
5116                if(resourceList->list.array)
5117                {
5118                   rsrcIdx = 0;
5119                   DU_FREE(resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2,\
5120                         sizeof(struct SRS_Resource__transmissionComb__n2));
5121                   DU_FREE(resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic,\
5122                         sizeof(struct SRS_Resource__resourceType__aperiodic));
5123
5124                   for(rsrcIdx = 0; rsrcIdx < resourceList->list.count; rsrcIdx++)
5125                   {
5126                      DU_FREE(resourceList->list.array[rsrcIdx], sizeof(SRS_Resource_t));
5127                   }
5128                   DU_FREE(resourceList->list.array, resourceList->list.size);
5129                }
5130                DU_FREE(srsCfg->srs_ResourceToAddModList, \
5131                      sizeof(struct SRS_Config__srs_ResourceToAddModList));
5132             }
5133
5134             DU_FREE(ulBwp->srs_Config->choice.setup, sizeof(SRS_Config_t));
5135          }
5136          DU_FREE(ulBwp->srs_Config, sizeof(struct BWP_UplinkDedicated__srs_Config));
5137       }
5138    }
5139 }
5140 /*******************************************************************
5141  *
5142  * @brief Frees memory allocated for initialUplinkBWP
5143  *
5144  * @details
5145  *
5146  *    Function : FreeinitialUplinkBWP
5147  *
5148  *    Functionality: Deallocating memory of initialUplinkBWP
5149  *
5150  * @params[in] UplinkConfig_t *ulCfg
5151  *
5152  * @return void
5153  *
5154  *
5155  * ****************************************************************/
5156 void FreeinitialUplinkBWP(UplinkConfig_t *ulCfg)
5157 {
5158    BWP_UplinkDedicated_t *ulBwp=NULLP;
5159    struct UplinkConfig__pusch_ServingCellConfig *puschCfg=NULLP;
5160
5161    if(ulCfg->initialUplinkBWP)
5162    {
5163       ulBwp=ulCfg->initialUplinkBWP;
5164       if(ulCfg->firstActiveUplinkBWP_Id)
5165       {
5166          if(ulCfg->pusch_ServingCellConfig)
5167          {
5168             puschCfg=ulCfg->pusch_ServingCellConfig;
5169             if(puschCfg->choice.setup)
5170             {
5171                if(puschCfg->choice.setup->ext1)
5172                {
5173                   DU_FREE(puschCfg->choice.setup->ext1->\
5174                         processingType2Enabled,sizeof(BOOLEAN_t));
5175                   DU_FREE(puschCfg->choice.setup->ext1->\
5176                         maxMIMO_Layers,sizeof(long));
5177                   DU_FREE(puschCfg->choice.setup->ext1, \
5178                         sizeof(struct PUSCH_ServingCellConfig__ext1));
5179                }
5180                DU_FREE(puschCfg->choice.setup, sizeof(struct PUSCH_ServingCellConfig));
5181             }
5182             DU_FREE(ulCfg->pusch_ServingCellConfig, sizeof(struct UplinkConfig__pusch_ServingCellConfig));
5183          }
5184          DU_FREE(ulCfg->firstActiveUplinkBWP_Id, sizeof(BWP_Id_t));
5185       }
5186       FreeInitialUlBWP(ulBwp);
5187       DU_FREE(ulCfg->initialUplinkBWP, sizeof(BWP_UplinkDedicated_t));
5188    }
5189 }
5190 /*******************************************************************
5191  *
5192  * @brief Frees emmory allocated for BWPDlDedPdschCfg
5193  *
5194  * @details
5195  *
5196  *    Function : FreeBWPDlDedPdschCfg
5197  *
5198  *    Functionality: Deallocating memory of BWPDlDedPdschCfg
5199  *
5200  * @params[in] BWP_DownlinkDedicated_t *dlBwp
5201  *
5202  * @return void
5203  *
5204  *
5205  * ****************************************************************/
5206 void FreeBWPDlDedPdschCfg(BWP_DownlinkDedicated_t *dlBwp)
5207 {
5208    struct PDSCH_Config *pdschCfg=NULLP;
5209    struct PDSCH_Config__prb_BundlingType *prbBndlType=NULLP;
5210    struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList=NULLP;
5211    struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA *dmrsDlCfg=NULLP;
5212
5213    if(dlBwp->pdsch_Config->choice.setup)
5214    {
5215       pdschCfg=dlBwp->pdsch_Config->choice.setup;
5216       if(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA)
5217       {
5218          if(pdschCfg->pdsch_TimeDomainAllocationList)
5219          {
5220             timeDomAllocList=pdschCfg->pdsch_TimeDomainAllocationList;
5221             if(pdschCfg->maxNrofCodeWordsScheduledByDCI)
5222             {
5223                prbBndlType=&pdschCfg->prb_BundlingType;
5224                DU_FREE(prbBndlType->choice.staticBundling,\
5225                      sizeof(struct PDSCH_Config__prb_BundlingType__staticBundling));
5226                DU_FREE(pdschCfg->maxNrofCodeWordsScheduledByDCI, sizeof(long));
5227             }
5228             FreePdschTimeDomAllocList(timeDomAllocList);
5229             DU_FREE(pdschCfg->pdsch_TimeDomainAllocationList, \
5230                   sizeof(struct PDSCH_Config__pdsch_TimeDomainAllocationList));
5231          }
5232          dmrsDlCfg=pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA;
5233          if(dmrsDlCfg->choice.setup)
5234          {
5235             DU_FREE(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition,
5236                   sizeof(long));
5237             DU_FREE(dmrsDlCfg->choice.setup, sizeof(struct DMRS_DownlinkConfig));
5238          }
5239          DU_FREE(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA, \
5240                sizeof(struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA));
5241       }
5242       DU_FREE(dlBwp->pdsch_Config->choice.setup, sizeof(struct PDSCH_Config));
5243    }
5244 }
5245 /*******************************************************************
5246  *
5247  * @brief Frees emmory allocated for BWPDlDedPdcchCfg
5248  *
5249  * @details
5250  *
5251  *    Function : FreeBWPDlDedPdcchCfg
5252  *
5253  *    Functionality: Deallocating memory of BWPDlDedPdcchCfg
5254  *
5255  * @params[in] BWP_DownlinkDedicated_t *dlBwp
5256  *
5257  * @return void
5258  *
5259  *
5260  * ****************************************************************/
5261 void FreeBWPDlDedPdcchCfg(BWP_DownlinkDedicated_t *dlBwp)
5262 {
5263    uint8_t idx1=0;
5264    uint8_t idx2=0;
5265    struct PDCCH_Config *pdcchCfg=NULLP;
5266    struct ControlResourceSet *controlRSet=NULLP;
5267    struct PDCCH_Config__controlResourceSetToAddModList *controlRSetList=NULLP;
5268
5269    if(dlBwp->pdcch_Config->choice.setup)
5270    {
5271       pdcchCfg=dlBwp->pdcch_Config->choice.setup;
5272       if(pdcchCfg->controlResourceSetToAddModList)
5273       {
5274          controlRSetList = pdcchCfg->controlResourceSetToAddModList;
5275          if(controlRSetList->list.array)
5276          {
5277             controlRSet = controlRSetList->list.array[idx2];
5278             if(controlRSet)
5279             {
5280                if(controlRSet->frequencyDomainResources.buf)
5281                {
5282                   if(controlRSet->pdcch_DMRS_ScramblingID)
5283                   {
5284                      if(pdcchCfg->searchSpacesToAddModList)
5285                      {
5286                         FreeSearchSpcToAddModList(pdcchCfg->searchSpacesToAddModList);
5287                         DU_FREE(pdcchCfg->searchSpacesToAddModList, \
5288                               sizeof(struct PDCCH_Config__searchSpacesToAddModList));
5289                      }
5290                      DU_FREE(controlRSet->pdcch_DMRS_ScramblingID, sizeof(long));
5291                   }
5292                   DU_FREE(controlRSet->frequencyDomainResources.buf, \
5293                         controlRSet->frequencyDomainResources.size);
5294                }
5295             }
5296             for(idx1 = 0; idx1 <controlRSetList->list.count; idx1++)
5297             {
5298                DU_FREE(controlRSetList->list.array[idx1], sizeof(struct ControlResourceSet));
5299             }
5300             DU_FREE(controlRSetList->list.array, controlRSetList->list.size);
5301          }
5302          DU_FREE(pdcchCfg->controlResourceSetToAddModList, \
5303                sizeof(struct PDCCH_Config__controlResourceSetToAddModList));
5304       }
5305       DU_FREE(dlBwp->pdcch_Config->choice.setup, sizeof(struct PDCCH_Config));
5306    }
5307 }
5308
5309 /*******************************************************************
5310  *
5311  * @brief Frees emmory allocated for DUToCURRCContainer
5312  *
5313  * @details
5314  *
5315  *    Function : FreeMemDuToCuRrcCont
5316  *
5317  *    Functionality: Deallocating memory of DuToCuRrcContainer
5318  *
5319  * @params[in] DuToCuRRCContainer, DuToCuRRCContainer
5320  *
5321  * @return ROK     - success
5322  *         RFAILED - failure
5323  *
5324  * ****************************************************************/
5325 uint8_t FreeMemDuToCuRrcCont(CellGroupConfigRrc_t *cellGrpCfg)
5326 {
5327    uint8_t idx=0;
5328    SpCellConfig_t *spCellCfg=NULLP;
5329    ServingCellConfig_t *srvCellCfg=NULLP;
5330    BWP_DownlinkDedicated_t *dlBwp=NULLP;
5331    MAC_CellGroupConfig_t *macCellGrpCfg=NULLP;
5332    PhysicalCellGroupConfig_t *phyCellGrpCfg=NULLP;
5333    struct CellGroupConfigRrc__rlc_BearerToAddModList *rlcBearerList=NULLP;
5334    struct RLC_Config *rlcConfig=NULLP;
5335    struct LogicalChannelConfig *macLcConfig=NULLP;
5336    struct SchedulingRequestConfig *schedulingRequestConfig=NULLP;
5337    struct SchedulingRequestConfig__schedulingRequestToAddModList *schReqList=NULLP;
5338    struct TAG_Config *tagConfig=NULLP;
5339    struct TAG_Config__tag_ToAddModList *tagList=NULLP;
5340    struct MAC_CellGroupConfig__phr_Config *phrConfig=NULLP;
5341    struct ServingCellConfig__pdsch_ServingCellConfig *pdschCfg=NULLP;
5342
5343    rlcBearerList = cellGrpCfg->rlc_BearerToAddModList;
5344    if(rlcBearerList)
5345    {
5346       if(rlcBearerList->list.array)
5347       {
5348          for(idx=0; idx<rlcBearerList->list.count; idx++)
5349          {
5350             if(rlcBearerList->list.array[idx])
5351             {
5352                rlcConfig   = rlcBearerList->list.array[idx]->rlc_Config;
5353                macLcConfig = rlcBearerList->list.array[idx]->mac_LogicalChannelConfig;
5354                if(rlcConfig)
5355                {
5356                   if(rlcConfig->choice.am)
5357                   {
5358                      DU_FREE(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
5359                      DU_FREE(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
5360                      DU_FREE(rlcConfig->choice.am, sizeof(struct RLC_Config__am));
5361                   }
5362                   DU_FREE(rlcConfig, sizeof(struct RLC_Config));
5363                }
5364                DU_FREE(rlcBearerList->list.array[idx]->servedRadioBearer, sizeof(struct RLC_BearerConfig__servedRadioBearer));
5365                if(macLcConfig)
5366                {
5367                   if(macLcConfig->ul_SpecificParameters)
5368                   {
5369                      DU_FREE(macLcConfig->ul_SpecificParameters->schedulingRequestID,   sizeof(SchedulingRequestId_t));
5370                      DU_FREE(macLcConfig->ul_SpecificParameters->logicalChannelGroup,   sizeof(long));
5371                      DU_FREE(macLcConfig->ul_SpecificParameters, sizeof(struct LogicalChannelConfig__ul_SpecificParameters));
5372                   }
5373                   DU_FREE(rlcBearerList->list.array[idx]->mac_LogicalChannelConfig, sizeof(struct LogicalChannelConfig));
5374                }
5375                DU_FREE(rlcBearerList->list.array[idx], sizeof(struct RLC_BearerConfig));
5376             }
5377          }
5378          DU_FREE(rlcBearerList->list.array, rlcBearerList->list.size);
5379       }
5380       DU_FREE(cellGrpCfg->rlc_BearerToAddModList, sizeof(struct CellGroupConfigRrc__rlc_BearerToAddModList));
5381    }
5382
5383    macCellGrpCfg = cellGrpCfg->mac_CellGroupConfig;
5384    if(macCellGrpCfg)
5385    {
5386       schedulingRequestConfig = macCellGrpCfg->schedulingRequestConfig;
5387       if(schedulingRequestConfig)
5388       {
5389          schReqList = schedulingRequestConfig->schedulingRequestToAddModList;
5390          if(schReqList)
5391          {
5392             if(schReqList->list.array)
5393             {
5394                for(idx=0;idx<schReqList->list.count; idx++)
5395                {
5396                   if(schReqList->list.array[idx])
5397                   {
5398                      DU_FREE(schReqList->list.array[idx]->sr_ProhibitTimer, sizeof(long));
5399                      DU_FREE(schReqList->list.array[idx], sizeof(struct SchedulingRequestToAddMod));
5400                   }
5401                }
5402                DU_FREE(schReqList->list.array, schReqList->list.size);
5403             }
5404             DU_FREE(schedulingRequestConfig->schedulingRequestToAddModList,\
5405                   sizeof(struct SchedulingRequestConfig__schedulingRequestToAddModList));    }
5406             DU_FREE(macCellGrpCfg->schedulingRequestConfig, sizeof(struct SchedulingRequestConfig));
5407       }
5408       if(macCellGrpCfg->bsr_Config)
5409       {
5410          DU_FREE(macCellGrpCfg->bsr_Config, sizeof(struct BSR_Config));
5411       }
5412       tagConfig = macCellGrpCfg->tag_Config;
5413       if(tagConfig)
5414       {
5415          tagList = tagConfig->tag_ToAddModList;
5416          if(tagList)
5417          {
5418             if(tagList->list.array)
5419             {
5420                for(idx=0; idx<tagList->list.count; idx++)
5421                {
5422                   DU_FREE(tagList->list.array[idx], sizeof(struct TAG));
5423                }
5424                DU_FREE(tagList->list.array, tagList->list.size);
5425             }
5426             DU_FREE(tagConfig->tag_ToAddModList, sizeof(struct TAG_Config__tag_ToAddModList));
5427          }
5428          DU_FREE(tagConfig, sizeof(struct TAG_Config));
5429       }
5430
5431       phrConfig = macCellGrpCfg->phr_Config;
5432       if(phrConfig)
5433       {
5434          DU_FREE(phrConfig->choice.setup, sizeof(struct PHR_Config));
5435          DU_FREE(phrConfig, sizeof(struct MAC_CellGroupConfig__phr_Config));
5436       }
5437
5438       DU_FREE(macCellGrpCfg, sizeof(MAC_CellGroupConfig_t));
5439    }
5440
5441    phyCellGrpCfg = cellGrpCfg->physicalCellGroupConfig;
5442    if(phyCellGrpCfg)
5443    {
5444       DU_FREE(phyCellGrpCfg->p_NR_FR1, sizeof(long));
5445       DU_FREE(phyCellGrpCfg, sizeof(PhysicalCellGroupConfig_t));
5446    }
5447
5448    spCellCfg = cellGrpCfg->spCellConfig;
5449    if(spCellCfg)
5450    {
5451       if(spCellCfg->servCellIndex)
5452       {
5453          if(spCellCfg->rlmInSyncOutOfSyncThreshold)
5454          {
5455             if(spCellCfg->spCellConfigDedicated)
5456             {
5457                srvCellCfg = spCellCfg->spCellConfigDedicated;
5458                if(srvCellCfg->tdd_UL_DL_ConfigurationDedicated)
5459                {
5460                   if(srvCellCfg->initialDownlinkBWP)
5461                   {
5462                      dlBwp = srvCellCfg->initialDownlinkBWP;
5463                      if(srvCellCfg->firstActiveDownlinkBWP_Id)
5464                      {
5465                         if(srvCellCfg->defaultDownlinkBWP_Id)
5466                         {
5467                            if(srvCellCfg->uplinkConfig)
5468                            {
5469                               if(srvCellCfg->pdsch_ServingCellConfig)
5470                               {
5471                                  pdschCfg= srvCellCfg->pdsch_ServingCellConfig;
5472                                  if(pdschCfg->choice.setup)
5473                                  {
5474                                     DU_FREE(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH,sizeof(long));
5475                                     DU_FREE(pdschCfg->choice.setup, sizeof( struct PDSCH_ServingCellConfig));
5476                                  }
5477                                  DU_FREE(srvCellCfg->pdsch_ServingCellConfig, sizeof(struct
5478                                        ServingCellConfig__pdsch_ServingCellConfig));
5479                               }
5480                               FreeinitialUplinkBWP(srvCellCfg->uplinkConfig);
5481                               DU_FREE(srvCellCfg->uplinkConfig, sizeof(UplinkConfig_t));
5482                            }
5483                            DU_FREE(srvCellCfg->defaultDownlinkBWP_Id, sizeof(long));
5484                         }
5485                         DU_FREE(srvCellCfg->firstActiveDownlinkBWP_Id, sizeof(long));
5486                      }
5487                      if(dlBwp->pdcch_Config)
5488                      {
5489                         if(dlBwp->pdsch_Config)
5490                         {
5491                            FreeBWPDlDedPdschCfg(dlBwp);
5492                            DU_FREE(dlBwp->pdsch_Config, sizeof(struct BWP_DownlinkDedicated__pdsch_Config));
5493                         }
5494                         FreeBWPDlDedPdcchCfg(dlBwp);
5495                         DU_FREE(dlBwp->pdcch_Config, sizeof(struct BWP_DownlinkDedicated__pdcch_Config));
5496                     }
5497                     DU_FREE(srvCellCfg->initialDownlinkBWP, sizeof(BWP_DownlinkDedicated_t));
5498                   }
5499                   DU_FREE(srvCellCfg->tdd_UL_DL_ConfigurationDedicated, sizeof(TDD_UL_DL_ConfigDedicated_t));
5500                }
5501                DU_FREE(spCellCfg->spCellConfigDedicated, sizeof(ServingCellConfig_t));
5502             }
5503             DU_FREE(spCellCfg->rlmInSyncOutOfSyncThreshold, sizeof(long));
5504          }
5505          DU_FREE(spCellCfg->servCellIndex, sizeof(long));
5506       }
5507       DU_FREE(spCellCfg,sizeof(SpCellConfig_t));
5508    }
5509    return ROK;
5510 }
5511 /*******************************************************************
5512  *
5513  * @brief Builds DU To CU RRC Container
5514  *
5515  * @details
5516  *
5517  *    Function : BuildDuToCuRrcContainer
5518  *
5519  *    Functionality: Builds DuToCuRrcContainer
5520  *
5521  * @params[in] idx, index in F1AP msg
5522  *             DuToCuRRCContainer, DuToCuRRCContainer
5523  *
5524  * @return ROK     - success
5525  *         RFAILED - failure
5526  *
5527  * ****************************************************************/
5528 uint8_t BuildDuToCuRrcContainer(DUtoCURRCContainer_t *duToCuRrcContainer)
5529 {
5530    uint8_t  ret = ROK;
5531    CellGroupConfigRrc_t  cellGrpCfg;
5532    asn_enc_rval_t        encRetVal;
5533    memset(&cellGrpCfg, 0, sizeof(CellGroupConfigRrc_t));
5534    memset(&encRetVal, 0, sizeof(asn_enc_rval_t));
5535
5536    while(true)
5537    {
5538       cellGrpCfg.cellGroupId = CELL_GRP_ID;
5539
5540       cellGrpCfg.rlc_BearerToAddModList = NULLP;
5541       DU_ALLOC(cellGrpCfg.rlc_BearerToAddModList, sizeof(struct CellGroupConfigRrc__rlc_BearerToAddModList));
5542       if(!cellGrpCfg.rlc_BearerToAddModList)
5543       {
5544          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildDuToCuRrcContainer");
5545          ret = RFAILED;
5546          break;
5547       }
5548       if(BuildRlcBearerToAddModList(cellGrpCfg.rlc_BearerToAddModList) != ROK)
5549       {
5550          DU_LOG("\nERROR  -->  F1AP : BuildRlcBearerToAddModList failed");
5551          ret = RFAILED;
5552          break;
5553       }
5554
5555       cellGrpCfg.rlc_BearerToReleaseList = NULLP;
5556       cellGrpCfg.mac_CellGroupConfig = NULLP;
5557       DU_ALLOC(cellGrpCfg.mac_CellGroupConfig, sizeof(MAC_CellGroupConfig_t));
5558       if(!cellGrpCfg.mac_CellGroupConfig)
5559       {
5560          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildDuToCuRrcContainer");
5561          ret = RFAILED;
5562          break;
5563       }
5564       if(BuildMacCellGrpCfg(cellGrpCfg.mac_CellGroupConfig) != ROK)
5565       {
5566          DU_LOG("\nERROR  -->  F1AP : BuildMacCellGrpCfg failed");
5567          ret = RFAILED;
5568          break;
5569       }
5570
5571       cellGrpCfg.physicalCellGroupConfig = NULLP;
5572       DU_ALLOC(cellGrpCfg.physicalCellGroupConfig, sizeof(PhysicalCellGroupConfig_t));
5573       if(!cellGrpCfg.physicalCellGroupConfig)
5574       {
5575          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildDuToCuRrcContainer");
5576          ret = RFAILED;
5577          break;
5578       }
5579       if(BuildPhyCellGrpCfg(cellGrpCfg.physicalCellGroupConfig) != ROK)
5580       {
5581          DU_LOG("\nERROR  -->  F1AP : BuildPhyCellGrpCfg failed");
5582          ret = RFAILED;
5583          break;
5584       }
5585
5586       cellGrpCfg.spCellConfig = NULLP;
5587       DU_ALLOC(cellGrpCfg.spCellConfig, sizeof(SpCellConfig_t));
5588       if(!cellGrpCfg.spCellConfig)
5589       {
5590          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildDuToCuRrcContainer");
5591          ret = RFAILED;
5592          break;
5593       }
5594       if(BuildSpCellCfg(cellGrpCfg.spCellConfig) != ROK)
5595       {
5596          DU_LOG("\nERROR  -->  F1AP : BuildSpCellCfg failed");
5597          ret = RFAILED;
5598          break;
5599       }
5600
5601       cellGrpCfg.sCellToAddModList = NULLP;
5602       cellGrpCfg.sCellToReleaseList = NULLP;
5603       cellGrpCfg.ext1 = NULLP;
5604
5605       /* encode cellGrpCfg into duToCuRrcContainer */
5606       xer_fprint(stdout, &asn_DEF_CellGroupConfigRrc, &cellGrpCfg);
5607       memset(encBuf, 0, ENC_BUF_MAX_LEN);
5608       encBufSize = 0;
5609       encRetVal = aper_encode(&asn_DEF_CellGroupConfigRrc, 0, &cellGrpCfg, PrepFinalEncBuf, encBuf);
5610       /* Encode results */
5611       if(encRetVal.encoded == ENCODE_FAIL)
5612       {
5613          DU_LOG( "\nERROR  --> F1AP : Could not encode DuToCuRrcContainer (at %s)\n",\
5614                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
5615          ret = RFAILED;
5616          break;
5617       }
5618       else
5619       {
5620          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for DuToCuRrcContainer\n");
5621          for(int i=0; i< encBufSize; i++)
5622          {
5623             printf("%x",encBuf[i]);
5624          }
5625       }
5626
5627       duToCuRrcContainer->size = encBufSize;
5628       DU_ALLOC(duToCuRrcContainer->buf, duToCuRrcContainer->size);
5629       if(!duToCuRrcContainer->buf)
5630       {
5631          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDuToCuRrcContainer");
5632          ret = RFAILED;
5633          break;
5634       }
5635       if(ret == ROK)
5636       {
5637          memcpy(duToCuRrcContainer->buf, encBuf, duToCuRrcContainer->size);
5638       }
5639       break;
5640    }
5641    FreeMemDuToCuRrcCont(&cellGrpCfg);
5642    return ret;
5643 }
5644
5645 /*******************************************************************
5646  *
5647  * @brief Free memory allocated in InitialULRRCMessage
5648  *
5649  * @details
5650  *
5651  *    Function : freeInitUlRrcMsgTransfer
5652  *
5653  *    Functionality: Free memory allocated in InitialULRRCMessage
5654  *
5655  * @params[in]F1AP_PDU_t  *f1apMsg)
5656  *
5657  * @return ROK     - success
5658  *         RFAILED - failure
5659  *
5660  * ****************************************************************/
5661
5662 uint8_t freeInitUlRrcMsgTransfer(F1AP_PDU_t  *f1apMsg)
5663 {
5664    uint8_t ieIdx, arrIdx;
5665    InitialULRRCMessageTransfer_t *initULRRCMsg=NULLP;
5666
5667    if(f1apMsg)
5668    {
5669       if(f1apMsg->choice.initiatingMessage)
5670       {
5671          initULRRCMsg = &f1apMsg->choice.initiatingMessage->value.\
5672             choice.InitialULRRCMessageTransfer;
5673          if(initULRRCMsg->protocolIEs.list.array)
5674          {
5675             for(ieIdx = 0; ieIdx < initULRRCMsg->protocolIEs.list.count; ieIdx++)
5676             {
5677                switch(initULRRCMsg->protocolIEs.list.array[ieIdx]->id)
5678                {
5679                   case ProtocolIE_ID_id_NRCGI:
5680                   {
5681                      if(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.pLMN_Identity.buf)
5682                      {
5683                         if(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.nRCellIdentity.buf)
5684                         {
5685                            DU_FREE(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.nRCellIdentity.buf,\
5686                            initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.nRCellIdentity.size);
5687                         }
5688                         DU_FREE(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.pLMN_Identity.buf,\
5689                         initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.pLMN_Identity.size);
5690                      }
5691                      break;
5692                   }
5693                   case ProtocolIE_ID_id_RRCContainer:
5694                   {
5695                      if(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf)
5696                      {
5697                         DU_FREE(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf,\
5698                         initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.size);
5699                      }
5700                      break;
5701                   }
5702                   case ProtocolIE_ID_id_DUtoCURRCContainer:
5703                   {
5704                      if(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.DUtoCURRCContainer.buf)
5705                      {
5706                         DU_FREE(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.DUtoCURRCContainer.buf,
5707                         initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.DUtoCURRCContainer.size);
5708                      }
5709                      break;
5710                   }
5711                   default:
5712                      break;
5713                }
5714              }
5715              for(arrIdx = 0; arrIdx < ieIdx; arrIdx++)
5716              {
5717                 if(initULRRCMsg->protocolIEs.list.array[arrIdx])
5718                 {
5719                    DU_FREE(initULRRCMsg->protocolIEs.list.array[arrIdx],\
5720                       sizeof(InitialULRRCMessageTransferIEs_t));
5721                 }
5722              }
5723              DU_FREE(initULRRCMsg->protocolIEs.list.array, initULRRCMsg->protocolIEs.list.size);
5724           }
5725          DU_FREE(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
5726       }
5727       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
5728    }
5729    else
5730    {
5731       DU_LOG("\nERROR  -->  DU_APP : Recevied F1ap Pdu is null at freeInitUlRrcMsgTransfer()");
5732       return RFAILED;
5733    }
5734    return ROK;
5735 }
5736
5737 /*******************************************************************
5738  *
5739  * @brief Builds and sends the InitialULRRCMessage
5740  *
5741  * @details
5742  *
5743  *    Function : BuildAndSendInitialRrcMsgTransfer
5744  *
5745  *    Functionality: Constructs the Initial UL RRC Message Transfer and sends
5746  *                   it to the CU through SCTP.
5747  *
5748  * @params[in]
5749  *
5750  * @return ROK     - success
5751  *         RFAILED - failure
5752  *
5753  * ****************************************************************/
5754 uint8_t BuildAndSendInitialRrcMsgTransfer(uint32_t gnbDuUeF1apId, uint16_t crnti,
5755       uint16_t rrcContSize, uint8_t *rrcContainer)
5756 {
5757    uint8_t   ret;
5758    uint8_t   elementCnt;
5759    uint8_t   ieIdx;
5760    asn_enc_rval_t  encRetVal;
5761    F1AP_PDU_t  *f1apMsg = NULLP;
5762    InitialULRRCMessageTransfer_t *initULRRCMsg = NULLP;
5763    memset(&encRetVal, 0, sizeof(asn_enc_rval_t));
5764
5765    while(true)
5766    {
5767       DU_LOG("\n INFO   -->  F1AP : Building RRC Setup Request\n");
5768       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
5769       if(f1apMsg == NULLP)
5770       {
5771          DU_LOG(" ERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
5772          break;
5773       }
5774       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
5775       DU_ALLOC(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
5776       if(f1apMsg->choice.initiatingMessage == NULLP)
5777       {
5778          DU_LOG(" ERROR  -->  F1AP : Memory allocation for  F1AP-PDU failed");
5779          break;
5780       }
5781       f1apMsg->choice.initiatingMessage->procedureCode =\
5782                                                         ProcedureCode_id_InitialULRRCMessageTransfer;
5783       f1apMsg->choice.initiatingMessage->criticality = Criticality_ignore;
5784       f1apMsg->choice.initiatingMessage->value.present = \
5785                                                          InitiatingMessage__value_PR_InitialULRRCMessageTransfer;
5786       initULRRCMsg =\
5787                     &f1apMsg->choice.initiatingMessage->value.choice.InitialULRRCMessageTransfer;
5788       elementCnt = 5;
5789       initULRRCMsg->protocolIEs.list.count = elementCnt;
5790       initULRRCMsg->protocolIEs.list.size = \
5791                                             elementCnt * sizeof(InitialULRRCMessageTransferIEs_t *);
5792       /* Initialize the F1Setup members */
5793       DU_ALLOC(initULRRCMsg->protocolIEs.list.array,initULRRCMsg->protocolIEs.list.size);
5794       if(initULRRCMsg->protocolIEs.list.array == NULLP)
5795       {
5796          DU_LOG(" ERROR  -->  F1AP : Memory allocation for\
5797                RRCSetupRequestMessageTransferIEs failed");
5798          break;
5799       }
5800       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
5801       {
5802          DU_ALLOC(initULRRCMsg->protocolIEs.list.array[ieIdx],\
5803                sizeof(InitialULRRCMessageTransferIEs_t));
5804          if(initULRRCMsg->protocolIEs.list.array[ieIdx] == NULLP)
5805          {
5806             break;
5807          }
5808       }
5809       ieIdx = 0;
5810       /*GNB DU UE F1AP ID*/
5811       initULRRCMsg->protocolIEs.list.array[ieIdx]->id  = \
5812                                                         ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
5813       initULRRCMsg->protocolIEs.list.array[ieIdx]->criticality  = Criticality_reject;
5814       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.present = \
5815                                                                   InitialULRRCMessageTransferIEs__value_PR_GNB_DU_UE_F1AP_ID;
5816       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID = gnbDuUeF1apId;
5817
5818
5819       /*NRCGI*/
5820       ieIdx++;
5821       initULRRCMsg->protocolIEs.list.array[ieIdx]->id  = \
5822                                                         ProtocolIE_ID_id_NRCGI;
5823       initULRRCMsg->protocolIEs.list.array[ieIdx]->criticality  =Criticality_reject;
5824       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.present = \
5825                                                                   InitialULRRCMessageTransferIEs__value_PR_NRCGI;
5826
5827       ret =\
5828            BuildNrcgi(&initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI);
5829       if(ret!=ROK)
5830       {
5831          break;
5832       }
5833
5834       /*CRNTI*/
5835       ieIdx++;
5836       initULRRCMsg->protocolIEs.list.array[ieIdx]->id  = \
5837                                                         ProtocolIE_ID_id_C_RNTI;
5838       initULRRCMsg->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
5839       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.present =\
5840                                                                  InitialULRRCMessageTransferIEs__value_PR_C_RNTI;
5841       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.C_RNTI = crnti;
5842
5843       /*RRCContainer*/
5844       ieIdx++;
5845       initULRRCMsg->protocolIEs.list.array[ieIdx]->id  = \
5846                                                         ProtocolIE_ID_id_RRCContainer;
5847       initULRRCMsg->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
5848       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.present =\
5849                                                                  InitialULRRCMessageTransferIEs__value_PR_RRCContainer;
5850
5851       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.size = rrcContSize;
5852       DU_ALLOC(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf,
5853             initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.size)
5854       if(!initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf)
5855       {
5856          DU_LOG(" ERROR  -->  F1AP : Memory allocation for RRCSetupRequestMessageTransferIEs failed");
5857          break;
5858
5859       }
5860       memcpy(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf, rrcContainer,
5861             initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.size);
5862
5863
5864       /*DUtoCURRCContainer*/
5865       ieIdx++;
5866       initULRRCMsg->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_DUtoCURRCContainer;
5867       initULRRCMsg->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
5868       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.present =\
5869                                                                  InitialULRRCMessageTransferIEs__value_PR_DUtoCURRCContainer;
5870
5871       ret = BuildDuToCuRrcContainer(&initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.DUtoCURRCContainer);
5872       if(ret != ROK)
5873       {
5874          break;
5875       }
5876
5877       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
5878
5879       /* Encode the F1SetupRequest type as APER */
5880       memset(encBuf, 0, ENC_BUF_MAX_LEN);
5881       encBufSize = 0;
5882       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
5883       /* Encode results */
5884       if(encRetVal.encoded == ENCODE_FAIL)
5885       {
5886          DU_LOG( "\nERROR  --> F1AP : Could not encode Initial UL RRC Message Transfer\
5887                structure (at %s)\n",encRetVal.failed_type ? \
5888                encRetVal.failed_type->name : "unknown");
5889          ret = RFAILED;
5890          break;
5891       }
5892       else
5893       {
5894
5895          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for Initial UL RRC\
5896                Message transfer\n");
5897          for(int i=0; i< encBufSize; i++)
5898          {
5899             printf("%x",encBuf[i]);
5900          }
5901       }
5902       /* Sending  msg  */
5903       if(SendF1APMsg(DU_APP_MEM_REGION,DU_POOL) != ROK)
5904       {
5905          DU_LOG("\nERROR  -->  F1AP : Sending Initial UL RRC Message Transfer Failed");
5906          ret = RFAILED;
5907          break;
5908       }
5909       break;
5910    }
5911    freeInitUlRrcMsgTransfer(f1apMsg);
5912    return ret;
5913 }/* End of BuildAndSendInitialRrcMsgTransfer*/
5914
5915 /*****  UE SETUP REQUEST *****/
5916
5917 /*******************************************************************
5918  *
5919  * @brief Free Qos And Snssai Drb Info
5920  *
5921  * @details
5922  *
5923  *    Function : freeDrbQosAndSnssaiInfo
5924  *
5925  *    Functionality: Free Qos And Snssai Drb Info
5926  *
5927  * @params[in] LcCfg *lcCfg,
5928  * @return void
5929  *
5930  * ****************************************************************/
5931 void freeDrbQosAndSnssaiInfo(LcCfg *lcCfg)
5932 {
5933    if(lcCfg->snssai)
5934    {
5935       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->snssai, sizeof(Snssai));
5936    }
5937    if(lcCfg->drbQos)
5938    {
5939       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->drbQos, sizeof(DrbQosInfo));
5940    }
5941 }
5942
5943 /******************************************************************
5944 *
5945 * @brief Function to delete the RLC Lc cfg from UE APP DB
5946 *
5947 * @details
5948 *
5949 *  Function : freeRlcLcCfg
5950 *
5951 *  Functionality: Function to delete the RLC Lc cfg from UE APP DB
5952 *
5953 *
5954  *****************************************************************/
5955
5956 void freeRlcLcCfg(RlcBearerCfg *lcCfg)
5957 {
5958    switch(lcCfg->rlcMode)
5959    {
5960       case RLC_AM :
5961       {
5962          if(lcCfg->u.amCfg)
5963          {
5964             DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->u.amCfg, sizeof(AmBearerCfg));
5965             lcCfg->u.amCfg = NULLP;
5966          }
5967          break;
5968       }
5969       case RLC_UM_BI_DIRECTIONAL :
5970       {
5971          if(lcCfg->u.umBiDirCfg)
5972          {
5973             DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->u.umBiDirCfg, sizeof(UmBiDirBearerCfg));
5974             lcCfg->u.umBiDirCfg = NULLP;
5975          }
5976          break;
5977       }
5978       case RLC_UM_UNI_DIRECTIONAL_UL :
5979       {
5980          if(lcCfg->u.umUniDirUlCfg)
5981          {
5982             DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->u.umUniDirUlCfg, sizeof(UmUniDirUlBearerCfg));
5983             lcCfg->u.umUniDirUlCfg = NULLP;
5984          }
5985          break;
5986
5987       }
5988       case RLC_UM_UNI_DIRECTIONAL_DL :
5989       {
5990          if(lcCfg->u.umUniDirDlCfg)
5991          {
5992             DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->u.umUniDirDlCfg, sizeof(UmUniDirDlBearerCfg));
5993             lcCfg->u.umUniDirDlCfg = NULLP;
5994          }
5995          break;
5996       }
5997       default:
5998          DU_LOG("\nERROR  -->  DU_APP: Invalid Rlc Mode %d at freeRlcLcCfg()", lcCfg->rlcMode);
5999          break;
6000    }
6001    memset(lcCfg, 0, sizeof(LcCfg));
6002 }
6003 /*******************************************************************
6004  *
6005  * @brief Function to free MacLcCfg
6006  *
6007  * @details
6008  *
6009  *    Function : freeMacLcCfg
6010  *
6011  *    Functionality: Function to free MacLcCfg
6012  *
6013  * @params[in] LcCfg *lcCfg,
6014  * @return void
6015  *
6016  * ****************************************************************/
6017
6018 void  freeMacLcCfg(LcCfg *lcCfg)
6019 {
6020     /* Deleting DRBQOS */
6021    if(lcCfg->drbQos)
6022    {
6023       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->drbQos, sizeof(DrbQosInfo));
6024       lcCfg->drbQos = NULLP;
6025    }
6026    /* Deleting SNSSAI */
6027    if(lcCfg->snssai)
6028    {
6029       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->snssai, sizeof(Snssai));
6030       lcCfg->snssai = NULLP;
6031    }
6032    memset(lcCfg, 0, sizeof(LcCfg));
6033 }
6034 /*******************************************************************
6035  *
6036  * @brief Free UE NR Capability received in UE Context setup request
6037  *
6038  * @details
6039  *
6040  *    Function : freeAperDecodeUeNrCapability
6041  *
6042  *    Functionality:
6043  *       Free UE NR Capability received in UE Context setup request
6044  *
6045  * @params[in]
6046  * @return ROK     - success
6047  *         RFAILED - failure
6048  *
6049  * ****************************************************************/
6050 void freeAperDecodeUeNrCapability(void *ueNrCapability)
6051 {
6052    uint8_t arrIdx =0;
6053    FeatureSets_t *featureSets =NULLP;
6054    UE_NR_Capability_t *ueNrCap = (UE_NR_Capability_t *)ueNrCapability;
6055
6056    if(ueNrCap->rf_Parameters.supportedBandListNR.list.array)
6057    {
6058       for(arrIdx = 0; arrIdx < ueNrCap->rf_Parameters.supportedBandListNR.list.count; arrIdx++)
6059       {
6060          if(ueNrCap->rf_Parameters.supportedBandListNR.list.array[arrIdx])
6061             free(ueNrCap->rf_Parameters.supportedBandListNR.list.array[arrIdx]);
6062       }
6063       free(ueNrCap->rf_Parameters.supportedBandListNR.list.array);
6064    }
6065
6066    if(ueNrCap->featureSets)
6067    {
6068       featureSets = ueNrCap->featureSets;
6069       if(featureSets->featureSetsDownlinkPerCC)
6070       {
6071          if(featureSets->featureSetsDownlinkPerCC->list.array)
6072          {
6073             for(arrIdx = 0; arrIdx < featureSets->featureSetsDownlinkPerCC->list.count; arrIdx++)
6074             {
6075                if(featureSets->featureSetsDownlinkPerCC->list.array[arrIdx])
6076                {
6077                   if(featureSets->featureSetsDownlinkPerCC->list.array[arrIdx]->supportedModulationOrderDL)
6078                      free(featureSets->featureSetsDownlinkPerCC->list.array[arrIdx]->supportedModulationOrderDL);
6079                   free(featureSets->featureSetsDownlinkPerCC->list.array[arrIdx]);
6080                }
6081             }
6082             free(featureSets->featureSetsDownlinkPerCC->list.array);
6083          }
6084          free(featureSets->featureSetsDownlinkPerCC);
6085       }
6086       if(featureSets->featureSetsUplinkPerCC)
6087       {
6088          if(featureSets->featureSetsUplinkPerCC->list.array)
6089          {
6090             for(arrIdx = 0; arrIdx < featureSets->featureSetsUplinkPerCC->list.count; arrIdx++)
6091             {
6092                if(featureSets->featureSetsUplinkPerCC->list.array[arrIdx])
6093                {
6094                   if(featureSets->featureSetsUplinkPerCC->list.array[arrIdx]->supportedModulationOrderUL)
6095                      free(featureSets->featureSetsUplinkPerCC->list.array[arrIdx]->supportedModulationOrderUL);
6096                   free(featureSets->featureSetsUplinkPerCC->list.array[arrIdx]);
6097                }
6098             }
6099             free(featureSets->featureSetsUplinkPerCC->list.array);
6100          }
6101          free(featureSets->featureSetsUplinkPerCC);
6102       }
6103       free(ueNrCap->featureSets);
6104    }
6105 }
6106
6107 /*******************************************************************
6108 *
6109 * @brief Function to free PdcchSearchSpcToAddModList
6110          where memory allocated by aper_decoder
6111 *
6112 * @details
6113 *
6114 *    Function : freeAperDecodePdcchSearchSpcToAddModList
6115 *
6116 *    Functionality: Function to free PdcchSearchSpcToAddModList
6117 *
6118 * @params[in] struct PDCCH_Config__searchSpacesToAddModList *searchSpcList
6119 * @return void
6120 *
6121 * ****************************************************************/
6122
6123 void freeAperDecodePdcchSearchSpcToAddModList(struct PDCCH_Config__searchSpacesToAddModList *searchSpcList)
6124 {
6125    uint8_t searchSpcArrIdx=0;
6126    uint8_t searchSpcArrIdx1=0;
6127    struct  SearchSpace *searchSpc=NULLP;
6128
6129
6130    if(searchSpcList->list.array)
6131    {
6132       if(searchSpcList->list.array[searchSpcArrIdx1])
6133       {
6134          searchSpc = searchSpcList->list.array[searchSpcArrIdx1];
6135          if(searchSpc->controlResourceSetId)
6136          {
6137             if(searchSpc->monitoringSlotPeriodicityAndOffset)
6138             {
6139                if(searchSpc->monitoringSymbolsWithinSlot)
6140                {
6141                   if(searchSpc->monitoringSymbolsWithinSlot->buf)
6142                   {
6143                      if(searchSpc->nrofCandidates)
6144                      {
6145                         if(searchSpc->searchSpaceType)
6146                         {
6147                            free(searchSpc->searchSpaceType->choice.ue_Specific);
6148                            free(searchSpc->searchSpaceType);
6149                         }
6150                         free(searchSpc->nrofCandidates);
6151                      }
6152                      free(searchSpc->monitoringSymbolsWithinSlot->buf);
6153                   }
6154                   free(searchSpc->monitoringSymbolsWithinSlot);
6155                }
6156                free(searchSpc->monitoringSlotPeriodicityAndOffset);
6157             }
6158             free(searchSpc->controlResourceSetId);
6159          }
6160       }
6161       for(searchSpcArrIdx = 0; searchSpcArrIdx < searchSpcList->list.count; searchSpcArrIdx++)
6162       {
6163          free(searchSpcList->list.array[searchSpcArrIdx]);
6164       }
6165       free(searchSpcList->list.array);
6166    }
6167 }
6168 /*******************************************************************
6169 *
6170 * @brief Function for free part for the memory allocated by aper_decoder
6171 *
6172 * @details
6173 *
6174 *    Function : freeAperDecodeBWPDlDedPdcchConfig
6175 *
6176 *    Functionality: Function to free BWPDlDedPdcchConfig
6177 *
6178 * @params[in]
6179 * @return void
6180 *
6181 * ****************************************************************/
6182
6183
6184 void freeAperDecodeBWPDlDedPdcchConfig(BWP_DownlinkDedicated_t *dlBwp)
6185 {
6186    uint8_t arrIdx1=0;
6187    uint8_t arrIdx2=0;
6188    struct PDCCH_Config *pdcchCfg=NULLP;
6189    struct ControlResourceSet *controlRSet=NULLP;
6190    struct PDCCH_Config__controlResourceSetToAddModList *controlRSetList=NULLP;
6191
6192    if(dlBwp->pdcch_Config->choice.setup)
6193    {
6194       pdcchCfg=dlBwp->pdcch_Config->choice.setup;
6195       if(pdcchCfg->controlResourceSetToAddModList)
6196       {
6197          controlRSetList = pdcchCfg->controlResourceSetToAddModList;
6198          if(controlRSetList->list.array)
6199          {
6200             controlRSet = controlRSetList->list.array[arrIdx2];
6201             if(controlRSet)
6202             {
6203                if(controlRSet->frequencyDomainResources.buf)
6204                {
6205                   if(controlRSet->pdcch_DMRS_ScramblingID)
6206                   {
6207                      if(pdcchCfg->searchSpacesToAddModList)
6208                      {
6209                         freeAperDecodePdcchSearchSpcToAddModList(pdcchCfg->searchSpacesToAddModList);
6210                         free(pdcchCfg->searchSpacesToAddModList);
6211                      }
6212                      free(controlRSet->pdcch_DMRS_ScramblingID);
6213                   }
6214                   free(controlRSet->frequencyDomainResources.buf);
6215                }
6216             }
6217             for(arrIdx1 = 0; arrIdx1 <controlRSetList->list.count; arrIdx1++)
6218             {
6219                free(controlRSetList->list.array[arrIdx1]);
6220             }
6221             free(controlRSetList->list.array);
6222          }
6223          free(pdcchCfg->controlResourceSetToAddModList);
6224       }
6225       free(dlBwp->pdcch_Config->choice.setup);
6226    }
6227 }
6228 /*******************************************************************
6229 *
6230 * @brief Function to free PdschTimeDomAllocationList
6231 *     where the memory allocated by aper_decoder
6232 *
6233 * @details
6234 *
6235 *    Function : freeAperDecodePdschTimeDomAllocationList
6236 *
6237 *    Functionality: Function to free PdschTimeDomAllocationList
6238 *
6239 * @params[in] struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList
6240 * @return void
6241 *
6242 * ****************************************************************/
6243
6244
6245 void freeAperDecodePdschTimeDomAllocationList( struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList)
6246 {
6247    uint8_t arrIdx=0;
6248
6249    if(timeDomAllocList->choice.setup)
6250    {
6251       if(timeDomAllocList->choice.setup->list.array)
6252       {
6253          for(arrIdx = 0; arrIdx <timeDomAllocList->choice.setup->list.count ; arrIdx++)
6254          {
6255             free(timeDomAllocList->choice.setup->list.array[arrIdx]);
6256          }
6257          free(timeDomAllocList->choice.setup->list.array);
6258       }
6259       free(timeDomAllocList->choice.setup);
6260    }
6261 }
6262
6263 /*******************************************************************
6264 *
6265 * @brief Function to free BWPDlDedPdschConfig
6266 *        where the memory allocated by aper_decoder
6267 *
6268 * @details
6269 *
6270 *    Function : freeAperDecodeBWPDlDedPdschConfig
6271 *
6272 *    Functionality: Function to free BWPDlDedPdschConfig
6273 *
6274 * @params[in] BWP_DownlinkDedicated_t *dlBwp
6275 * @return void
6276 *
6277 * ****************************************************************/
6278
6279
6280 void freeAperDecodeBWPDlDedPdschConfig(BWP_DownlinkDedicated_t *dlBwp)
6281 {
6282    struct PDSCH_Config *pdschCfg=NULLP;
6283    struct PDSCH_Config__prb_BundlingType *prbBndlType=NULLP;
6284    struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList=NULLP;
6285    struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA *dmrsDlCfg=NULLP;
6286
6287    if(dlBwp->pdsch_Config->choice.setup)
6288    {
6289       pdschCfg=dlBwp->pdsch_Config->choice.setup;
6290       if(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA)
6291       {
6292          if(pdschCfg->pdsch_TimeDomainAllocationList)
6293          {
6294             timeDomAllocList=pdschCfg->pdsch_TimeDomainAllocationList;
6295             if(pdschCfg->maxNrofCodeWordsScheduledByDCI)
6296             {
6297                prbBndlType=&pdschCfg->prb_BundlingType;
6298                free(prbBndlType->choice.staticBundling);
6299                free(pdschCfg->maxNrofCodeWordsScheduledByDCI);
6300             }
6301             freeAperDecodePdschTimeDomAllocationList(timeDomAllocList);
6302             free(pdschCfg->pdsch_TimeDomainAllocationList);
6303          }
6304          dmrsDlCfg=pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA;
6305          if(dmrsDlCfg->choice.setup)
6306          {
6307             free(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition);
6308             free(dmrsDlCfg->choice.setup);
6309          }
6310          free(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA);
6311       }
6312       free(dlBwp->pdsch_Config->choice.setup);
6313    }
6314 }
6315 /*******************************************************************
6316 *
6317 * @brief Function to free PuschTimeDomAllocListCfg
6318                  where the memory allocated by aper_decoder
6319 *
6320 * @details
6321 *
6322 *    Function : freeAperDecodePuschTimeDomAllocListCfg
6323 *
6324 *    Functionality: Function to free PuschTimeDomAllocListCfg
6325 *
6326 * @params[in] PUSCH_Config_t *puschCfg
6327 * @return void
6328 *
6329 * ****************************************************************/
6330
6331
6332 void freeAperDecodePuschTimeDomAllocListCfg(PUSCH_Config_t *puschCfg)
6333 {
6334    uint8_t arrIdx=0;
6335    uint8_t arrIdx1=0;
6336    struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList_t=NULLP;
6337
6338    if(puschCfg->pusch_TimeDomainAllocationList)
6339    {
6340       timeDomAllocList_t=puschCfg->pusch_TimeDomainAllocationList;
6341       if(timeDomAllocList_t->choice.setup)
6342       {
6343          if(timeDomAllocList_t->choice.setup->list.array)
6344          {
6345             free(timeDomAllocList_t->choice.setup->list.array[arrIdx1]->k2);
6346             for(arrIdx = 0; arrIdx<timeDomAllocList_t->choice.setup->list.count; arrIdx++)
6347             {
6348                free(timeDomAllocList_t->choice.setup->list.array[arrIdx]);
6349             }
6350             free(timeDomAllocList_t->choice.setup->list.array);
6351          }
6352          free(timeDomAllocList_t->choice.setup);
6353       }
6354       free(puschCfg->transformPrecoder);
6355       free(puschCfg->pusch_TimeDomainAllocationList);
6356    }
6357 }
6358 /*******************************************************************
6359 *
6360 * @brief Function to free InitialUlBWPConfig where memory allocated by aper_decoder
6361 *
6362 * @details
6363 *
6364 *    Function : freeAperDecodeInitialUlBWPConfig
6365 *
6366 *    Functionality: Function to free InitialUlBWPConfig
6367 *
6368 * @params[in]  BWP_UplinkDedicated_t *ulBwp
6369 * @return void
6370 *
6371 * ****************************************************************/
6372
6373
6374 void freeAperDecodeInitialUlBWPConfig(BWP_UplinkDedicated_t *ulBwp)
6375 {
6376    uint8_t  rSetIdx =0;
6377    uint8_t  rsrcIdx =0;
6378    SRS_Config_t   *srsCfg = NULLP;
6379    PUSCH_Config_t *puschCfg = NULLP;
6380    struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA *dmrsUlCfg = NULLP;
6381    struct SRS_Config__srs_ResourceSetToAddModList *rsrcSetList = NULLP;
6382    struct SRS_ResourceSet__srs_ResourceIdList *rsrcIdList = NULLP;
6383    struct SRS_Config__srs_ResourceToAddModList *resourceList = NULLP;
6384
6385    if(ulBwp->pusch_Config)
6386    {
6387       if(ulBwp->pusch_Config->choice.setup)
6388       {
6389          puschCfg=ulBwp->pusch_Config->choice.setup;
6390          if(puschCfg->dataScramblingIdentityPUSCH)
6391          {
6392             if(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA)
6393             {
6394                freeAperDecodePuschTimeDomAllocListCfg(puschCfg);
6395                dmrsUlCfg=puschCfg->dmrs_UplinkForPUSCH_MappingTypeA;
6396                if(dmrsUlCfg->choice.setup)
6397                {
6398                   if(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition)
6399                   {
6400                      if(dmrsUlCfg->choice.setup->transformPrecodingDisabled)
6401                      {
6402                         free(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0);
6403                         free(dmrsUlCfg->choice.setup->transformPrecodingDisabled);
6404                      }
6405                      free(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition);
6406                   }
6407                   free(dmrsUlCfg->choice.setup);
6408                }
6409                free(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA);
6410             }
6411             free(puschCfg->dataScramblingIdentityPUSCH);
6412          }
6413          free(ulBwp->pusch_Config->choice.setup);
6414       }
6415       free(ulBwp->pusch_Config);
6416
6417       /* Free SRS-Config */
6418       if(ulBwp->srs_Config)
6419       {
6420          if(ulBwp->srs_Config->choice.setup)
6421          {
6422             srsCfg = ulBwp->srs_Config->choice.setup;
6423
6424             /* Free Resource Set to add/mod list */
6425             if(srsCfg->srs_ResourceSetToAddModList)
6426             {
6427                rsrcSetList = srsCfg->srs_ResourceSetToAddModList;
6428                if(rsrcSetList->list.array)
6429                {
6430                   rSetIdx = 0;
6431
6432                   /* Free SRS resource Id list in this SRS resource set */
6433                   if(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList)
6434                   {
6435                      rsrcIdList =
6436                         rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList;
6437
6438                      if(rsrcIdList->list.array)
6439                      {
6440                         for(rsrcIdx = 0; rsrcIdx < rsrcIdList->list.count;
6441                               rsrcIdx++)
6442                         {
6443                            free(rsrcIdList->list.array[rsrcIdx]);
6444                         }
6445                         free(rsrcIdList->list.array);
6446                      }
6447                      free(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList);
6448                   }
6449
6450                   /* Free resource type info for this SRS resource set */
6451
6452                   free(rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic);
6453
6454                   /* Free memory for each resource set */
6455                   for(rSetIdx = 0; rSetIdx < rsrcSetList->list.count; rSetIdx++)
6456                   {
6457                      free(rsrcSetList->list.array[rSetIdx]);
6458                   }
6459                   free(rsrcSetList->list.array);
6460                }
6461                free(srsCfg->srs_ResourceSetToAddModList);
6462             }
6463
6464             /* Free resource to add/modd list */
6465             if(srsCfg->srs_ResourceToAddModList)
6466             {
6467                resourceList = srsCfg->srs_ResourceToAddModList;
6468                if(resourceList->list.array)
6469                {
6470                   rsrcIdx = 0;
6471
6472                   free(resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2);
6473                   free(resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic);
6474
6475                   for(rsrcIdx = 0; rsrcIdx < resourceList->list.count; rsrcIdx++)
6476                   {
6477                      free(resourceList->list.array[rsrcIdx]);
6478                   }
6479                   free(resourceList->list.array);
6480                }
6481                free(srsCfg->srs_ResourceToAddModList);
6482             }
6483
6484             free(ulBwp->srs_Config->choice.setup);
6485          }
6486          free(ulBwp->srs_Config);
6487       }
6488    }
6489 }
6490 /*******************************************************************
6491 *
6492 * @brief Function to free initialUplinkBWPConfig where memory allocated by aper_decoder
6493 *
6494 * @details
6495 *
6496 *    Function : freeAperDecodeinitialUplinkBWPConfig
6497 *
6498 *    Functionality: Function to free initialUplinkBWPConfig
6499 *
6500 * @params[in] UplinkConfig_t *ulCfg
6501 * @return void
6502 *
6503 * ****************************************************************/
6504
6505
6506 void freeAperDecodeinitialUplinkBWPConfig(UplinkConfig_t *ulCfg)
6507 {
6508    BWP_UplinkDedicated_t *ulBwp=NULLP;
6509    struct UplinkConfig__pusch_ServingCellConfig *puschCfg=NULLP;
6510
6511    if(ulCfg->initialUplinkBWP)
6512    {
6513       ulBwp=ulCfg->initialUplinkBWP;
6514       if(ulCfg->firstActiveUplinkBWP_Id)
6515       {
6516          if(ulCfg->pusch_ServingCellConfig)
6517          {
6518             puschCfg=ulCfg->pusch_ServingCellConfig;
6519             if(puschCfg->choice.setup)
6520             {
6521                if(puschCfg->choice.setup->ext1)
6522                {
6523                   free(puschCfg->choice.setup->ext1->processingType2Enabled);
6524                   free(puschCfg->choice.setup->ext1->maxMIMO_Layers);
6525                   free(puschCfg->choice.setup->ext1);
6526                }
6527                free(puschCfg->choice.setup);
6528             }
6529             free(ulCfg->pusch_ServingCellConfig);
6530          }
6531          free(ulCfg->firstActiveUplinkBWP_Id);
6532       }
6533       freeAperDecodeInitialUlBWPConfig(ulBwp);
6534       free(ulCfg->initialUplinkBWP);
6535    }
6536 }
6537
6538 /*******************************************************************
6539  *
6540  * @brief Function to free DuUeCfg
6541  *
6542  * @details
6543  *
6544  *    Function : freeDuUeCfg
6545  *
6546  *    Functionality: Function to free DuUeCfg
6547  *
6548  * @params[in] DuUeCfg *ueCfg
6549  * @return void
6550  *
6551  * ****************************************************************/
6552 void freeDuUeCfg(DuUeCfg *ueCfg)
6553 {
6554    uint8_t lcIdx = 0;
6555    uint8_t arrIdx = 0;
6556    SpCellConfig_t *spCellCfg = NULLP;
6557    ServingCellConfig_t *srvCellCfg = NULLP;
6558    BWP_DownlinkDedicated_t *dlBwp = NULLP;
6559    MAC_CellGroupConfig_t *macCellGrpCfg = NULLP;
6560    PhysicalCellGroupConfig_t *phyCellGrpCfg = NULLP;
6561    struct CellGroupConfigRrc__rlc_BearerToAddModList *rlcBearerList = NULLP;
6562    struct RLC_Config *rlcConfig = NULLP;
6563    struct LogicalChannelConfig *macLcConfig = NULLP;
6564    struct SchedulingRequestConfig *schedulingRequestConfig = NULLP;
6565    struct SchedulingRequestConfig__schedulingRequestToAddModList *schReqList = NULLP;
6566    struct TAG_Config *tagConfig = NULLP;
6567    struct TAG_Config__tag_ToAddModList *tagList = NULLP;
6568    struct MAC_CellGroupConfig__phr_Config *phrConfig = NULLP;
6569    struct ServingCellConfig__pdsch_ServingCellConfig *pdschCfg = NULLP;
6570    CellGroupConfigRrc_t *cellGrpCfg = ueCfg->cellGrpCfg;
6571
6572    if(ueCfg->ueNrCapability)
6573    {
6574       freeAperDecodeUeNrCapability(ueCfg->ueNrCapability);
6575       DU_FREE(ueCfg->ueNrCapability, sizeof(UE_NR_Capability_t));
6576       ueCfg->ueNrCapability = NULLP;
6577    }
6578
6579    if(ueCfg->cellGrpCfg)
6580    {
6581
6582       rlcBearerList = cellGrpCfg->rlc_BearerToAddModList;
6583       if(rlcBearerList)
6584       {
6585          if(rlcBearerList->list.array)
6586          {
6587             for(arrIdx=0; arrIdx<rlcBearerList->list.count; arrIdx++)
6588             {
6589                if(rlcBearerList->list.array[arrIdx])
6590                {
6591                   rlcConfig   = rlcBearerList->list.array[arrIdx]->rlc_Config;
6592                   macLcConfig = rlcBearerList->list.array[arrIdx]->mac_LogicalChannelConfig;
6593
6594                   if(rlcBearerList->list.array[arrIdx]->servedRadioBearer)
6595                   {
6596                      free(rlcBearerList->list.array[arrIdx]->servedRadioBearer);
6597                   }
6598                   if(rlcConfig)
6599                   {
6600                      if(rlcConfig->choice.am)
6601                      {
6602                         free(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength);
6603                         free(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength);
6604                         free(rlcConfig->choice.am);
6605                      }
6606                      free(rlcBearerList->list.array[arrIdx]->rlc_Config);
6607                   }
6608                   if(macLcConfig)
6609                   {
6610                      if(macLcConfig->ul_SpecificParameters)
6611                      {
6612                         free(macLcConfig->ul_SpecificParameters->schedulingRequestID);
6613                         free(macLcConfig->ul_SpecificParameters->logicalChannelGroup);
6614                         free(macLcConfig->ul_SpecificParameters);
6615                      }
6616                      free(rlcBearerList->list.array[arrIdx]->mac_LogicalChannelConfig);
6617                   }
6618                   free(rlcBearerList->list.array[arrIdx]);
6619                }
6620             }
6621             free(rlcBearerList->list.array);
6622          }
6623          free(cellGrpCfg->rlc_BearerToAddModList);
6624       }
6625
6626       macCellGrpCfg = cellGrpCfg->mac_CellGroupConfig;
6627       if(macCellGrpCfg)
6628       {
6629          schedulingRequestConfig = macCellGrpCfg->schedulingRequestConfig;
6630          if(schedulingRequestConfig)
6631          {
6632             schReqList = schedulingRequestConfig->schedulingRequestToAddModList;
6633             if(schReqList)
6634             {
6635                if(schReqList->list.array)
6636                {
6637                   for(arrIdx=0;arrIdx<schReqList->list.count; arrIdx++)
6638                   {
6639                      if(schReqList->list.array[arrIdx])
6640                      {
6641                         free(schReqList->list.array[arrIdx]->sr_ProhibitTimer);
6642                         free(schReqList->list.array[arrIdx]);
6643                      }
6644                   }
6645                   free(schReqList->list.array);
6646                }
6647                free(schedulingRequestConfig->schedulingRequestToAddModList);
6648             }
6649             free(macCellGrpCfg->schedulingRequestConfig);
6650          }
6651          if(macCellGrpCfg->bsr_Config)
6652          {
6653             free(macCellGrpCfg->bsr_Config);
6654          }
6655          tagConfig = macCellGrpCfg->tag_Config;
6656          if(tagConfig)
6657          {
6658             tagList = tagConfig->tag_ToAddModList;
6659             if(tagList)
6660             {
6661                if(tagList->list.array)
6662                {
6663                   for(arrIdx=0; arrIdx<tagList->list.count; arrIdx++)
6664                   {
6665                      free(tagList->list.array[arrIdx]);
6666                   }
6667                   free(tagList->list.array);
6668                }
6669                free(tagConfig->tag_ToAddModList);
6670             }
6671             free(tagConfig);
6672          }
6673
6674          phrConfig = macCellGrpCfg->phr_Config;
6675          if(phrConfig)
6676          {
6677             free(phrConfig->choice.setup);
6678             free(phrConfig);
6679          }
6680
6681          free(macCellGrpCfg);
6682       }
6683
6684       phyCellGrpCfg = cellGrpCfg->physicalCellGroupConfig;
6685       if(phyCellGrpCfg)
6686       {
6687          free(phyCellGrpCfg->p_NR_FR1);
6688          free(phyCellGrpCfg);
6689       }
6690
6691       spCellCfg = cellGrpCfg->spCellConfig;
6692       if(spCellCfg)
6693       {
6694          if(spCellCfg->servCellIndex)
6695          {
6696             if(spCellCfg->rlmInSyncOutOfSyncThreshold)
6697             {
6698                if(spCellCfg->spCellConfigDedicated)
6699                {
6700                   srvCellCfg = spCellCfg->spCellConfigDedicated;
6701                   if(srvCellCfg->initialDownlinkBWP)
6702                   {
6703                      dlBwp = srvCellCfg->initialDownlinkBWP;
6704                      if(srvCellCfg->firstActiveDownlinkBWP_Id)
6705                      {
6706                         if(srvCellCfg->defaultDownlinkBWP_Id)
6707                         {
6708                            if(srvCellCfg->uplinkConfig)
6709                            {
6710
6711                               if(srvCellCfg->pdsch_ServingCellConfig)
6712                               {
6713                                  pdschCfg=
6714                                     srvCellCfg->pdsch_ServingCellConfig;
6715                                  if(pdschCfg->choice.setup)
6716                                  {
6717
6718                                     free(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH);
6719                                     free(pdschCfg->choice.setup);
6720                                  }
6721
6722                                  free(srvCellCfg->pdsch_ServingCellConfig);
6723                               }
6724
6725                               freeAperDecodeinitialUplinkBWPConfig(srvCellCfg->uplinkConfig);
6726                               free(srvCellCfg->uplinkConfig);
6727                            }
6728                            free(srvCellCfg->defaultDownlinkBWP_Id);
6729                         }
6730
6731                         free(srvCellCfg->firstActiveDownlinkBWP_Id);
6732                      }
6733                      if(dlBwp->pdcch_Config)
6734                      {
6735                         if(dlBwp->pdsch_Config)
6736                         {
6737                            freeAperDecodeBWPDlDedPdschConfig(dlBwp);
6738                            free(dlBwp->pdsch_Config);
6739                         }
6740                         freeAperDecodeBWPDlDedPdcchConfig(dlBwp);
6741                         free(dlBwp->pdcch_Config);
6742                      }
6743                      free(srvCellCfg->initialDownlinkBWP);
6744                   }
6745
6746                   free(spCellCfg->spCellConfigDedicated);
6747                }
6748                free(spCellCfg->rlmInSyncOutOfSyncThreshold);
6749             }
6750             free(spCellCfg->servCellIndex);
6751          }
6752          free(spCellCfg);
6753       }
6754       DU_FREE(ueCfg->cellGrpCfg, sizeof(CellGroupConfigRrc_t));
6755       ueCfg->cellGrpCfg = NULLP;
6756    }
6757    if(ueCfg->ambrCfg)
6758    {
6759       memset(ueCfg->ambrCfg, 0, sizeof(AmbrCfg));
6760       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, ueCfg->ambrCfg, sizeof(AmbrCfg));
6761    }
6762    for(lcIdx = 0; lcIdx < ueCfg->numRlcLcs; lcIdx++)
6763    {
6764       freeRlcLcCfg(&ueCfg->rlcLcCfg[lcIdx]);
6765    }
6766    for(lcIdx = 0; lcIdx < ueCfg->numMacLcs; lcIdx++)
6767    {
6768       freeMacLcCfg(&ueCfg->macLcCfg[lcIdx]);
6769    }
6770    for(lcIdx = 0; lcIdx < ueCfg->numDrb; lcIdx++)
6771    {
6772       DU_FREE(ueCfg->upTnlInfo[lcIdx].tnlCfg1, sizeof(GtpTnlCfg));
6773       memset(&ueCfg->upTnlInfo[lcIdx], 0, sizeof(UpTnlCfg));
6774    }
6775 }
6776
6777 /*******************************************************************
6778  *
6779  * @brief Function to free UecontextSetupDb
6780  *
6781  * @details
6782  *
6783  *    Function : freeF1UeDb
6784  *
6785  *    Functionality: Function to free UecontextSetupDb
6786  *
6787  * @params[in] UecontextSetupDb *
6788  * @return void
6789  *
6790  * ****************************************************************/
6791
6792 void freeF1UeDb(F1UeContextSetupDb *f1UeDb)
6793 {
6794
6795    if(f1UeDb->dlRrcMsg)
6796    {
6797       if(f1UeDb->dlRrcMsg->rrcMsgPdu)
6798       {
6799          DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL,\
6800             f1UeDb->dlRrcMsg->rrcMsgPdu, f1UeDb->dlRrcMsg->rrcMsgSize);
6801       }
6802       memset(f1UeDb->dlRrcMsg, 0, sizeof(F1DlRrcMsg));
6803    }
6804    freeDuUeCfg(&f1UeDb->duUeCfg);
6805    memset(f1UeDb, 0, sizeof(F1UeContextSetupDb));
6806    DU_FREE(f1UeDb, sizeof(F1UeContextSetupDb));
6807 }
6808
6809 /*******************************************************************
6810  *
6811  * @brief Function to build Am cfg Info
6812  *
6813  * @details
6814  *
6815  *    Function : extractRlcAmCfg
6816  *
6817  *    Functionality: Function to build Am cfg Info
6818  *
6819  * @params[in] AmBearerCfg *
6820  *             void *
6821  *
6822  * @return ROK/RFAILED
6823  *
6824  * ****************************************************************/
6825
6826 void extractRlcAmCfg(AmBearerCfg *amCfgToSet, struct RLC_Config__am *rlcAmCfg)
6827 {
6828    if(rlcAmCfg)
6829    {
6830       /* UL AM */
6831       if(rlcAmCfg->dl_AM_RLC.sn_FieldLength)
6832       {
6833          amCfgToSet->ulAmCfg.snLenUl = *(rlcAmCfg->dl_AM_RLC.sn_FieldLength);
6834          /*TODO: Check the timer value when sent by real CU */
6835          amCfgToSet->ulAmCfg.reAssemTmr = rlcAmCfg->dl_AM_RLC.t_Reassembly;
6836          amCfgToSet->ulAmCfg.statProhTmr = rlcAmCfg->dl_AM_RLC.t_StatusProhibit;
6837       }
6838
6839       /* DL AM */
6840       if(rlcAmCfg->ul_AM_RLC.sn_FieldLength)
6841       {
6842          amCfgToSet->dlAmCfg.snLenDl = *(rlcAmCfg->ul_AM_RLC.sn_FieldLength);
6843          amCfgToSet->dlAmCfg.pollRetxTmr = rlcAmCfg->ul_AM_RLC.t_PollRetransmit;
6844          amCfgToSet->dlAmCfg.pollPdu   = rlcAmCfg->ul_AM_RLC.pollPDU;
6845          amCfgToSet->dlAmCfg.pollByte  = rlcAmCfg->ul_AM_RLC.pollByte;
6846          amCfgToSet->dlAmCfg.maxRetxTh = rlcAmCfg->ul_AM_RLC.maxRetxThreshold;
6847       }
6848    }
6849 }
6850
6851 /*******************************************************************
6852  *
6853  * @brief Function to build Um Bi Info
6854  *
6855  * @details
6856  *
6857  *    Function : extractRlcUmBiCfg
6858  *
6859  *    Functionality: Function to build Um Bi Info
6860  *
6861  * @params[in] UmBiDirBearerCfg *
6862  *             void *
6863  *
6864  * @return ROK/RFAILED
6865  *
6866  * ****************************************************************/
6867
6868 void extractRlcUmBiCfg(UmBiDirBearerCfg *umBiCfgToSet, struct RLC_Config__um_Bi_Directional *rlcBiCfg)
6869 {
6870    if(rlcBiCfg)
6871    {
6872       /* UL UM BI DIR Cfg */
6873       if(rlcBiCfg->dl_UM_RLC.sn_FieldLength)
6874       {
6875          umBiCfgToSet->ulUmCfg.snLenUlUm  = *(rlcBiCfg->dl_UM_RLC.sn_FieldLength);
6876          umBiCfgToSet->ulUmCfg.reAssemTmr = rlcBiCfg->dl_UM_RLC.t_Reassembly;
6877       }
6878
6879       /* DL UM BI DIR Cfg */
6880       if(rlcBiCfg->ul_UM_RLC.sn_FieldLength)
6881          umBiCfgToSet->dlUmCfg.snLenDlUm  = *(rlcBiCfg->ul_UM_RLC.sn_FieldLength);
6882    }
6883 }
6884
6885 /*******************************************************************
6886  *
6887  * @brief Function to build Um Ul Info
6888  *
6889  * @details
6890  *
6891  *    Function : extractRlcUmUlCfg
6892  *
6893  *    Functionality: Function to build Um Ul Info
6894  *
6895  * @params[in] UmUniDirUlBearerCfg *
6896  *             void *
6897  *
6898  * @return ROK/RFAILED
6899  *
6900  * ****************************************************************/
6901
6902 void extractRlcUmUlCfg(UmUniDirUlBearerCfg *umUlCfgToSet, struct RLC_Config__um_Uni_Directional_DL *umUlCfg)
6903 {
6904    if(umUlCfg)
6905    {
6906       if(umUlCfg->dl_UM_RLC.sn_FieldLength)
6907       {
6908          umUlCfgToSet->ulUmCfg.snLenUlUm  = *(umUlCfg->dl_UM_RLC.sn_FieldLength);
6909          umUlCfgToSet->ulUmCfg.reAssemTmr = umUlCfg->dl_UM_RLC.t_Reassembly;
6910       }
6911    }
6912 }
6913
6914 /*******************************************************************
6915  *
6916  * @brief Function to build Um Uni Dl Info
6917  *
6918  * @details
6919  *
6920  *    Function : extractRlcUmDlCfg
6921  *
6922  *    Functionality: Function to build Um Uni Dl Info
6923  *
6924  * @params[in] UmUniDirDlBearerCfg *
6925  *             void *
6926  *
6927  * @return ROK/RFAILED
6928  *
6929  * ****************************************************************/
6930 void extractRlcUmDlCfg(UmUniDirDlBearerCfg *umDlCfgToSet, struct RLC_Config__um_Uni_Directional_UL *umDlCfg)
6931 {
6932    if(umDlCfg)
6933    {
6934       if(umDlCfg->ul_UM_RLC.sn_FieldLength)
6935          umDlCfgToSet->dlUmCfg.snLenDlUm  = *(umDlCfg->ul_UM_RLC.sn_FieldLength);
6936    }
6937 }
6938
6939 /*******************************************************************
6940  *
6941  * @brief Function to extractRlcModeCfg
6942  *
6943  * @details
6944  *
6945  *    Function : extractRlcModeCfg
6946  *
6947  *    Functionality: Function to extractRlcModeCfg
6948  *
6949  * @params[in] RLC_Config_t *
6950  *             RlcBearerCfg *
6951  *             void  *
6952  * @return ROK/RFAILED
6953  *
6954  * ****************************************************************/
6955 void extractRlcModeCfg(uint8_t rlcMode, RlcBearerCfg *rlcDbCfg, RLC_Config_t *lcCfg)
6956 {
6957    if(lcCfg)
6958    {
6959       switch(rlcMode)
6960       {
6961          case RLC_AM :
6962             {
6963                if(lcCfg->choice.am)
6964                {
6965                   DU_ALLOC_SHRABL_BUF(rlcDbCfg->u.amCfg, sizeof(AmBearerCfg));
6966                   if(rlcDbCfg->u.amCfg)
6967                      extractRlcAmCfg(rlcDbCfg->u.amCfg, lcCfg->choice.am);
6968                }
6969                break;
6970             }
6971          case RLC_UM_BI_DIRECTIONAL :
6972             {
6973                if(lcCfg->choice.um_Bi_Directional)
6974                {
6975                   DU_ALLOC_SHRABL_BUF(rlcDbCfg->u.umBiDirCfg, sizeof(UmBiDirBearerCfg));
6976                   if(rlcDbCfg->u.umBiDirCfg)
6977                      extractRlcUmBiCfg(rlcDbCfg->u.umBiDirCfg, lcCfg->choice.um_Bi_Directional);
6978                }
6979                break;
6980             }
6981          case RLC_UM_UNI_DIRECTIONAL_UL :
6982             {
6983                if(lcCfg->choice.um_Uni_Directional_DL)
6984                {
6985                   DU_ALLOC_SHRABL_BUF(rlcDbCfg->u.umUniDirUlCfg, sizeof(UmUniDirUlBearerCfg));
6986                   if(rlcDbCfg->u.umUniDirUlCfg)
6987                      extractRlcUmUlCfg(rlcDbCfg->u.umUniDirUlCfg, lcCfg->choice.um_Uni_Directional_DL);
6988                }
6989                break;
6990             }
6991          case RLC_UM_UNI_DIRECTIONAL_DL :
6992             {
6993                if(lcCfg->choice.um_Uni_Directional_UL)
6994                {
6995                   DU_ALLOC_SHRABL_BUF(rlcDbCfg->u.umUniDirDlCfg, sizeof(UmUniDirDlBearerCfg));
6996                   if(rlcDbCfg->u.umUniDirDlCfg)
6997                      extractRlcUmDlCfg(rlcDbCfg->u.umUniDirDlCfg, lcCfg->choice.um_Uni_Directional_UL);
6998                }
6999                break;
7000             }
7001          default:
7002             DU_LOG("\nERROR  -->  DUAPP: Invalid rlcMode %d at extractRlcCfgToAddMod()", rlcMode);
7003             break;
7004       }
7005    }
7006 }
7007
7008 /*******************************************************************
7009  *
7010  * @brief Function to extract extractUlLcCfg
7011  *
7012  * @details
7013  *
7014  *    Function : extractUlLcCfg
7015  *
7016  *    Functionality: Function to extract extractUlLcCfg
7017  *
7018  * @params[in] UlLcCfg *f1UlLcCfg, LogicalChannelConfig_t *ulLcCfg
7019  * @return void
7020  *
7021  * ****************************************************************/
7022
7023 void extractUlLcCfg(UlLcCfg *f1UlLcCfg, LogicalChannelConfig_t *ulLcCfg)
7024 {
7025    if(ulLcCfg)
7026    {
7027       if(ulLcCfg->ul_SpecificParameters)
7028       {
7029          f1UlLcCfg->priority = \
7030             ulLcCfg->ul_SpecificParameters->priority;
7031       if(ulLcCfg->ul_SpecificParameters->logicalChannelGroup)
7032       {
7033          f1UlLcCfg->lcGroup = \
7034            *(ulLcCfg->ul_SpecificParameters->logicalChannelGroup);
7035       }
7036       if(ulLcCfg->ul_SpecificParameters->schedulingRequestID)
7037       {
7038          f1UlLcCfg->schReqId = \
7039            *(ulLcCfg->ul_SpecificParameters->schedulingRequestID);
7040       }
7041       f1UlLcCfg->pbr = \
7042          ulLcCfg->ul_SpecificParameters->prioritisedBitRate;
7043       f1UlLcCfg->bsd = \
7044          ulLcCfg->ul_SpecificParameters->bucketSizeDuration;
7045       }
7046    }
7047 }
7048
7049 /*******************************************************************
7050  *
7051  * @brief Function to procRlcLcCfg
7052  *
7053  * @details
7054  *
7055  *    Function : procRlcLcCfg
7056  *
7057  *    Functionality: Function to procRlcLcCfg
7058  *
7059  * @params[in] rbId, lcId, rbType, rlcMod
7060  *             RLC_Config_t *, RlcBearerCfg * ,
7061  * @return void
7062  *
7063  * ****************************************************************/
7064
7065 void procRlcLcCfg(uint8_t rbId, uint8_t lcId, uint8_t rbType, uint8_t rlcMode,\
7066    uint8_t configType, RLC_Config_t *f1RlcCfg, RlcBearerCfg *lcCfg)
7067 {
7068
7069    lcCfg->rbId   = rbId;
7070    lcCfg->configType = configType;
7071
7072    if(rbType == RB_TYPE_SRB)
7073    {
7074       lcCfg->rbType = RB_TYPE_SRB;
7075       lcCfg->lcId   = rbId;
7076       lcCfg->lcType = LCH_DCCH;
7077       lcCfg->rlcMode = RLC_AM;
7078    }
7079    else if(rbType == RB_TYPE_DRB)
7080    {
7081       lcCfg->rbType = RB_TYPE_DRB;
7082       lcCfg->lcId   = lcId;
7083       lcCfg->lcType = LCH_DTCH;
7084       lcCfg->rlcMode = rlcMode;
7085    }
7086    if(f1RlcCfg) /* rlc mode config recived */
7087    {
7088       extractRlcModeCfg(lcCfg->rlcMode, lcCfg, f1RlcCfg);
7089    }
7090 }
7091
7092
7093
7094 /*******************************************************************
7095  *
7096  * @brief Fills DrbQos Info received by CU
7097  *
7098  * @details
7099  *
7100  *    Function : extractQosInfo
7101  *
7102  *    Functionality: Fills DrbQos Info received  by CU
7103  *
7104  * @params[in] DrbQosInfo *qosToAdd,
7105  *             QoSFlowLevelQoSParameters_t *qosFlowCfg
7106  * @return void
7107  *
7108  * ****************************************************************/
7109
7110 void extractQosInfo(DrbQosInfo *qosToAdd, QoSFlowLevelQoSParameters_t *qosFlowCfg)
7111 {
7112    qosToAdd->fiveQiType = qosFlowCfg->qoS_Characteristics.present;
7113    qosToAdd->u.nonDyn5Qi.fiveQi     =\
7114          qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->fiveQI;
7115    if(qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow)
7116    {
7117       qosToAdd->u.nonDyn5Qi.avgWindow = \
7118         *(qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow);
7119    }
7120    qosToAdd->u.nonDyn5Qi.maxDataBurstVol = \
7121       *(qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume);
7122    if(qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->qoSPriorityLevel)
7123    {
7124       qosToAdd->u.nonDyn5Qi.priorLevel = \
7125          *(qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->qoSPriorityLevel);
7126    }
7127    qosToAdd->ngRanRetPri.priorityLevel = \
7128       qosFlowCfg->nGRANallocationRetentionPriority.priorityLevel;
7129    qosToAdd->ngRanRetPri.preEmptionCap = \
7130       qosFlowCfg->nGRANallocationRetentionPriority.pre_emptionCapability;
7131    qosToAdd->ngRanRetPri.preEmptionVul = \
7132       qosFlowCfg->nGRANallocationRetentionPriority.pre_emptionVulnerability;
7133    if(qosFlowCfg->gBR_QoS_Flow_Information)
7134    {
7135       memcpy(&qosToAdd->grbQosInfo.maxFlowBitRateDl, \
7136          qosFlowCfg->gBR_QoS_Flow_Information->maxFlowBitRateDownlink.buf, \
7137          qosFlowCfg->gBR_QoS_Flow_Information->maxFlowBitRateDownlink.size);
7138       memcpy(&qosToAdd->grbQosInfo.maxFlowBitRateUl, \
7139          qosFlowCfg->gBR_QoS_Flow_Information->maxFlowBitRateUplink.buf, \
7140          qosFlowCfg->gBR_QoS_Flow_Information->maxFlowBitRateUplink.size);
7141       memcpy(&qosToAdd->grbQosInfo.guarFlowBitRateDl,\
7142          qosFlowCfg->gBR_QoS_Flow_Information->guaranteedFlowBitRateDownlink.buf, \
7143          qosFlowCfg->gBR_QoS_Flow_Information->guaranteedFlowBitRateDownlink.size);
7144       memcpy(&qosToAdd->grbQosInfo.guarFlowBitRateUl,\
7145          qosFlowCfg->gBR_QoS_Flow_Information->guaranteedFlowBitRateUplink.buf, \
7146          qosFlowCfg->gBR_QoS_Flow_Information->guaranteedFlowBitRateUplink.size);
7147    }
7148    qosToAdd->pduSessionId = 0;
7149    qosToAdd->ulPduSessAggMaxBitRate = 0;
7150 }
7151
7152 /*******************************************************************
7153  *
7154  * @brief Function to extract GTP Tunnel Info from CU
7155  *
7156  * @details
7157  *
7158  *    Function : extractUpTnlInfo
7159  *
7160  *    Functionality: Function to extract GTP Tunnel Info from CU
7161  *
7162  * @params[in] F1AP message
7163  * @return ROK/RFAILED
7164  *
7165  * ****************************************************************/
7166
7167 uint8_t extractUpTnlInfo(uint8_t drbId, uint8_t configType,\
7168    ULUPTNLInformation_ToBeSetup_List_t *tnlInfo, UpTnlCfg *upTnlInfo)
7169 {
7170    uint8_t tnlIdx;
7171    uint32_t ipv4_du = 0;
7172    GTPTunnel_t *gtpTunnel = NULLP;
7173
7174    upTnlInfo->drbId = drbId;
7175    upTnlInfo->configType = configType;
7176 #ifdef O1_ENABLE
7177    cmInetAddr((S8*)g_cfg.DU_IPV4_Addr, &ipv4_du);
7178 #else
7179    cmInetAddr((char *)DU_IP_V4_ADDR, &ipv4_du);
7180 #endif
7181
7182    for(tnlIdx=0; tnlIdx < tnlInfo->list.count; tnlIdx++)
7183    {
7184       if(tnlInfo->list.array[tnlIdx]->uLUPTNLInformation.present == UPTransportLayerInformation_PR_gTPTunnel)
7185       {
7186          if(tnlInfo->list.array[tnlIdx]->uLUPTNLInformation.choice.gTPTunnel)
7187          {
7188             gtpTunnel = tnlInfo->list.array[tnlIdx]->uLUPTNLInformation.choice.gTPTunnel;
7189             DU_ALLOC(upTnlInfo->tnlCfg1, sizeof(GtpTnlCfg));
7190             if(upTnlInfo->tnlCfg1 == NULLP)
7191             {
7192                DU_LOG("\nERROR  -->  F1AP : extractUpTnlInfo: Failed to allocate mmeory for tunnel cfg 1");
7193                return RFAILED;
7194             }
7195             bitStringToInt(&gtpTunnel->transportLayerAddress, &upTnlInfo->tnlCfg1->ulTnlAddress);
7196             upTnlInfo->tnlCfg1->dlTnlAddress = ipv4_du;
7197             if(gtpTunnel->gTP_TEID.size > 0)
7198             {
7199                teIdStringToInt(gtpTunnel->gTP_TEID.buf, &upTnlInfo->tnlCfg1->teId);
7200             }
7201          }
7202          break;
7203       }
7204    }
7205    return ROK;
7206 }
7207 /*******************************************************************
7208 *
7209 * @brief Function to extract Drb Qos Cfg Info from CU
7210 *
7211 * @details
7212 *
7213 *    Function : extractDrbQosCfg
7214 *
7215 *    Functionality: Function to extract Drb Qos Cfg Info from CU
7216 *
7217 * @params[in] DRB_Information_t *drbInfo, LcCfg *macLcToAdd
7218 * @return ROK/RFAILED
7219 *
7220 * ****************************************************************/
7221
7222 uint8_t extractDrbQosCfg(DRB_Information_t *drbInfo, LcCfg *macLcToAdd )
7223 {
7224    if(!macLcToAdd->drbQos)
7225    {
7226       DU_ALLOC_SHRABL_BUF(macLcToAdd->drbQos, sizeof(DrbQosInfo));
7227       if(macLcToAdd->drbQos == NULLP)
7228       {
7229          DU_LOG("\nERROR  -->  DUAPP:Memory failed at allocating DrbQos at extractDrbCfg()");
7230          return RFAILED;
7231       }
7232
7233    }
7234    if(drbInfo->dRB_QoS.qoS_Characteristics.present == QoS_Characteristics_PR_non_Dynamic_5QI)
7235    {
7236       extractQosInfo(macLcToAdd->drbQos, &drbInfo->dRB_QoS);
7237       macLcToAdd->dlLcCfg.lcp = macLcToAdd->drbQos->ngRanRetPri.priorityLevel;
7238    }
7239    if(!macLcToAdd->snssai)
7240    {
7241       DU_ALLOC_SHRABL_BUF(macLcToAdd->snssai, sizeof(Snssai));
7242       if(macLcToAdd->snssai == NULLP)
7243       {
7244          DU_LOG("\nERROR  -->  DUAPP : Memory failed at allocating SNSSAI at extractDrbCfg()");
7245          return RFAILED;
7246       }
7247    }
7248    memcpy(&macLcToAdd->snssai->sst, drbInfo->sNSSAI.sST.buf, \
7249          drbInfo->sNSSAI.sST.size);
7250    if(drbInfo->sNSSAI.sD)
7251    {
7252       memcpy(macLcToAdd->snssai->sd, drbInfo->sNSSAI.sD->buf, \
7253             drbInfo->sNSSAI.sD->size);
7254    }
7255    return ROK;
7256 }
7257 /*******************************************************************
7258  *
7259  * @brief Function to extract DRB info received from CU
7260  *
7261  * @details
7262  *
7263  *    Function : extractDrbCfg
7264  *
7265  *    Functionality: Function to extract DRB info received from CU
7266  *
7267  * @params[in] F1AP message
7268  * @return void
7269  *
7270  * ****************************************************************/
7271 uint8_t extractDrbCfg(DRBs_ToBeSetup_Item_t *drbItem,DRBs_ToBeSetupMod_Item_t *drbSetupModItem,\
7272 LcCfg *macLcToAdd, UpTnlCfg *upTnlInfo)
7273 {
7274    DRB_Information_t *drbInfo = NULLP;
7275
7276    if(drbItem != NULLP)
7277    {
7278       if(extractUpTnlInfo(drbItem->dRBID, CONFIG_ADD, &drbItem->uLUPTNLInformation_ToBeSetup_List, upTnlInfo) != ROK)
7279       {
7280          DU_LOG("\nERROR  -->  DUAPP : Failed to extract tunnel Cfg at extractDrbCfg()");
7281          return RFAILED;
7282       }
7283       if(drbItem->qoSInformation.present == QoSInformation_PR_choice_extension)
7284       {
7285          if(drbItem->qoSInformation.choice.choice_extension->value.present == QoSInformation_ExtIEs__value_PR_DRB_Information)
7286          {
7287             drbInfo = &drbItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information;
7288             if(extractDrbQosCfg(drbInfo , macLcToAdd) != ROK)
7289             {
7290                DU_LOG("\nERROR  -->  DUAPP : Failed to extract qos Cfg at extractDrbCfg()");
7291                return RFAILED;
7292             }
7293          }
7294       }
7295    }
7296    else if(drbSetupModItem != NULLP)
7297    {
7298       if(extractUpTnlInfo(drbSetupModItem->dRBID, CONFIG_ADD, &drbSetupModItem->uLUPTNLInformation_ToBeSetup_List,\
7299       upTnlInfo) != ROK)
7300       {
7301          DU_LOG("\nERROR  -->  DUAPP : Failed to extract tunnel Cfg at extractDrbCfg()");
7302          return RFAILED;
7303       }
7304       if(drbSetupModItem->qoSInformation.present == QoSInformation_PR_choice_extension)
7305       {
7306          if(drbSetupModItem->qoSInformation.choice.choice_extension->value.present ==\
7307          QoSInformation_ExtIEs__value_PR_DRB_Information)
7308          {
7309             drbInfo = &drbSetupModItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information;
7310             if(extractDrbQosCfg(drbInfo , macLcToAdd) != ROK)
7311             {
7312                DU_LOG("\nERROR  -->  DUAPP : Failed to extract qos Cfg at extractDrbCfg()");
7313                return RFAILED;
7314             }
7315
7316          }
7317       }
7318    }
7319
7320    return ROK;
7321 }
7322
7323 /*******************************************************************
7324  *
7325  * @brief Function to extract RB info received from CU
7326  *
7327  * @details
7328  *
7329  *    Function : extractMacRbCfg
7330  *
7331  *    Functionality: Function to extract RB info received from CU
7332  *
7333  * @params[in] F1AP message
7334  * @return ROK/RFAILED
7335  *
7336  * ****************************************************************/
7337
7338 uint8_t extractMacRbCfg(uint8_t lcId, DRBs_ToBeSetup_Item_t *drbCfg,\
7339 DRBs_ToBeSetupMod_Item_t *drbSetupModCfg,  LogicalChannelConfig_t *ulLcCfg, LcCfg *lcCfg, UpTnlCfg *upTnlInfo)
7340 {
7341    if(drbCfg != NULLP)
7342    {
7343       if(extractDrbCfg(drbCfg, NULL, lcCfg, upTnlInfo) != ROK)
7344       {
7345          DU_LOG("ERROR  -->  F1AP : Failed to build Drb Qos at extractMacRbCfg()");
7346          return RFAILED;
7347       }
7348    }
7349    else if(drbSetupModCfg != NULLP)
7350    {
7351       if(extractDrbCfg(NULL, drbSetupModCfg, lcCfg, upTnlInfo) != ROK)
7352       {
7353          DU_LOG("ERROR  -->  F1AP : Failed to build Drb Qos at extractMacRbCfg()");
7354          return RFAILED;
7355       }
7356    }
7357    else
7358    {
7359       lcCfg->drbQos = NULLP;
7360       lcCfg->snssai = NULLP;
7361       if(lcCfg->lcId == SRB2_LCID)
7362          lcCfg->dlLcCfg.lcp = LC_PRIORITY_3;
7363       else
7364          lcCfg->dlLcCfg.lcp = LC_PRIORITY_1;
7365    }
7366    if(ulLcCfg)
7367    {
7368       lcCfg->ulLcCfgPres = true;
7369       extractUlLcCfg(&lcCfg->ulLcCfg, ulLcCfg);
7370    }
7371    else
7372       lcCfg->ulLcCfgPres = false;
7373    return ROK;
7374 }
7375
7376 /*******************************************************************
7377  *
7378  * @brief Function processing LC config info received from CU
7379  *
7380  * @details
7381  *
7382  *    Function : procMacLcCfg
7383  *
7384  *    Functionality: Function processing LC config info received from CU
7385  *
7386  * @params[in] F1AP message
7387  * @return ROK/RFAILED
7388  *
7389  * ****************************************************************/
7390
7391 uint8_t procMacLcCfg(uint8_t lcId, uint8_t rbType, uint8_t configType,\
7392 DRBs_ToBeSetup_Item_t *drbItem, DRBs_ToBeSetupMod_Item_t *drbSetupModItem, LogicalChannelConfig_t *ulLcCfg,\
7393 LcCfg *lcCfg, UpTnlCfg *upTnlInfo)
7394 {
7395    uint8_t ret = ROK;
7396
7397    lcCfg->lcId = lcId;
7398    lcCfg->configType = configType;
7399    if(rbType == RB_TYPE_SRB)
7400    {
7401       ret = extractMacRbCfg(lcId, NULL,NULL, ulLcCfg, lcCfg, NULL);
7402    }
7403    else if(rbType == RB_TYPE_DRB)
7404    {
7405       if(drbItem != NULL)
7406         ret = extractMacRbCfg(lcId, drbItem, NULL, ulLcCfg, lcCfg, upTnlInfo);
7407       else if(drbSetupModItem != NULL)
7408         ret = extractMacRbCfg(lcId, NULL, drbSetupModItem, ulLcCfg, lcCfg, upTnlInfo);
7409    }
7410    return ret;
7411 }
7412
7413 /*******************************************************************
7414  *
7415  * @brief Function to extract Rlc cfg To Add/Mod in CellGrp Info
7416  *
7417  * @details
7418  *
7419  *    Function : extractRlcCfgToAddMod
7420  *
7421  *    Functionality: Function to extract Rlc cfg To Add/Mod in CellGrp Info
7422  *
7423  * @params[in] CellGroupConfigRrc__rlc_BearerTo pointer
7424  *             DuUeCfg Pointer
7425  * @return ROK/RFAILED
7426  *
7427  * ****************************************************************/
7428
7429 uint8_t extractRlcCfgToAddMod(struct CellGroupConfigRrc__rlc_BearerToAddModList *lcCfg, DuUeCfg *ueCfgDb)
7430 {
7431   uint8_t idx, rbId, lcId, rlcMode, rbType;
7432   RLC_Config_t *f1RlcCfg = NULLP;
7433   LogicalChannelConfig_t *macUlLcCfg = NULLP;
7434
7435   for(idx = 0; idx < lcCfg->list.count; idx++)
7436   {
7437      lcId = lcCfg->list.array[idx]->logicalChannelIdentity;
7438      if(lcCfg->list.array[idx]->servedRadioBearer)
7439      {
7440         /* RadioBearer for SRB/DRB */
7441         if(lcCfg->list.array[idx]->servedRadioBearer->present ==\
7442         RLC_BearerConfig__servedRadioBearer_PR_srb_Identity)
7443         {
7444            rbId = lcCfg->list.array[idx]->servedRadioBearer->choice.srb_Identity;
7445            rbType = RB_TYPE_SRB;
7446         }
7447         else if(lcCfg->list.array[idx]->servedRadioBearer->present ==\
7448         RLC_BearerConfig__servedRadioBearer_PR_drb_Identity)
7449         {
7450            rbId = lcCfg->list.array[idx]->servedRadioBearer->choice.drb_Identity;
7451            rbType = RB_TYPE_DRB;
7452         }
7453         else
7454         {
7455            DU_LOG("\nERROR  -->  No components present in Bearer config to ADD/MOD");
7456            return RFAILED;
7457         }
7458         /* MAC UL LC Config */
7459         if(lcCfg->list.array[idx]->mac_LogicalChannelConfig)
7460         {
7461            macUlLcCfg = lcCfg->list.array[idx]->mac_LogicalChannelConfig;
7462         }
7463      }
7464      else
7465      {
7466         DU_LOG("\nERROR  -->  DUAPP: Received RadioBearer config is NULL");
7467         return RFAILED;
7468      }
7469      /* RLC Mode Config */
7470      if(lcCfg->list.array[idx]->rlc_Config)
7471      {
7472         rlcMode  = lcCfg->list.array[idx]->rlc_Config->present;
7473         f1RlcCfg = lcCfg->list.array[idx]->rlc_Config;
7474      }
7475
7476      /* Filling RLC/MAC Config*/
7477      memset(&ueCfgDb->macLcCfg[idx], 0, sizeof(LcCfg));
7478      memset(&ueCfgDb->rlcLcCfg[idx], 0, sizeof(RlcBearerCfg));
7479      procRlcLcCfg(rbId, lcId, rbType, rlcMode, CONFIG_UNKNOWN, f1RlcCfg, &(ueCfgDb->rlcLcCfg[idx]));
7480      if(procMacLcCfg(lcId, rbType, CONFIG_UNKNOWN, NULL, NULL, macUlLcCfg, &ueCfgDb->macLcCfg[idx], NULL) != ROK)
7481      {
7482         DU_LOG("\nERROR  -->  DU APP : Failed while filling MAC LC config at extractRlcCfgToAddMod()");
7483         return RFAILED;
7484      }
7485      (ueCfgDb->numRlcLcs)++;
7486      (ueCfgDb->numMacLcs)++;
7487   }
7488   //TODO: To send the failure cause in UeContextSetupRsp
7489   return ROK;
7490 }
7491
7492 /*******************************************************************
7493  *
7494  * @brief DeAlloc pdsch serv cell config info
7495  *
7496  * @details
7497  *
7498  *    Function : freeMacPdschServCellInfo
7499  *
7500  *    Functionality: DeAlloc pdsch serv cell config info
7501  *
7502  * @params[in] PdschServCellCfg pointer
7503  * @return void
7504  *
7505  * ****************************************************************/
7506
7507 void freeMacPdschServCellInfo(PdschServCellCfg *pdsch)
7508 {
7509    if(pdsch->xOverhead)
7510    {
7511       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, pdsch->xOverhead, sizeof(uint8_t));
7512    }
7513    if(pdsch->codeBlkGrpFlushInd)
7514    {
7515       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, pdsch->codeBlkGrpFlushInd, sizeof(bool));
7516    }
7517    if(pdsch->maxCodeBlkGrpPerTb)
7518    {
7519       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, pdsch->maxCodeBlkGrpPerTb, sizeof(uint8_t));
7520    }
7521    if(pdsch->maxMimoLayers)
7522    {
7523       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, pdsch->maxMimoLayers, sizeof(uint8_t));
7524    }
7525 }
7526
7527 /*******************************************************************
7528  *
7529  * @brief Free Serving cell Info
7530  *
7531  * @details
7532  *
7533  *    Function : freeMacServingCellInfo
7534  *
7535  *    Functionality: Free Serving cell Info
7536  *
7537  * @params[in] ServCellCfgInfo *srvCellCfg
7538  * @return void
7539  *
7540  * ****************************************************************/
7541 void freeMacServingCellInfo(ServCellCfgInfo *srvCellCfg)
7542 {
7543    freeMacPdschServCellInfo(&srvCellCfg->pdschServCellCfg);
7544    if(srvCellCfg->bwpInactivityTmr)
7545    {
7546       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, srvCellCfg->bwpInactivityTmr, sizeof(uint8_t));
7547    }
7548 }
7549
7550 /*******************************************************************
7551  *
7552  * @brief Free cell Grp Cfg Info
7553  *
7554  * @details
7555  *
7556  *    Function : freeUeReCfgCellGrpInfo
7557  *
7558  *    Functionality: Free cell Grp Cfg Info
7559  *
7560  * @params[in] MacUeCfg*  duUeCfg
7561  * @return void
7562  *
7563  * ****************************************************************/
7564
7565 void freeUeReCfgCellGrpInfo(MacUeCfg *macUeCfg)
7566 {
7567    freeMacServingCellInfo(&macUeCfg->spCellCfg.servCellCfg);
7568 }
7569
7570 /*******************************************************************
7571  *
7572  * @brief Fills Reconfig SchReqReConfig
7573  *
7574  * @details
7575  *
7576  *    Function : extractSchReqReConfig
7577  *
7578  *    Functionality: Fills Reconfig SchReqReConfig
7579  *
7580  * @params[in] SchedulingRequestConfig_t *cuSchedReq
7581  *             SchedReqCfg*  macSchedReq
7582  * @return void
7583  *
7584  * ****************************************************************/
7585 void extractSchReqReConfig(SchedulingRequestConfig_t *cuSchedReq, SchedReqCfg *macSchedReq)
7586 {
7587    uint8_t schReqIdx = 0;
7588    struct SchedulingRequestConfig__schedulingRequestToAddModList *schReqListToAdd = NULLP;
7589    struct SchedulingRequestConfig__schedulingRequestToReleaseList *schReqListToRel = NULLP;
7590
7591    if(cuSchedReq->schedulingRequestToAddModList)
7592    {
7593       schReqListToAdd = cuSchedReq->schedulingRequestToAddModList;
7594       if(schReqListToAdd->list.count)
7595       {
7596          macSchedReq->addModListCount = schReqListToAdd->list.count;
7597          for(schReqIdx = 0; schReqIdx < schReqListToAdd->list.count; schReqIdx++)
7598          {
7599             macSchedReq->addModList[schReqIdx].schedReqId = \
7600                schReqListToAdd->list.array[schReqIdx]->schedulingRequestId;
7601             macSchedReq->addModList[schReqIdx].srProhibitTmr = \
7602                *(schReqListToAdd->list.array[schReqIdx]->sr_ProhibitTimer);
7603             macSchedReq->addModList[schReqIdx].srTransMax    =\
7604                schReqListToAdd->list.array[schReqIdx]->sr_TransMax;
7605          }
7606       }
7607    }
7608    /* Scheduling Req To release */
7609    if(cuSchedReq->schedulingRequestToReleaseList)
7610    {
7611       schReqListToRel = cuSchedReq->schedulingRequestToReleaseList;
7612       if(schReqListToRel->list.count)
7613       {
7614          macSchedReq->relListCount = schReqListToRel->list.count;
7615          for(schReqIdx = 0; schReqIdx < schReqListToRel->list.count; schReqIdx++)
7616          {
7617             macSchedReq->relList[schReqIdx] = \
7618                *schReqListToRel->list.array[schReqIdx];
7619          }
7620       }
7621    }
7622 }
7623
7624 /*******************************************************************
7625  *
7626  * @brief Fills TagReconfig
7627  *
7628  * @details
7629  *
7630  *    Function : extractTagReconfig
7631  *
7632  *    Functionality: Fills extractTagReconfig
7633  *
7634  * @params[in] TAG_Config_t *cuTagCfg
7635  *             TagCfg *macTagCfg
7636  * @return void
7637  *
7638  * ****************************************************************/
7639
7640 void extractTagReconfig(TAG_Config_t *cuTagCfg, TagCfg *macTagCfg)
7641 {
7642   uint8_t tagIdx = 0;
7643   struct TAG_Config__tag_ToAddModList  *tagListToAddMod = NULLP;
7644   struct TAG_Config__tag_ToReleaseList *tagListToRel = NULLP;
7645
7646   /* Tag config to AddMod */
7647   if(cuTagCfg->tag_ToAddModList)
7648   {
7649      tagListToAddMod = cuTagCfg->tag_ToAddModList;
7650      if(tagListToAddMod->list.count)
7651      {
7652         macTagCfg->addModListCount = tagListToAddMod->list.count;
7653         for(tagIdx = 0; tagIdx < tagListToAddMod->list.count; tagIdx++)
7654         {
7655            macTagCfg->addModList[tagIdx].tagId =\
7656               tagListToAddMod->list.array[tagIdx]->tag_Id;
7657            macTagCfg->addModList[tagIdx].timeAlignTimer = \
7658
7659               tagListToAddMod->list.array[tagIdx]->timeAlignmentTimer;
7660         }
7661      }
7662   }
7663   /* Tag config to release */
7664   if(cuTagCfg->tag_ToReleaseList)
7665   {
7666      tagListToRel = cuTagCfg->tag_ToReleaseList;
7667      if(tagListToRel->list.count)
7668      {
7669         macTagCfg->relListCount = tagListToRel->list.count;
7670         for(tagIdx = 0; tagIdx < tagListToRel->list.count; tagIdx++)
7671         {
7672            macTagCfg->relList[tagIdx] = *tagListToRel->list.array[tagIdx];
7673         }
7674      }
7675   }
7676 }
7677
7678 /*******************************************************************
7679  *
7680  * @brief Fills PdcchCfg received by CU
7681  *
7682  * @details
7683  *
7684  *    Function : extractPdcchCfg
7685  *
7686  *    Functionality: Fills PdcchCfg received  by CU
7687  *
7688  * @params[in] PDCCH_Config_t *cuPdcchCfg,
7689  *             PdcchConfig *duPdcchCfg
7690  * @return void
7691  *
7692  * ****************************************************************/
7693
7694 void extractPdcchCfg(PDCCH_Config_t *cuPdcchCfg, PdcchConfig *macPdcchCfg)
7695 {
7696    uint8_t cRsetIdx = 0;
7697    uint8_t srchSpcIdx = 0;
7698
7699    struct PDCCH_Config__controlResourceSetToAddModList *cRsetToAddModList = NULLP;
7700    struct PDCCH_Config__controlResourceSetToReleaseList *cRsetToRelList = NULLP;
7701    struct PDCCH_Config__searchSpacesToAddModList *srchSpcToAddModList = NULLP;
7702    struct PDCCH_Config__searchSpacesToReleaseList *srchSpcToRelList = NULLP;
7703
7704
7705    /* Control Resource Set To Add/Mod List */
7706    if(cuPdcchCfg->controlResourceSetToAddModList)
7707    {
7708       cRsetToAddModList = cuPdcchCfg->controlResourceSetToAddModList;
7709       if(cRsetToAddModList->list.count)
7710       {
7711          macPdcchCfg->numCRsetToAddMod = cRsetToAddModList->list.count;
7712          for(cRsetIdx = 0; cRsetIdx < cRsetToAddModList->list.count; cRsetIdx++)
7713          {
7714             macPdcchCfg->cRSetToAddModList[cRsetIdx].cRSetId = \
7715               cRsetToAddModList->list.array[cRsetIdx]->controlResourceSetId;
7716             bitStringToInt(&cRsetToAddModList->list.array[cRsetIdx]->frequencyDomainResources,\
7717                macPdcchCfg->cRSetToAddModList[cRsetIdx].freqDomainRsrc);
7718             macPdcchCfg->cRSetToAddModList[cRsetIdx].duration = \
7719               cRsetToAddModList->list.array[cRsetIdx]->duration;
7720
7721             macPdcchCfg->cRSetToAddModList[cRsetIdx].cceRegMappingType = \
7722               cRsetToAddModList->list.array[cRsetIdx]->cce_REG_MappingType.present;
7723             if(macPdcchCfg->cRSetToAddModList[cRsetIdx].cceRegMappingType == CCE_REG_MAPPINGTYPE_PR_INTERLEAVED)
7724             {
7725                //TODO: handle the case for Interleaved
7726             }
7727             macPdcchCfg->cRSetToAddModList[cRsetIdx].precoderGranularity = \
7728               cRsetToAddModList->list.array[cRsetIdx]->precoderGranularity;
7729             if(cRsetToAddModList->list.array[cRsetIdx]->pdcch_DMRS_ScramblingID)
7730             {
7731                macPdcchCfg->cRSetToAddModList[cRsetIdx].dmrsScramblingId= \
7732                   *(cRsetToAddModList->list.array[cRsetIdx]->pdcch_DMRS_ScramblingID);
7733             }
7734          }
7735       }
7736
7737    }
7738    /* Control Resource Set To Release List */
7739    if(cuPdcchCfg->controlResourceSetToReleaseList)
7740    {
7741       cRsetToRelList = cuPdcchCfg->controlResourceSetToReleaseList;
7742       if(cRsetToRelList->list.count)
7743       {
7744          macPdcchCfg->numCRsetToRel = cRsetToRelList->list.count;
7745          for(cRsetIdx = 0; cRsetIdx < cRsetToRelList->list.count; cRsetIdx++)
7746          {
7747             macPdcchCfg->cRSetToRelList[cRsetIdx] = *(cRsetToRelList->list.array[cRsetIdx]);
7748          }
7749       }
7750    }
7751
7752    /* Search space To Add/Mod List */
7753    if(cuPdcchCfg->searchSpacesToAddModList)
7754    {
7755       srchSpcToAddModList = cuPdcchCfg->searchSpacesToAddModList;
7756       if(srchSpcToAddModList->list.count)
7757       {
7758          macPdcchCfg->numSearchSpcToAddMod = srchSpcToAddModList->list.count;
7759          for(srchSpcIdx = 0; srchSpcIdx < srchSpcToAddModList->list.count; srchSpcIdx++)
7760          {
7761             macPdcchCfg->searchSpcToAddModList[srchSpcIdx].searchSpaceId =\
7762                srchSpcToAddModList->list.array[srchSpcIdx]->searchSpaceId;
7763             macPdcchCfg->searchSpcToAddModList[srchSpcIdx].cRSetId =\
7764                *(srchSpcToAddModList->list.array[srchSpcIdx]->controlResourceSetId);
7765             if(srchSpcToAddModList->list.array[srchSpcIdx]->monitoringSlotPeriodicityAndOffset)
7766             {
7767                macPdcchCfg->searchSpcToAddModList[srchSpcIdx].mSlotPeriodicityAndOffset =\
7768                   srchSpcToAddModList->list.array[srchSpcIdx]->monitoringSlotPeriodicityAndOffset->present;
7769             }
7770             if(srchSpcToAddModList->list.array[srchSpcIdx]->monitoringSymbolsWithinSlot)
7771             {
7772                bitStringToInt(srchSpcToAddModList->list.array[srchSpcIdx]->monitoringSymbolsWithinSlot,\
7773                   macPdcchCfg->searchSpcToAddModList[srchSpcIdx].mSymbolsWithinSlot);
7774             }
7775             if(srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates)
7776             {
7777               macPdcchCfg->searchSpcToAddModList[srchSpcIdx].numCandidatesAggLevel1 = \
7778                   srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates->aggregationLevel1;
7779               macPdcchCfg->searchSpcToAddModList[srchSpcIdx].numCandidatesAggLevel2 = \
7780                   srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates->aggregationLevel2;
7781               macPdcchCfg->searchSpcToAddModList[srchSpcIdx].numCandidatesAggLevel4 = \
7782                   srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates->aggregationLevel4;
7783
7784               macPdcchCfg->searchSpcToAddModList[srchSpcIdx].numCandidatesAggLevel8 = \
7785                   srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates->aggregationLevel8;
7786
7787               macPdcchCfg->searchSpcToAddModList[srchSpcIdx].numCandidatesAggLevel16 = \
7788                   srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates->aggregationLevel16;
7789             }
7790             if(srchSpcToAddModList->list.array[srchSpcIdx]->searchSpaceType)
7791             {
7792                macPdcchCfg->searchSpcToAddModList[srchSpcIdx].searchSpaceType =\
7793                   srchSpcToAddModList->list.array[srchSpcIdx]->searchSpaceType->present;
7794                if(macPdcchCfg->searchSpcToAddModList[srchSpcIdx].searchSpaceType == SEARCHSPACETYPE_PR_UE_SPECIFIC)
7795                {
7796                   macPdcchCfg->searchSpcToAddModList[srchSpcIdx].ueSpecificDciFormat =\
7797                      srchSpcToAddModList->list.array[srchSpcIdx]->searchSpaceType->choice.ue_Specific->dci_Formats;
7798                }
7799
7800             }
7801          }
7802       }
7803    }
7804    /* Search space To Rel List */
7805    if(cuPdcchCfg->searchSpacesToReleaseList)
7806    {
7807       srchSpcToRelList = cuPdcchCfg->searchSpacesToReleaseList;
7808       if(srchSpcToRelList->list.count)
7809       {
7810          macPdcchCfg->numSearchSpcToRel = srchSpcToRelList->list.count;
7811          for(srchSpcIdx = 0; srchSpcIdx < srchSpcToRelList->list.count; srchSpcIdx++)
7812          {
7813             macPdcchCfg->searchSpcToRelList[srchSpcIdx] =\
7814                *(srchSpcToRelList->list.array[srchSpcIdx]);
7815          }
7816       }
7817    }
7818 }
7819
7820 /*******************************************************************
7821  *
7822  * @brief Fills PdschCfg received by CU
7823  *
7824  * @details
7825  *
7826  *    Function : extractPdschCfg
7827  *
7828  *    Functionality: Fills PdschCfg received  by CU
7829  *
7830  * @params[in] PDSCH_Config_t *cuPdschCfg,
7831  *             PdschConfig *macPdschCfg
7832  * @return void
7833  *
7834  * ****************************************************************/
7835
7836 void extractPdschCfg(PDSCH_Config_t *cuPdschCfg, PdschConfig *macPdschCfg)
7837 {
7838    uint8_t timeDomIdx;
7839    struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAlloc = NULLP;
7840
7841    if(cuPdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA)
7842    {
7843       if(cuPdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA->present == \
7844          PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA_PR_setup)
7845       {
7846          if(cuPdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA->choice.setup)
7847          {
7848             macPdschCfg->dmrsDlCfgForPdschMapTypeA.addPos = \
7849                *(cuPdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA->choice.setup->dmrs_AdditionalPosition);
7850          }
7851       }
7852    }
7853    macPdschCfg->resourceAllocType = cuPdschCfg->resourceAllocation;
7854    if(cuPdschCfg->pdsch_TimeDomainAllocationList)
7855    {
7856       timeDomAlloc = cuPdschCfg->pdsch_TimeDomainAllocationList;
7857       if(timeDomAlloc->present ==\
7858          PDSCH_Config__pdsch_TimeDomainAllocationList_PR_setup)
7859       {
7860          if(timeDomAlloc->choice.setup)
7861          {
7862             macPdschCfg->numTimeDomRsrcAlloc  = timeDomAlloc->choice.setup->list.count;
7863             for(timeDomIdx = 0; timeDomIdx < timeDomAlloc->choice.setup->list.count; timeDomIdx++)
7864             {
7865                macPdschCfg->timeDomRsrcAllociList[timeDomIdx].mappingType = \
7866                   timeDomAlloc->choice.setup->list.array[timeDomIdx]->mappingType;
7867                macPdschCfg->timeDomRsrcAllociList[timeDomIdx].startSymbolAndLength = \
7868                   timeDomAlloc->choice.setup->list.array[timeDomIdx]->startSymbolAndLength;
7869             }
7870          }
7871       }
7872    }
7873    macPdschCfg->rbgSize = cuPdschCfg->rbg_Size;
7874    if(cuPdschCfg->maxNrofCodeWordsScheduledByDCI)
7875       macPdschCfg->numCodeWordsSchByDci = *(cuPdschCfg->maxNrofCodeWordsScheduledByDCI);
7876    if(cuPdschCfg->prb_BundlingType.present == PDSCH_Config__prb_BundlingType_PR_staticBundling)
7877    {
7878       macPdschCfg->bundlingType = cuPdschCfg->prb_BundlingType.present;
7879       if(cuPdschCfg->prb_BundlingType.choice.staticBundling)
7880       {
7881          if(cuPdschCfg->prb_BundlingType.choice.staticBundling->bundleSize)
7882          {
7883             macPdschCfg->bundlingInfo.StaticBundling.size = \
7884                *(cuPdschCfg->prb_BundlingType.choice.staticBundling->bundleSize);
7885          }
7886       }
7887    }
7888    else if(cuPdschCfg->prb_BundlingType.present == PDSCH_Config__prb_BundlingType_PR_dynamicBundling)
7889    {
7890       macPdschCfg->bundlingType = cuPdschCfg->prb_BundlingType.present;
7891    }
7892
7893 }
7894
7895 /*******************************************************************
7896  *
7897  * @brief Fills PdschServingCellCfg received by CU
7898  *
7899  * @details
7900  *
7901  *    Function : extractPdschServingCellCfg
7902  *
7903  *    Functionality: Fills PdschCfg received  by CU
7904  *
7905  * @params[in] PDSCH_ServingCellConfig_t *cuPdschSrvCellCfg,
7906  *             PdschServCellCfg *macUePdschSrvCellCfg
7907  * @return ROK/RFAILED
7908  *
7909  * ****************************************************************/
7910
7911 uint8_t extractPdschServingCellCfg(PDSCH_ServingCellConfig_t *cuPdschSrvCellCfg, PdschServCellCfg *macUePdschSrvCellCfg)
7912 {
7913    if(cuPdschSrvCellCfg->codeBlockGroupTransmission)
7914    {
7915       if(cuPdschSrvCellCfg->codeBlockGroupTransmission->choice.setup)
7916       {
7917          if(macUePdschSrvCellCfg->maxCodeBlkGrpPerTb)
7918          {
7919             *(macUePdschSrvCellCfg->maxCodeBlkGrpPerTb)  = \
7920                cuPdschSrvCellCfg->codeBlockGroupTransmission->choice.setup->maxCodeBlockGroupsPerTransportBlock;
7921          }
7922          else
7923          {
7924             DU_ALLOC_SHRABL_BUF(macUePdschSrvCellCfg->maxCodeBlkGrpPerTb, sizeof(uint8_t));
7925             if(macUePdschSrvCellCfg->maxCodeBlkGrpPerTb)
7926             {
7927                *(macUePdschSrvCellCfg->maxCodeBlkGrpPerTb)  = \
7928                   cuPdschSrvCellCfg->codeBlockGroupTransmission->choice.setup->maxCodeBlockGroupsPerTransportBlock;
7929             }
7930             else
7931             {
7932                DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for maxCodeBlkGrpPerTb at extractPdschServingCellCfg()");
7933                return RFAILED;
7934             }
7935          }
7936          if(macUePdschSrvCellCfg->codeBlkGrpFlushInd)
7937          {
7938             *(macUePdschSrvCellCfg->codeBlkGrpFlushInd)  = \
7939                cuPdschSrvCellCfg->codeBlockGroupTransmission->choice.setup->codeBlockGroupFlushIndicator;
7940          }
7941          else
7942          {
7943             DU_ALLOC_SHRABL_BUF(macUePdschSrvCellCfg->maxCodeBlkGrpPerTb, sizeof(bool));
7944             if(macUePdschSrvCellCfg->codeBlkGrpFlushInd)
7945             {
7946                *(macUePdschSrvCellCfg->codeBlkGrpFlushInd)  = \
7947                   cuPdschSrvCellCfg->codeBlockGroupTransmission->choice.setup->codeBlockGroupFlushIndicator;
7948             }
7949             else
7950             {
7951                DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for codeBlkGrpFlushInd at extractPdschServingCellCfg()");
7952                return RFAILED;
7953             }
7954          }
7955       }
7956    }
7957    if(cuPdschSrvCellCfg->nrofHARQ_ProcessesForPDSCH)
7958    {
7959       macUePdschSrvCellCfg->numHarqProcForPdsch = *(cuPdschSrvCellCfg->nrofHARQ_ProcessesForPDSCH);
7960    }
7961    if(cuPdschSrvCellCfg->ext1)
7962    {
7963       if(cuPdschSrvCellCfg->ext1->maxMIMO_Layers)
7964       {
7965         if(macUePdschSrvCellCfg->maxMimoLayers)
7966         {
7967            *(macUePdschSrvCellCfg->maxMimoLayers)  = *(cuPdschSrvCellCfg->ext1->maxMIMO_Layers);
7968         }
7969         else
7970         {
7971            DU_ALLOC_SHRABL_BUF(macUePdschSrvCellCfg->maxMimoLayers, sizeof(uint8_t));
7972            if(macUePdschSrvCellCfg->maxMimoLayers)
7973            {
7974               *(macUePdschSrvCellCfg->maxMimoLayers)  = *(cuPdschSrvCellCfg->ext1->maxMIMO_Layers);
7975            }
7976            else
7977            {
7978               DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for maxMimoLayers at extractPdschServingCellCfg()");
7979               return RFAILED;
7980            }
7981         }
7982       }
7983    }
7984    if(cuPdschSrvCellCfg->xOverhead)
7985    {
7986       if(macUePdschSrvCellCfg->xOverhead)
7987       {
7988          *(macUePdschSrvCellCfg->xOverhead)  = *(cuPdschSrvCellCfg->xOverhead);
7989       }
7990       else
7991       {
7992          DU_ALLOC_SHRABL_BUF(macUePdschSrvCellCfg->xOverhead, sizeof(uint8_t));
7993          if(macUePdschSrvCellCfg->xOverhead)
7994          {
7995             *(macUePdschSrvCellCfg->xOverhead)  = *(cuPdschSrvCellCfg->xOverhead);
7996          }
7997          else
7998          {
7999             DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for xOverhead at extractPdschServingCellCfg()");
8000             return RFAILED;
8001          }
8002       }
8003    }
8004    return ROK;
8005 }
8006
8007 /*******************************************************************
8008  *
8009  * @brief Fills PuschCfg received by CU
8010  *
8011  * @details
8012  *
8013  *    Function : extractPuschCfg
8014  *
8015  *    Functionality: Fills PuschCfg received  by CU
8016  *
8017  * @params[in] BWP_UplinkDedicated__pusch_Config *cuPuschCfg,
8018  *             PuschCfg *macPuschCfg
8019  * @return void
8020  *
8021  * ****************************************************************/
8022
8023 void extractPuschCfg(struct BWP_UplinkDedicated__pusch_Config *cuPuschCfg, PuschCfg *macPuschCfg)
8024 {
8025    uint8_t timeDomIdx = 0;
8026    DMRS_UplinkConfig_t *dmrsUlCfg = NULLP;
8027    struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList = NULLP;
8028
8029    if(cuPuschCfg->present == BWP_UplinkDedicated__pusch_Config_PR_setup)
8030    {
8031       if(cuPuschCfg->choice.setup)
8032       {
8033          if(cuPuschCfg->choice.setup->dataScramblingIdentityPUSCH)
8034          {
8035              macPuschCfg->dataScramblingId = \
8036                 *(cuPuschCfg->choice.setup->dataScramblingIdentityPUSCH);
8037          }
8038          if(cuPuschCfg->choice.setup->dmrs_UplinkForPUSCH_MappingTypeA)
8039          {
8040             if(cuPuschCfg->choice.setup->dmrs_UplinkForPUSCH_MappingTypeA->present == PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA_PR_setup)
8041             {
8042                if(cuPuschCfg->choice.setup->dmrs_UplinkForPUSCH_MappingTypeA->choice.setup)
8043                {
8044                   dmrsUlCfg = (cuPuschCfg->choice.setup->dmrs_UplinkForPUSCH_MappingTypeA->choice.setup);
8045                   if(dmrsUlCfg->dmrs_AdditionalPosition)
8046                   {
8047                      macPuschCfg->dmrsUlCfgForPuschMapTypeA.addPos =\
8048                         *(dmrsUlCfg->dmrs_AdditionalPosition);
8049                   }
8050                   if(dmrsUlCfg->transformPrecodingDisabled)
8051                   {
8052                      if(dmrsUlCfg->transformPrecodingDisabled->scramblingID0)
8053                      {
8054                         macPuschCfg->dmrsUlCfgForPuschMapTypeA.transPrecodDisabled.scramblingId0 = \
8055                            *(dmrsUlCfg->transformPrecodingDisabled->scramblingID0);
8056                      }
8057                   }
8058                }
8059             }
8060          }
8061          /*Res Alloc Type for UL */
8062          if(cuPuschCfg->choice.setup->resourceAllocation)
8063          {
8064             macPuschCfg->resourceAllocType = \
8065                cuPuschCfg->choice.setup->resourceAllocation;
8066          }
8067          if(cuPuschCfg->choice.setup->pusch_TimeDomainAllocationList)
8068          {
8069             timeDomAllocList = cuPuschCfg->choice.setup->pusch_TimeDomainAllocationList;
8070             if(timeDomAllocList->present == PUSCH_Config__pusch_TimeDomainAllocationList_PR_setup)
8071             {
8072                if(timeDomAllocList->choice.setup)
8073                {
8074                   macPuschCfg->numTimeDomRsrcAlloc = timeDomAllocList->choice.setup->list.count;
8075                   for(timeDomIdx = 0; timeDomIdx <timeDomAllocList->choice.setup->list.count; timeDomIdx++)
8076                   {
8077                      macPuschCfg->timeDomRsrcAllocList[timeDomIdx].k2 = \
8078                         *(timeDomAllocList->choice.setup->list.array[timeDomIdx]->k2);
8079                      macPuschCfg->timeDomRsrcAllocList[timeDomIdx].mappingType = \
8080                         timeDomAllocList->choice.setup->list.array[timeDomIdx]->mappingType;
8081                      macPuschCfg->timeDomRsrcAllocList[timeDomIdx].startSymbolAndLength = \
8082                         timeDomAllocList->choice.setup->list.array[timeDomIdx]->startSymbolAndLength;
8083                   }
8084                }
8085             }
8086          }
8087          if(cuPuschCfg->choice.setup->transformPrecoder)
8088             macPuschCfg->transformPrecoder = *(cuPuschCfg->choice.setup->transformPrecoder);
8089       }
8090    }
8091 }
8092
8093 /*******************************************************************
8094  *
8095  * @brief Function to fill pucch Power Control
8096  *
8097  * @details
8098  *
8099  *    Function : extractPucchPowerControl
8100  *
8101  *    Functionality: Function to fill pucch Power Control
8102  *
8103  * @params[in] PucchPowerControl *pwrCtrl,
8104  *             struct PUCCH_PowerControl *cuPwrCtrlCfg
8105  * @return void
8106  *
8107  * ****************************************************************/
8108
8109 void extractPucchPowerControl(PucchPowerControl *pwrCtrl, struct PUCCH_PowerControl *cuPwrCtrlCfg)
8110 {
8111    uint8_t arrIdx;
8112
8113    if(cuPwrCtrlCfg->deltaF_PUCCH_f0)
8114       pwrCtrl->deltaF_Format0 = *cuPwrCtrlCfg->deltaF_PUCCH_f0;
8115    if(cuPwrCtrlCfg->deltaF_PUCCH_f1)
8116       pwrCtrl->deltaF_Format1 = *cuPwrCtrlCfg->deltaF_PUCCH_f1;
8117    if(cuPwrCtrlCfg->deltaF_PUCCH_f2)
8118       pwrCtrl->deltaF_Format2 = *cuPwrCtrlCfg->deltaF_PUCCH_f2;
8119    if(cuPwrCtrlCfg->deltaF_PUCCH_f3)
8120       pwrCtrl->deltaF_Format3 = *cuPwrCtrlCfg->deltaF_PUCCH_f3;
8121    if(cuPwrCtrlCfg->deltaF_PUCCH_f4)
8122       pwrCtrl->deltaF_Format4 = *cuPwrCtrlCfg->deltaF_PUCCH_f4;
8123    if(cuPwrCtrlCfg->p0_Set)
8124    {
8125       pwrCtrl->p0SetCount = cuPwrCtrlCfg->p0_Set->list.count;
8126       for(arrIdx=0; arrIdx < pwrCtrl->p0SetCount; arrIdx++)
8127       {
8128          pwrCtrl->p0Set[arrIdx].p0PucchId =\
8129             cuPwrCtrlCfg->p0_Set->list.array[arrIdx]->p0_PUCCH_Id;
8130          pwrCtrl->p0Set[arrIdx].p0PucchVal =\
8131             cuPwrCtrlCfg->p0_Set->list.array[arrIdx]->p0_PUCCH_Value;
8132       }
8133    }
8134    if(cuPwrCtrlCfg->pathlossReferenceRSs)
8135    {
8136       pwrCtrl->pathLossRefRSListCount = cuPwrCtrlCfg->pathlossReferenceRSs->list.count;
8137       for(arrIdx = 0; arrIdx < pwrCtrl->pathLossRefRSListCount; arrIdx++)
8138       {
8139          pwrCtrl->pathLossRefRSList[arrIdx].pathLossRefRSId =\
8140             cuPwrCtrlCfg->pathlossReferenceRSs->list.array[arrIdx]->pucch_PathlossReferenceRS_Id;
8141       }
8142    }
8143 }
8144
8145  /*******************************************************************
8146  *
8147  * @brief Function to extractResrcSetToAddModList sent by CU
8148  *
8149  * @details
8150  *
8151  *    Function : extractResrcSetToAddModList
8152  *
8153  *    Functionality: Fucntion to extractResrcSetToAddModList
8154  *
8155  * @params[in] PucchResrcSetCfg pointer,
8156  *             struct PUCCH_Config__resourceSetToAddModList pointer
8157  * @return void
8158  *
8159  * ****************************************************************/
8160
8161 void extractResrcSetToAddModList(PucchResrcSetCfg *macRsrcSetList, struct PUCCH_Config__resourceSetToAddModList *cuRsrcSetList)
8162 {
8163    uint8_t arrIdx, rsrcListIdx;
8164
8165    macRsrcSetList->resrcSetToAddModListCount = cuRsrcSetList->list.count;
8166    for(arrIdx = 0; arrIdx < macRsrcSetList->resrcSetToAddModListCount; arrIdx++)
8167    {
8168       macRsrcSetList->resrcSetToAddModList[arrIdx].resrcSetId     =\
8169          cuRsrcSetList->list.array[arrIdx]->pucch_ResourceSetId;
8170       macRsrcSetList->resrcSetToAddModList[arrIdx].resrcListCount =\
8171          cuRsrcSetList->list.array[arrIdx]->resourceList.list.count;
8172       for(rsrcListIdx = 0; rsrcListIdx < macRsrcSetList->resrcSetToAddModList[arrIdx].resrcListCount; rsrcListIdx++)
8173       {
8174          macRsrcSetList->resrcSetToAddModList[arrIdx].resrcList[rsrcListIdx] =\
8175             *cuRsrcSetList->list.array[arrIdx]->resourceList.list.array[rsrcListIdx];
8176       }
8177       macRsrcSetList->resrcSetToAddModList[arrIdx].maxPayLoadSize =\
8178          *cuRsrcSetList->list.array[arrIdx]->maxPayloadMinus1;
8179    }
8180 }/* End of extractResrcSetToAddModList */
8181
8182 /*******************************************************************
8183  *
8184  * @brief Fills extractResrcToAddModList sent by CU
8185  *
8186  * @details
8187  *
8188  *    Function : extractResrcToAddModList
8189  *
8190  *    Functionality: Fills extractResrcToAddModList
8191  *
8192  * @params[in] PucchResrcCfg pointer,
8193  *             struct PUCCH_Config__resourceToAddModList pointer
8194  * @return ROk/RFAILED
8195  *
8196  * ****************************************************************/
8197
8198 uint8_t extractResrcToAddModList(PucchResrcCfg *macResrcList, struct PUCCH_Config__resourceToAddModList *cuResrcList)
8199 {
8200    uint8_t arrIdx;
8201
8202    macResrcList->resrcToAddModListCount = cuResrcList->list.count;
8203    for(arrIdx = 0; arrIdx < macResrcList->resrcToAddModListCount; arrIdx++)
8204    {
8205       macResrcList->resrcToAddModList[arrIdx].resrcId      =\
8206         cuResrcList->list.array[arrIdx]->pucch_ResourceId;
8207       macResrcList->resrcToAddModList[arrIdx].startPrb     =\
8208         cuResrcList->list.array[arrIdx]->startingPRB;
8209       if(cuResrcList->list.array[arrIdx]->intraSlotFrequencyHopping)
8210       {
8211          macResrcList->resrcToAddModList[arrIdx].intraFreqHop =\
8212            *cuResrcList->list.array[arrIdx]->intraSlotFrequencyHopping;
8213       }
8214       if(cuResrcList->list.array[arrIdx]->secondHopPRB)
8215       {
8216          macResrcList->resrcToAddModList[arrIdx].secondPrbHop =\
8217            *cuResrcList->list.array[arrIdx]->secondHopPRB;
8218       }
8219       /* PUCCH RSRC FORMAT */
8220       if(cuResrcList->list.array[arrIdx]->format.present == PUCCH_Resource__format_PR_format0)
8221       {
8222          macResrcList->resrcToAddModList[arrIdx].pucchFormat = PUCCH_FORMAT_0;
8223          if(cuResrcList->list.array[arrIdx]->format.choice.format0)
8224          {
8225             DU_ALLOC_SHRABL_BUF(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format0, sizeof(PucchFormat0));
8226             if(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format0 == NULLP)
8227             {
8228                DU_LOG("\nERROR  --> F1AP : Failed to allocate memory for Format0 in extractResrcToAddModList()");
8229                return RFAILED;
8230             }
8231             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format0->initialCyclicShift =\
8232                cuResrcList->list.array[arrIdx]->format.choice.format0->initialCyclicShift;
8233             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format0->numSymbols =\
8234                cuResrcList->list.array[arrIdx]->format.choice.format0->nrofSymbols;
8235             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format0->startSymbolIdx =\
8236                cuResrcList->list.array[arrIdx]->format.choice.format0->startingSymbolIndex;
8237          }
8238       }
8239       else if(cuResrcList->list.array[arrIdx]->format.present == PUCCH_Resource__format_PR_format1)
8240       {
8241          macResrcList->resrcToAddModList[arrIdx].pucchFormat = PUCCH_FORMAT_1;
8242          if(cuResrcList->list.array[arrIdx]->format.choice.format1)
8243          {
8244             DU_ALLOC_SHRABL_BUF(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1, sizeof(PucchFormat1));
8245             if(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1 == NULLP)
8246             {
8247                DU_LOG("\nERROR  --> F1AP : Failed to allocate memory for Format1 in extractResrcToAddModList()");
8248                return RFAILED;
8249             }
8250             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1->initialCyclicShift =\
8251                 cuResrcList->list.array[arrIdx]->format.choice.format1->initialCyclicShift;
8252             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1->numSymbols =\
8253                 cuResrcList->list.array[arrIdx]->format.choice.format1->nrofSymbols;
8254             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1->startSymbolIdx =\
8255                 cuResrcList->list.array[arrIdx]->format.choice.format1->startingSymbolIndex;
8256             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1->timeDomOCC =\
8257                 cuResrcList->list.array[arrIdx]->format.choice.format1->timeDomainOCC;
8258          }
8259       }
8260       else if(cuResrcList->list.array[arrIdx]->format.present == PUCCH_Resource__format_PR_format2)
8261       {
8262          macResrcList->resrcToAddModList[arrIdx].pucchFormat = PUCCH_FORMAT_2;
8263          if(cuResrcList->list.array[arrIdx]->format.choice.format2)
8264          {
8265             DU_ALLOC_SHRABL_BUF(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format2, sizeof(PucchFormat2_3));
8266             if(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format2 == NULLP)
8267             {
8268                DU_LOG("\nERROR  --> F1AP : Failed to allocate memory for Format2 in extractResrcToAddModList()");
8269                return RFAILED;
8270             }
8271             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format2->numPrbs =\
8272                 cuResrcList->list.array[arrIdx]->format.choice.format2->nrofPRBs;
8273             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format2->numSymbols =\
8274                 cuResrcList->list.array[arrIdx]->format.choice.format2->nrofSymbols;
8275             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format2->startSymbolIdx =\
8276                 cuResrcList->list.array[arrIdx]->format.choice.format2->startingSymbolIndex;
8277          }
8278       }
8279       else if(cuResrcList->list.array[arrIdx]->format.present == PUCCH_Resource__format_PR_format3)
8280       {
8281          macResrcList->resrcToAddModList[arrIdx].pucchFormat = PUCCH_FORMAT_3;
8282          if(cuResrcList->list.array[arrIdx]->format.choice.format3)
8283          {
8284             DU_ALLOC_SHRABL_BUF(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format3, sizeof(PucchFormat2_3));
8285             if(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format3 == NULLP)
8286             {
8287                DU_LOG("\nERROR  --> F1AP : Failed to allocate memory for Format3 in extractResrcToAddModList()");
8288                return RFAILED;
8289             }
8290             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format3->numPrbs =\
8291                 cuResrcList->list.array[arrIdx]->format.choice.format3->nrofPRBs;
8292             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format3->numSymbols =\
8293                 cuResrcList->list.array[arrIdx]->format.choice.format3->nrofSymbols;
8294             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format3->startSymbolIdx =\
8295                 cuResrcList->list.array[arrIdx]->format.choice.format3->startingSymbolIndex;
8296          }
8297       }
8298       else if(cuResrcList->list.array[arrIdx]->format.present == PUCCH_Resource__format_PR_format4)
8299       {
8300          macResrcList->resrcToAddModList[arrIdx].pucchFormat = PUCCH_FORMAT_4;
8301          if(cuResrcList->list.array[arrIdx]->format.choice.format4)
8302          {
8303             DU_ALLOC_SHRABL_BUF(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4, sizeof(PucchFormat4));
8304             if(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4 == NULLP)
8305             {
8306                DU_LOG("\nERROR  --> F1AP : Failed to allocate memory for Format4 in extractResrcToAddModList()");
8307                return RFAILED;
8308             }
8309             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4->numSymbols =\
8310                 cuResrcList->list.array[arrIdx]->format.choice.format4->nrofSymbols;
8311             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4->occLen =\
8312                 cuResrcList->list.array[arrIdx]->format.choice.format4->occ_Length;
8313             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4->occIdx =\
8314                 cuResrcList->list.array[arrIdx]->format.choice.format4->occ_Index;
8315             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4->startSymbolIdx =\
8316                 cuResrcList->list.array[arrIdx]->format.choice.format4->startingSymbolIndex;
8317          }
8318       }
8319    }
8320    return ROK;
8321
8322 }/* End of extractResrcToAddModList */
8323
8324 /*******************************************************************
8325  *
8326  * @brief Fills fillPucchSchedReqPeriodAndOffset sent by CU
8327  *
8328  * @details
8329  *
8330  *    Function : fillPucchSchedReqPeriodAndOffset
8331  *
8332  *    Functionality: To fillPucchSchedReqPeriodAndOffset
8333  *
8334  * @params[in] macPeriodicty,
8335  *     SchedulingRequestResourceConfig__periodicityAndOffset pointer
8336  * @return void
8337  *
8338  * ****************************************************************/
8339
8340 void fillPucchSchedReqPeriodAndOffset(uint8_t macPeriodicty, uint16_t  macOffset,\
8341    struct SchedulingRequestResourceConfig__periodicityAndOffset *cuPeriodicty)
8342 {
8343    macPeriodicty = cuPeriodicty->present;
8344    switch(macPeriodicty)
8345    {
8346       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sym2:
8347          {
8348             macOffset     = cuPeriodicty->choice.sym2;
8349             break;
8350          }
8351       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sym6or7:
8352          {
8353             macOffset     = cuPeriodicty->choice.sym6or7;
8354             break;
8355          }
8356       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl1:
8357          {
8358             macOffset     = cuPeriodicty->choice.sl1;
8359             break;
8360          }
8361       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl2:
8362          {
8363             macOffset = cuPeriodicty->choice.sl2;
8364             break;
8365          }
8366       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl4:
8367          {
8368             macOffset = cuPeriodicty->choice.sl4;
8369             break;
8370          }
8371       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl5:
8372          {
8373             macOffset = cuPeriodicty->choice.sl5;
8374             break;
8375          }
8376       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl8:
8377          {
8378             macOffset = cuPeriodicty->choice.sl8;
8379             break;
8380          }
8381       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl10:
8382          {
8383             macOffset = cuPeriodicty->choice.sl10;
8384             break;
8385          }
8386       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl16:
8387          {
8388             macOffset = cuPeriodicty->choice.sl16;
8389             break;
8390          }
8391       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl20:
8392          {
8393             macOffset = cuPeriodicty->choice.sl20;
8394             break;
8395          }
8396       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl40:
8397          {
8398             macOffset = cuPeriodicty->choice.sl40;
8399             break;
8400          }
8401       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl80:
8402          {
8403             macOffset = cuPeriodicty->choice.sl80;
8404             break;
8405          }
8406       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl160:
8407          {
8408             macOffset = cuPeriodicty->choice.sl160;
8409             break;
8410          }
8411       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl320:
8412          {
8413             macOffset = cuPeriodicty->choice.sl320;
8414             break;
8415          }
8416       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl640:
8417          {
8418             macOffset = cuPeriodicty->choice.sl640;
8419             break;
8420          }
8421       default :
8422          DU_LOG("\nERROR  -->  F1AP : Invalid periodicity %d", macPeriodicty);
8423    }
8424 }
8425
8426 /*******************************************************************
8427  *
8428  * @brief Function to extractPucchFormatCfg sent by CU
8429  *
8430  * @details
8431  *
8432  *    Function : extractPucchFormatCfg
8433  *
8434  *    Functionality: Function to extractPucchFormatCfg
8435  *
8436  * @params[in] PucchFormatCfg pointer,
8437  *             PUCCH_FormatConfig_t pointer
8438  * @return void
8439  *
8440  * ****************************************************************/
8441
8442 void extractPucchFormatCfg(PucchFormatCfg *macFormatCfg, PUCCH_FormatConfig_t *cuFormatCfg)
8443  {
8444     if(cuFormatCfg->interslotFrequencyHopping)
8445        macFormatCfg->interSlotFreqHop = *cuFormatCfg->interslotFrequencyHopping;
8446     if(cuFormatCfg->additionalDMRS)
8447        macFormatCfg->addDmrs = *cuFormatCfg->additionalDMRS;
8448     if(cuFormatCfg->maxCodeRate)
8449        macFormatCfg->maxCodeRate = *cuFormatCfg->maxCodeRate;
8450     if(cuFormatCfg->nrofSlots)
8451        macFormatCfg->numSlots = *cuFormatCfg->nrofSlots;
8452     if(cuFormatCfg->pi2BPSK)
8453        macFormatCfg->pi2BPSK = *cuFormatCfg->pi2BPSK;
8454     if(cuFormatCfg->simultaneousHARQ_ACK_CSI)
8455        macFormatCfg->harqAckCSI = *cuFormatCfg->simultaneousHARQ_ACK_CSI;
8456  }/* End of extractPucchFormatCfg */
8457
8458 /*******************************************************************
8459  *
8460  * @brief Function to extractSchedReqCfgToAddMod sent by CU
8461  *
8462  * @details
8463  *
8464  *    Function : extractSchedReqCfgToAddMod
8465  *
8466  *    Functionality: Function to extractSchedReqCfgToAddMod
8467  *
8468  * @params[in] PucchSchedReqCfg pointer,
8469  *      PUCCH_Config__schedulingRequestResourceToAddModList pointer
8470  * @return void
8471  *
8472  * ****************************************************************/
8473
8474 void extractSchedReqCfgToAddMod(PucchSchedReqCfg *macSchedReqCfg, struct PUCCH_Config__schedulingRequestResourceToAddModList *cuSchedReqList)
8475 {
8476    uint8_t arrIdx;
8477
8478    macSchedReqCfg->schedAddModListCount = cuSchedReqList->list.count;
8479    for(arrIdx = 0; arrIdx <  macSchedReqCfg->schedAddModListCount; arrIdx++)
8480    {
8481       macSchedReqCfg->schedAddModList[arrIdx].resrcId =\
8482          cuSchedReqList->list.array[arrIdx]->schedulingRequestResourceId;
8483       macSchedReqCfg->schedAddModList[arrIdx].requestId =\
8484          cuSchedReqList->list.array[arrIdx]->schedulingRequestID;
8485       if(cuSchedReqList->list.array[arrIdx]->periodicityAndOffset)
8486       {
8487          fillPucchSchedReqPeriodAndOffset(macSchedReqCfg->schedAddModList[arrIdx].periodicity,\
8488             macSchedReqCfg->schedAddModList[arrIdx].offset, cuSchedReqList->list.array[arrIdx]->periodicityAndOffset);
8489       }
8490       if(cuSchedReqList->list.array[arrIdx]->resource)
8491       {
8492          macSchedReqCfg->schedAddModList[arrIdx].resrc =\
8493             *cuSchedReqList->list.array[arrIdx]->resource;
8494       }
8495    }
8496
8497 }/* End of extractSchedReqCfgToAddMod */
8498
8499  /*******************************************************************
8500  *
8501  * @brief Fills PucchCfg received by CU
8502  *
8503  * @details
8504  *
8505  *    Function : extractPucchCfg
8506  *
8507  *    Functionality: Fills PucchCfg received  by CU
8508  *
8509  * @params[in] BWP_UplinkDedicated__pucch_Config *cuPucchCfg,
8510  *             PucchCfg *macPucchCfg
8511  * @return ROK/RFAILED
8512  *
8513  * ****************************************************************/
8514
8515 uint8_t extractPucchCfg(struct BWP_UplinkDedicated__pucch_Config *cuPucchCfg, PucchCfg *macPucchCfg)
8516 {
8517    uint8_t arrIdx;
8518
8519    if(cuPucchCfg->present == BWP_UplinkDedicated__pucch_Config_PR_setup)
8520    {
8521       if(cuPucchCfg->choice.setup)
8522       {
8523          /* Resource Set Cfg */
8524          if(cuPucchCfg->choice.setup->resourceSetToAddModList)
8525          {
8526             DU_ALLOC_SHRABL_BUF(macPucchCfg->resrcSet, sizeof(PucchResrcSetCfg));
8527             if(macPucchCfg->resrcSet == NULLP)
8528             {
8529                DU_LOG("\nERROR --> F1AP : Failed to extract Resrc set List in extractPucchCfg()");
8530                return RFAILED;
8531             }
8532             memset(macPucchCfg->resrcSet, 0, sizeof(PucchResrcSetCfg));
8533             extractResrcSetToAddModList(macPucchCfg->resrcSet, cuPucchCfg->choice.setup->resourceSetToAddModList);
8534          }
8535
8536          /* Resource Cfg */
8537          if(cuPucchCfg->choice.setup->resourceToAddModList)
8538          {
8539             DU_ALLOC_SHRABL_BUF(macPucchCfg->resrc, sizeof(PucchResrcCfg));
8540             if(macPucchCfg->resrc == NULLP)
8541             {
8542                DU_LOG("\nERROR --> F1AP : Failed to extract Resrc List in extractPucchCfg()");
8543                return RFAILED;
8544             }
8545             memset(macPucchCfg->resrc, 0, sizeof(PucchResrcCfg));
8546             extractResrcToAddModList(macPucchCfg->resrc, cuPucchCfg->choice.setup->resourceToAddModList);
8547          }
8548
8549          /* Format 1 Cfg */
8550          if(cuPucchCfg->choice.setup->format1)
8551          {
8552             DU_ALLOC_SHRABL_BUF(macPucchCfg->format1, sizeof(PucchFormatCfg));
8553             if(macPucchCfg->format1 == NULLP)
8554             {
8555                DU_LOG("\nERROR --> F1AP : Failed to extract format 1 Cfg in  extractPucchCfg()");
8556                return RFAILED;
8557             }
8558             memset(macPucchCfg->format1, 0, sizeof(PucchFormatCfg));
8559             extractPucchFormatCfg(macPucchCfg->format1,\
8560                cuPucchCfg->choice.setup->format1->choice.setup);
8561          }
8562
8563          /* Format 2 Cfg */
8564          if(cuPucchCfg->choice.setup->format2)
8565          {
8566             DU_ALLOC_SHRABL_BUF(macPucchCfg->format2, sizeof(PucchFormatCfg));
8567             if(macPucchCfg->format2 == NULLP)
8568             {
8569                DU_LOG("\nERROR --> F1AP : Failed to extract format 2 Cfg in  extractPucchCfg()");
8570                return RFAILED;
8571             }
8572             memset(macPucchCfg->format2, 0, sizeof(PucchFormatCfg));
8573             extractPucchFormatCfg(macPucchCfg->format2,\
8574                cuPucchCfg->choice.setup->format2->choice.setup);
8575          }
8576
8577          /* Format 3 Cfg */
8578          if(cuPucchCfg->choice.setup->format3)
8579          {
8580             DU_ALLOC_SHRABL_BUF(macPucchCfg->format3, sizeof(PucchFormatCfg));
8581             if(macPucchCfg->format3 == NULLP)
8582             {
8583                DU_LOG("\nERROR --> F1AP : Failed to extract format 3 Cfg in  extractPucchCfg()");
8584                return RFAILED;
8585             }
8586             memset(macPucchCfg->format3, 0, sizeof(PucchFormatCfg));
8587             extractPucchFormatCfg(macPucchCfg->format3,\
8588                cuPucchCfg->choice.setup->format3->choice.setup);
8589          }
8590
8591          /* Format 4 Cfg */
8592          if(cuPucchCfg->choice.setup->format4)
8593          {
8594             DU_ALLOC_SHRABL_BUF(macPucchCfg->format4, sizeof(PucchFormatCfg));
8595             if(macPucchCfg->format4 == NULLP)
8596             {
8597                DU_LOG("\nERROR --> F1AP : Failed to extract format 4 Cfg in  extractPucchCfg()");
8598                return RFAILED;
8599             }
8600             memset(macPucchCfg->format4, 0, sizeof(PucchFormatCfg));
8601             extractPucchFormatCfg(macPucchCfg->format4,\
8602                cuPucchCfg->choice.setup->format4->choice.setup);
8603          }
8604
8605          /* Sched Req List */
8606          if(cuPucchCfg->choice.setup->schedulingRequestResourceToAddModList)
8607          {
8608             DU_ALLOC_SHRABL_BUF(macPucchCfg->schedReq, sizeof(PucchSchedReqCfg));
8609             if(macPucchCfg->schedReq == NULLP)
8610             {
8611                DU_LOG("\nERROR --> F1AP : Failed to extract schedReqCfg in  extractPucchCfg()");
8612                return RFAILED;
8613             }
8614             memset(macPucchCfg->schedReq, 0, sizeof(PucchSchedReqCfg));
8615             extractSchedReqCfgToAddMod(macPucchCfg->schedReq,\
8616             cuPucchCfg->choice.setup->schedulingRequestResourceToAddModList);
8617          }
8618
8619          /*TODO: Add support for  Spatial Info */
8620
8621          /* MultiCsiCfg */
8622          if(cuPucchCfg->choice.setup->multi_CSI_PUCCH_ResourceList)
8623          {
8624             DU_ALLOC_SHRABL_BUF(macPucchCfg->multiCsiCfg, sizeof(PucchMultiCsiCfg));
8625             if(macPucchCfg->multiCsiCfg == NULLP)
8626             {
8627                DU_LOG("\nERROR --> F1AP : Failed to extract multiCsiCfg in  extractPucchCfg()");
8628                return RFAILED;
8629             }
8630             memset(macPucchCfg->multiCsiCfg, 0, sizeof(PucchMultiCsiCfg));
8631             macPucchCfg->multiCsiCfg->multiCsiResrcListCount = cuPucchCfg->choice.setup->multi_CSI_PUCCH_ResourceList->list.count;
8632             for(arrIdx =0; arrIdx < macPucchCfg->multiCsiCfg->multiCsiResrcListCount; arrIdx++)
8633             {
8634                macPucchCfg->multiCsiCfg->multiCsiResrcList[arrIdx] =\
8635                  *cuPucchCfg->choice.setup->multi_CSI_PUCCH_ResourceList->list.array[arrIdx];
8636             }
8637          }
8638
8639          /* Dl_DataToUL_ACK */
8640          if(cuPucchCfg->choice.setup->dl_DataToUL_ACK)
8641          {
8642             DU_ALLOC_SHRABL_BUF(macPucchCfg->dlDataToUlAck, sizeof(PucchDlDataToUlAck));
8643             if(macPucchCfg->dlDataToUlAck == NULLP)
8644             {
8645                DU_LOG("\nERROR --> F1AP : Failed to extract Dl_DataToUL_ACK in extractPucchCfg()");
8646                return RFAILED;
8647             }
8648             memset(macPucchCfg->dlDataToUlAck, 0, sizeof(PucchDlDataToUlAck));
8649             macPucchCfg->dlDataToUlAck->dlDataToUlAckListCount = cuPucchCfg->choice.setup->dl_DataToUL_ACK->list.count;
8650             for(arrIdx = 0; arrIdx < macPucchCfg->dlDataToUlAck->dlDataToUlAckListCount; arrIdx++)
8651             {
8652                macPucchCfg->dlDataToUlAck->dlDataToUlAckList[arrIdx] =\
8653                   *cuPucchCfg->choice.setup->dl_DataToUL_ACK->list.array[arrIdx];
8654             }
8655          }
8656
8657          /* Power Control */
8658          if(cuPucchCfg->choice.setup->pucch_PowerControl)
8659          {
8660             DU_ALLOC_SHRABL_BUF(macPucchCfg->powerControl, sizeof(PucchPowerControl));
8661             if(macPucchCfg->powerControl == NULLP)
8662             {
8663                DU_LOG("\nERROR --> F1AP : Failed to extract power control in extractPucchCfg()");
8664                return RFAILED;
8665             }
8666             extractPucchPowerControl(macPucchCfg->powerControl,\
8667                cuPucchCfg->choice.setup->pucch_PowerControl);
8668          }
8669       }
8670    }
8671    return ROK;
8672 }
8673
8674 /*******************************************************************
8675  *
8676  * @brief Fills ServingCellReconfig received by CU
8677  *
8678  * @details
8679  *
8680  *    Function : extractSpCellDedicatedCfg
8681  *
8682  *    Functionality: Fills ServingCellReconfig received  by CU
8683  *
8684  * @params[in] ServingCellConfig_t *cuSrvCellCfg
8685  *             ServCellCfgInfo *macSrvCellCfg
8686  * @return ROK/RFAILD
8687  *
8688  * ****************************************************************/
8689 uint8_t extractSpCellDedicatedCfg(ServingCellConfig_t *cuSrvCellCfg, ServCellCfgInfo *macSrvCellCfg)
8690 {
8691    uint8_t ret = ROK;
8692    BWP_DownlinkDedicated_t *dlBwp = NULLP;
8693    BWP_UplinkDedicated_t   *ulBwp = NULLP;
8694
8695    if(cuSrvCellCfg->initialDownlinkBWP)
8696    {
8697       dlBwp = ((BWP_DownlinkDedicated_t *)(cuSrvCellCfg->initialDownlinkBWP));
8698       if(dlBwp->pdcch_Config)
8699       {
8700          if(dlBwp->pdcch_Config->choice.setup)
8701          {
8702             macSrvCellCfg->initDlBwp.pdcchPresent = true;
8703             extractPdcchCfg(dlBwp->pdcch_Config->choice.setup, &macSrvCellCfg->initDlBwp.pdcchCfg);
8704          }
8705       }
8706       if(dlBwp->pdsch_Config)
8707       {
8708          if(dlBwp->pdsch_Config->choice.setup)
8709          {
8710             macSrvCellCfg->initDlBwp.pdschPresent = true;
8711             extractPdschCfg(dlBwp->pdsch_Config->choice.setup, &macSrvCellCfg->initDlBwp.pdschCfg);
8712          }
8713       }
8714    }
8715    if(cuSrvCellCfg->firstActiveDownlinkBWP_Id)
8716       macSrvCellCfg->firstActvDlBwpId = *(cuSrvCellCfg->firstActiveDownlinkBWP_Id);
8717    if(cuSrvCellCfg->defaultDownlinkBWP_Id)
8718       macSrvCellCfg->defaultDlBwpId = *(cuSrvCellCfg->defaultDownlinkBWP_Id);
8719    if(cuSrvCellCfg->bwp_InactivityTimer)
8720    {
8721       if(macSrvCellCfg->bwpInactivityTmr)
8722       {
8723          memcpy(macSrvCellCfg->bwpInactivityTmr, cuSrvCellCfg->bwp_InactivityTimer, sizeof(uint8_t));
8724       }
8725       else
8726       {
8727          macSrvCellCfg->bwpInactivityTmr = NULLP;
8728          DU_ALLOC_SHRABL_BUF(macSrvCellCfg->bwpInactivityTmr, sizeof(uint8_t));
8729          if(macSrvCellCfg->bwpInactivityTmr)
8730          {
8731             memcpy(macSrvCellCfg->bwpInactivityTmr, cuSrvCellCfg->bwp_InactivityTimer, sizeof(uint8_t));
8732          }
8733          else
8734          {
8735             DU_LOG("\nERROR  --> F1AP : Memory Alloc failed for bwpInactivityTmr at extractSpCellDedicatedCfg()");
8736             return RFAILED;
8737          }
8738       }
8739    }
8740    if(cuSrvCellCfg->pdsch_ServingCellConfig)
8741    {
8742       if(cuSrvCellCfg->pdsch_ServingCellConfig->choice.setup)
8743       {
8744          ret = extractPdschServingCellCfg(cuSrvCellCfg->pdsch_ServingCellConfig->choice.setup, &macSrvCellCfg->pdschServCellCfg);
8745          if(ret == RFAILED)
8746          {
8747             DU_LOG("\nERROR --> F1AP : Failed at extractPdschServingCellCfg()");
8748             return RFAILED;
8749          }
8750       }
8751    }
8752    if(cuSrvCellCfg->uplinkConfig)
8753    {
8754      if(cuSrvCellCfg->uplinkConfig->initialUplinkBWP)
8755      {
8756         ulBwp = ((BWP_UplinkDedicated_t *)(cuSrvCellCfg->uplinkConfig->initialUplinkBWP));
8757         if(ulBwp->pusch_Config)
8758         {
8759            macSrvCellCfg->initUlBwp.puschPresent = true;
8760            extractPuschCfg(ulBwp->pusch_Config, &macSrvCellCfg->initUlBwp.puschCfg);
8761         }
8762         if(ulBwp->pucch_Config)
8763         {
8764            macSrvCellCfg->initUlBwp.pucchPresent = true;
8765            memset(&macSrvCellCfg->initUlBwp.pucchCfg, 0, sizeof(PucchCfg));
8766            extractPucchCfg(ulBwp->pucch_Config, &macSrvCellCfg->initUlBwp.pucchCfg);
8767         }
8768      }
8769      if(cuSrvCellCfg->uplinkConfig->firstActiveUplinkBWP_Id)
8770         macSrvCellCfg->firstActvUlBwpId = *(cuSrvCellCfg->uplinkConfig->firstActiveUplinkBWP_Id);
8771    }
8772    return ret;
8773 }
8774 /*******************************************************************
8775  *
8776  * @brief Fills Reconfig Cell group Info received by CU
8777  *
8778  * @details
8779  *
8780  *    Function : extractUeReCfgCellInfo
8781  *
8782  *    Functionality: Fills Reconfig Cell group Info received by CU
8783  *
8784  * @params[in] CellGroupConfigRrc_t *macCellGrpCfg
8785  *             MacUeCfg*  macUeCfg
8786  * @return ROK/RFAILED
8787  *
8788  * ****************************************************************/
8789 uint8_t extractUeReCfgCellInfo(CellGroupConfigRrc_t *cellGrp, MacUeCfg *macUeCfg)
8790 {
8791    uint8_t ret = ROK;
8792    MAC_CellGroupConfig_t     *macCellGroup = NULLP;
8793    PhysicalCellGroupConfig_t *phyCellGrpCfg = NULLP;
8794    SpCellConfig_t            *spcellCfg = NULLP;
8795    ServingCellConfig_t       *servCellCfg = NULLP;
8796
8797    if(cellGrp)
8798    {
8799       /* Fill MacCell Group Reconfig  */
8800       if(cellGrp->mac_CellGroupConfig)
8801       {
8802          macUeCfg->macCellGrpCfgPres = true;
8803          macCellGroup = ((MAC_CellGroupConfig_t *)(cellGrp->mac_CellGroupConfig));
8804          if(macCellGroup->schedulingRequestConfig)
8805          {
8806             extractSchReqReConfig(macCellGroup->schedulingRequestConfig, &macUeCfg->macCellGrpCfg.schReqCfg);
8807          }
8808          if(macCellGroup->tag_Config)
8809          {
8810             extractTagReconfig(macCellGroup->tag_Config, &macUeCfg->macCellGrpCfg.tagCfg);
8811          }
8812          if(macCellGroup->bsr_Config)
8813          {
8814             macUeCfg->macCellGrpCfg.bsrTmrCfg.periodicTimer = macCellGroup->bsr_Config->periodicBSR_Timer;
8815             macUeCfg->macCellGrpCfg.bsrTmrCfg.retxTimer     = macCellGroup->bsr_Config->retxBSR_Timer;
8816             if(macCellGroup->bsr_Config->logicalChannelSR_DelayTimer)
8817             {
8818                macUeCfg->macCellGrpCfg.bsrTmrCfg.srDelayTimer  =\
8819                *(macCellGroup->bsr_Config->logicalChannelSR_DelayTimer);
8820             }
8821          }
8822          if(macCellGroup->phr_Config)
8823          {
8824             if(macCellGroup->phr_Config->present == MAC_CellGroupConfig__phr_Config_PR_setup)
8825             {
8826                macUeCfg->macCellGrpCfg.phrCfgSetupPres = true;
8827                if(macCellGroup->phr_Config->choice.setup)
8828                {
8829                   macUeCfg->macCellGrpCfg.phrCfg.periodicTimer     = \
8830                   macCellGroup->phr_Config->choice.setup->phr_PeriodicTimer;
8831                   macUeCfg->macCellGrpCfg.phrCfg.prohibitTimer     = \
8832                   macCellGroup->phr_Config->choice.setup->phr_ProhibitTimer;
8833                   macUeCfg->macCellGrpCfg.phrCfg.txPowerFactor     = \
8834                   macCellGroup->phr_Config->choice.setup->phr_Tx_PowerFactorChange;
8835                   macUeCfg->macCellGrpCfg.phrCfg.multiplePHR       = \
8836                   macCellGroup->phr_Config->choice.setup->multiplePHR;
8837                   macUeCfg->macCellGrpCfg.phrCfg.dummy             = \
8838                   macCellGroup->phr_Config->choice.setup->dummy;
8839                   macUeCfg->macCellGrpCfg.phrCfg.phrType2OtherCell = \
8840                   macCellGroup->phr_Config->choice.setup->phr_Type2OtherCell;
8841                   macUeCfg->macCellGrpCfg.phrCfg.phrOtherCG        = \
8842                   macCellGroup->phr_Config->choice.setup->phr_ModeOtherCG;
8843                }
8844             }
8845          }
8846       }
8847       /* Fill Physical Cell Group Reconfig */
8848       if(cellGrp->physicalCellGroupConfig)
8849       {
8850          macUeCfg->phyCellGrpCfgPres = true;
8851          phyCellGrpCfg = ((PhysicalCellGroupConfig_t *)(cellGrp->physicalCellGroupConfig));
8852          if(phyCellGrpCfg->p_NR_FR1)
8853          {
8854             if(*(phyCellGrpCfg->p_NR_FR1) != macUeCfg->phyCellGrpCfg.pNrFr1)
8855                macUeCfg->phyCellGrpCfg.pNrFr1 = *(phyCellGrpCfg->p_NR_FR1);
8856          }
8857          macUeCfg->phyCellGrpCfg.pdschHarqAckCodebook = phyCellGrpCfg->pdsch_HARQ_ACK_Codebook;
8858       }
8859       /* Fill SpCell Reconfig */
8860       if(cellGrp->spCellConfig)
8861       {
8862          macUeCfg->spCellCfgPres = true;
8863          spcellCfg = ((SpCellConfig_t *)(cellGrp->spCellConfig));
8864          if(spcellCfg->servCellIndex)
8865          {
8866             macUeCfg->spCellCfg.servCellIdx = *(spcellCfg->servCellIndex);
8867          }
8868          /* Fill Serving cell Reconfig info */
8869          if(cellGrp->spCellConfig->spCellConfigDedicated)
8870          {
8871             servCellCfg = ((ServingCellConfig_t *)(cellGrp->spCellConfig->spCellConfigDedicated));
8872             ret = extractSpCellDedicatedCfg(servCellCfg, &macUeCfg->spCellCfg.servCellCfg);
8873             if(ret == RFAILED)
8874             {
8875                DU_LOG("\nERROR --> F1AP : Failed at extractSpCellDedicatedCfg()");
8876             }
8877          }
8878       }
8879    }
8880    return ret;
8881 }
8882 /*******************************************************************
8883 *
8884 * @brief free the memory allocated by decoder
8885 *
8886 * @details
8887 *
8888 *    Function : freeAperDecodeNrcgi
8889 *
8890 *    Functionality: Free Nrcgi values
8891 *
8892 * @params[in] NRCGI_t *nrcgi
8893 * @return void
8894 *
8895 * ****************************************************************/
8896
8897
8898 void freeAperDecodeNrcgi(NRCGI_t *nrcgi)
8899 {
8900     if(nrcgi->pLMN_Identity.buf != NULLP)
8901     {
8902        free(nrcgi->pLMN_Identity.buf);
8903     }
8904     if(nrcgi->nRCellIdentity.buf != NULLP)
8905     {
8906        free(nrcgi->nRCellIdentity.buf);
8907     }
8908 }
8909 /*******************************************************************
8910 *
8911 * @brief free the memory allocated by decoder
8912 *
8913 * @details
8914 *
8915 *    Function : freeAperDecodeCuToDuInfo
8916 *
8917 *    Functionality:  Free Cu To Du Information
8918 *
8919 * @params[in] CUtoDURRCInformation_t *rrcMsg
8920 * @return void
8921 *
8922 * ****************************************************************/
8923
8924
8925 void freeAperDecodeCuToDuInfo(CUtoDURRCInformation_t *rrcMsg)
8926 {
8927    uint8_t ieIdx =0;
8928    uint8_t arrIdx =0;
8929
8930    if(rrcMsg->uE_CapabilityRAT_ContainerList)
8931    {
8932       if(rrcMsg->uE_CapabilityRAT_ContainerList->buf)
8933          free(rrcMsg->uE_CapabilityRAT_ContainerList->buf);
8934       free(rrcMsg->uE_CapabilityRAT_ContainerList);
8935    }
8936
8937    if(rrcMsg->iE_Extensions)
8938    {
8939       if(rrcMsg->iE_Extensions->list.array)
8940       {
8941          for(ieIdx= 0; ieIdx < rrcMsg->iE_Extensions->list.count; ieIdx++)
8942          {
8943             if(rrcMsg->iE_Extensions->list.array[ieIdx])
8944             {
8945                switch(rrcMsg->iE_Extensions->list.array[ieIdx]->id)
8946                {
8947                   case ProtocolIE_ID_id_CellGroupConfig:
8948                      if(rrcMsg->iE_Extensions->list.array[ieIdx]->extensionValue.choice.CellGroupConfig.buf != NULLP)
8949                      {
8950                         free(rrcMsg->iE_Extensions->list.array[ieIdx]->extensionValue.choice.CellGroupConfig.buf);
8951                      }
8952                      break;
8953                   default:
8954                      DU_LOG("\nERROR  -->  F1AP : Invalid Event type %ld at FreeCuToDuInfo()", \
8955                            rrcMsg->iE_Extensions->list.array[ieIdx]->id);
8956                      break;
8957                }
8958             }
8959          }
8960          for(arrIdx = 0; arrIdx < ieIdx; arrIdx++)
8961          {
8962             free(rrcMsg->iE_Extensions->list.array[arrIdx]);
8963          }
8964          free(rrcMsg->iE_Extensions->list.array);
8965
8966       }
8967
8968       free(rrcMsg->iE_Extensions);
8969    }
8970 }
8971 /*******************************************************************
8972 *
8973 * @brief free the memory allocated by decoder
8974 *
8975 * @details
8976 *
8977 *    Function : freeAperDecodeSplCellList
8978 *
8979 *    Functionality: Free Spl Cell List
8980                     where memory allocated by aper_decoder
8981 *
8982 * @params[in]  SCell_ToBeSetup_List_t *spCellLst
8983 * @return void
8984 *
8985 * ****************************************************************/
8986
8987
8988 void freeAperDecodeSplCellList(SCell_ToBeSetup_List_t *spCellLst)
8989 {
8990     uint8_t  cellIdx =0;
8991
8992     if(spCellLst->list.array != NULLP)
8993     {
8994        for(cellIdx=0; cellIdx<spCellLst->list.count; cellIdx++)
8995        {
8996           if(cellIdx==0&&spCellLst->list.array[cellIdx]!=NULLP)
8997           {
8998              freeAperDecodeNrcgi(&spCellLst->list.array[cellIdx]->value.choice.SCell_ToBeSetup_Item.sCell_ID);
8999           }
9000           if(spCellLst->list.array[cellIdx]!=NULLP)
9001           {
9002              free(spCellLst->list.array[cellIdx]);
9003           }
9004        }
9005        free(spCellLst->list.array);
9006     }
9007 }
9008 /*******************************************************************
9009 *
9010 * @brief free the memory allocated by decoder
9011 *
9012 * @details
9013 *
9014 *    Function : freeAperDecodeSRBSetup
9015 *
9016 *    Functionality: added free part for the memory allocated by aper_decoder
9017 *
9018 * @params[in] SRBs_ToBeSetup_List_t *srbSet
9019 * @return void
9020 *
9021 ****************************************************************/
9022
9023
9024 void freeAperDecodeSRBSetup(SRBs_ToBeSetup_List_t *srbSet)
9025 {
9026     uint8_t srbIdx =0;
9027     if(srbSet->list.array != NULLP)
9028     {
9029        for(srbIdx=0; srbIdx<srbSet->list.count; srbIdx++)
9030        {
9031           if(srbSet->list.array[srbIdx]!=NULLP)
9032           {
9033              free(srbSet->list.array[srbIdx]);
9034           }
9035        }
9036        free(srbSet->list.array);
9037     }
9038 }
9039
9040 /*******************************************************************
9041 *
9042 * @brief free the memory allocated by decoder
9043 *
9044 * @details
9045 *
9046 *    Function : freeAperDecodeULTnlInfo
9047 *
9048 *    Functionality: added free part for the memory allocated by aper_decoder
9049 *
9050 * @params[in] ULUPTNLInformation_ToBeSetup_List_t *ulInfo
9051 * @return void
9052 *
9053 * ****************************************************************/
9054
9055
9056 void freeAperDecodeULTnlInfo(ULUPTNLInformation_ToBeSetup_List_t *ulInfo)
9057 {
9058    uint8_t ulIdx=0;
9059    if(ulInfo->list.array != NULLP)
9060    {
9061       for(ulIdx=0; ulIdx<ulInfo->list.count; ulIdx++)
9062       {
9063          if(ulIdx==0&&ulInfo->list.array[ulIdx]!=NULLP)
9064          {
9065             if(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel!=NULLP)
9066             {
9067                if(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel->\
9068                      transportLayerAddress.buf != NULLP)
9069                {
9070                   if(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf\
9071                         !=NULLP)
9072                   {
9073                      free(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf);
9074                   }
9075                   free(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel->\
9076                         transportLayerAddress.buf);
9077                }
9078                free(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel);
9079             }
9080          }
9081          if(ulInfo->list.array[ulIdx]!=NULLP)
9082          {
9083             free(ulInfo->list.array[ulIdx]);
9084          }
9085       }
9086       free(ulInfo->list.array);
9087    }
9088 }
9089 /*******************************************************************
9090 *
9091 * @brief free the memory allocated by decoder
9092 *
9093 * @details
9094 *
9095 *    Function : freeAperDecodeDRBSetup
9096 *
9097 *    Functionality: free DRBSetup which is allocated by decoder
9098 *
9099 * @params[in]  DRBs_ToBeSetup_List_t *drbSet
9100 * @return void
9101 *
9102 * ****************************************************************/
9103
9104 void freeAperDecodeDRBSetup(DRBs_ToBeSetup_List_t *drbSet)
9105 {
9106    DRBs_ToBeSetup_Item_t *drbSetItem = NULLP;
9107    uint8_t  flowIdx =0;
9108    uint8_t  drbIdx =0;
9109
9110    if(drbSet->list.array != NULLP)
9111    {
9112       for(drbIdx=0; drbIdx<drbSet->list.count; drbIdx++)
9113       {
9114          if(drbIdx==0&&drbSet->list.array[drbIdx] != NULLP)
9115          {
9116             drbSetItem =&drbSet->list.array[drbIdx]->value.choice.DRBs_ToBeSetup_Item;
9117             if(drbSetItem->qoSInformation.choice.choice_extension != NULLP)
9118             {
9119                if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
9120                      qoS_Characteristics.choice.non_Dynamic_5QI !=NULLP)
9121                {
9122                   if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
9123                         qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow!=NULLP)
9124                   {
9125                      if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
9126                            qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume!=NULLP)
9127                      {
9128
9129                         if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sST.buf!=NULLP)
9130                         {
9131
9132                            if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD!=NULLP)
9133                            {
9134
9135                               if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD->\
9136                                     buf!=NULLP)
9137                               {
9138
9139                                  if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.\
9140                                        flows_Mapped_To_DRB_List.list.array != NULLP)
9141                                  {
9142
9143                                     for(flowIdx=0;flowIdx<drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9144                                           DRB_Information.flows_Mapped_To_DRB_List.list.count; flowIdx++)
9145                                     {
9146
9147                                        if(flowIdx==0&&drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9148                                              DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]!=NULLP)
9149                                        {
9150                                           if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9151                                                 DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
9152                                                 qoSFlowLevelQoSParameters.\
9153                                                 qoS_Characteristics.choice.non_Dynamic_5QI!=NULLP)
9154                                           {
9155                                              if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9156                                                    DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
9157                                                    qoSFlowLevelQoSParameters.\
9158                                                    qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow!=NULLP)
9159                                              {
9160
9161                                                 if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9162                                                       DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
9163                                                       qoSFlowLevelQoSParameters.\
9164                                                       qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume!=NULLP)
9165                                                 {
9166
9167
9168                                                    free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9169                                                          DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
9170                                                          qoSFlowLevelQoSParameters.\
9171                                                          qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume);
9172                                                 }
9173
9174                                                 free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9175                                                       DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
9176                                                       qoSFlowLevelQoSParameters.\
9177                                                       qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow);
9178                                              }
9179
9180                                              free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9181
9182                                                    DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
9183                                                    qoSFlowLevelQoSParameters.\
9184                                                    qoS_Characteristics.choice.non_Dynamic_5QI);
9185                                           }
9186                                        }
9187                                        if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9188                                              DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]!=NULLP)
9189                                        {
9190
9191                                           free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9192                                                 DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]);
9193                                        }
9194                                     }
9195
9196                                     free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9197                                           DRB_Information.flows_Mapped_To_DRB_List.list.array);
9198                                  }
9199
9200                                  free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9201                                        DRB_Information.sNSSAI.sD->buf);
9202                               }
9203
9204                               free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD);
9205                            }
9206
9207                            free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sST.buf);
9208
9209                         }
9210
9211                         free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
9212
9213                               qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume);
9214                      }
9215
9216                      free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
9217                            qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow);
9218                   }
9219
9220                   free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
9221                         qoS_Characteristics.choice.non_Dynamic_5QI);
9222                }
9223                free(drbSetItem->qoSInformation.choice.choice_extension);
9224             }
9225             freeAperDecodeULTnlInfo(&drbSetItem->uLUPTNLInformation_ToBeSetup_List);
9226             if(drbSetItem->uLConfiguration)
9227             {
9228                free(drbSetItem->uLConfiguration);
9229             }
9230          }
9231          if(drbSet->list.array[drbIdx]!=NULLP)
9232          {
9233             free(drbSet->list.array[drbIdx]);
9234          }
9235       }
9236       free(drbSet->list.array);
9237    }
9238 }
9239
9240
9241 /*******************************************************************
9242  *
9243  * @brief builds Mac Cell Cfg
9244  *
9245  * @details
9246  *
9247  *    Function : procUeReCfgCellInfo
9248  *
9249  *    Functionality: builds Mac Cell Cfg
9250  *
9251  * @params[in] MacUeCfg pointer
9252  *             void pointer
9253  *
9254  * @return void
9255  *
9256  * ****************************************************************/
9257 uint8_t procUeReCfgCellInfo(MacUeCfg *macUeCfg, void *cellInfo)
9258 {
9259    uint8_t ret = ROK;
9260    CellGroupConfigRrc_t *cellGrp = NULLP;
9261
9262    if(cellInfo)
9263    {
9264       cellGrp = (CellGroupConfigRrc_t *)cellInfo;
9265       ret = extractUeReCfgCellInfo(cellGrp, macUeCfg);
9266       if(ret == RFAILED)
9267          DU_LOG("\nERROR  -->  F1AP : Failed at procUeReCfgCellInfo()");
9268    }
9269    if(ret == RFAILED)
9270    {
9271       freeUeReCfgCellGrpInfo(macUeCfg);
9272    }
9273    return ret;
9274 }
9275
9276 /*******************************************************************
9277  *
9278  * @brief Filling modulation info in mac ue cfg
9279  *
9280  * @details
9281  *
9282  *    Function : duFillModulationDetails
9283  *
9284  *    Functionality: Filling modulation info in mac ue cfg
9285  *
9286  * @params[in] MAC UE Config to be updated
9287  *             Current UE configuration
9288  *             UE NR capability from CU
9289  * @return ROK     - success
9290  *         RFAILED - failure
9291  *
9292  * ****************************************************************/
9293 void duFillModulationDetails(MacUeCfg *ueCfg, MacUeCfg *oldUeCfg, void *ueCap)
9294 {
9295    UE_NR_Capability_t *ueNrCap;
9296
9297    if(ueCap)
9298       ueNrCap = (UE_NR_Capability_t *)ueCap;
9299
9300    /* Filling DL modulation info */
9301    if(ueNrCap->featureSets && ueNrCap->featureSets->featureSetsDownlinkPerCC && \
9302          ueNrCap->featureSets->featureSetsDownlinkPerCC->list.array[0] && \
9303          ueNrCap->featureSets->featureSetsDownlinkPerCC->list.array[0]->supportedModulationOrderDL)
9304    {
9305       switch(*(ueNrCap->featureSets->featureSetsDownlinkPerCC->list.array[0]->supportedModulationOrderDL))
9306       {
9307          case ModulationOrder_qpsk:
9308             {
9309                ueCfg->dlModInfo.modOrder = MOD_ORDER_QPSK;
9310                break;
9311             }
9312          case ModulationOrder_qam16:
9313             {
9314                ueCfg->dlModInfo.modOrder = MOD_ORDER_QAM16;
9315                break;
9316             }
9317          case ModulationOrder_qam64:
9318             {
9319                ueCfg->dlModInfo.modOrder = MOD_ORDER_QAM64;
9320                ueCfg->dlModInfo.mcsIndex = PDSCH_MCS_INDEX;
9321                ueCfg->dlModInfo.mcsTable = MCS_TABLE_QAM64;
9322                break;
9323             }
9324          case ModulationOrder_qam256:
9325             {
9326                ueCfg->dlModInfo.modOrder = MOD_ORDER_QAM256;
9327                break;
9328             }
9329          default:
9330             {
9331                DU_LOG("\nERROR  -->  DU APP: Incorrect downlink modulation order received. Reatining old modulation configuration");
9332                memcpy(&ueCfg->dlModInfo, &oldUeCfg->dlModInfo, sizeof(ModulationInfo));
9333                break;
9334             }
9335       }
9336    }
9337    else
9338    {
9339       memcpy(&ueCfg->dlModInfo, &oldUeCfg->dlModInfo, sizeof(ModulationInfo));
9340    }
9341
9342    /* Filling UL modulation info */
9343    if(ueNrCap->featureSets && ueNrCap->featureSets->featureSetsUplinkPerCC && \
9344          ueNrCap->featureSets->featureSetsUplinkPerCC->list.array[0] && \
9345          ueNrCap->featureSets->featureSetsUplinkPerCC->list.array[0]->supportedModulationOrderUL)
9346    {
9347       switch(*(ueNrCap->featureSets->featureSetsUplinkPerCC->list.array[0]->supportedModulationOrderUL))
9348       {
9349          case ModulationOrder_qpsk:
9350             {
9351                ueCfg->ulModInfo.modOrder = MOD_ORDER_QPSK;
9352                break;
9353             }
9354          case ModulationOrder_qam16:
9355             {
9356                ueCfg->ulModInfo.modOrder = MOD_ORDER_QAM16;
9357                ueCfg->ulModInfo.mcsIndex = PUSCH_MCS_INDEX;
9358                ueCfg->ulModInfo.mcsTable = MCS_TABLE_QAM64;
9359                break;
9360             }
9361          case ModulationOrder_qam64:
9362             {
9363                ueCfg->ulModInfo.modOrder = MOD_ORDER_QAM64;
9364                break;
9365             }
9366          case ModulationOrder_qam256:
9367             {
9368                ueCfg->ulModInfo.modOrder = MOD_ORDER_QAM256;
9369                break;
9370             }
9371          default:
9372             {
9373                DU_LOG("\nERROR  -->  DU APP: Incorrect uplink modulation order received. Reatining old modulation configuration");
9374                memcpy(&ueCfg->ulModInfo, &oldUeCfg->ulModInfo, sizeof(ModulationInfo));
9375                break;
9376             }
9377       }
9378    }
9379    else
9380    {
9381       memcpy(&ueCfg->ulModInfo, &oldUeCfg->ulModInfo, sizeof(ModulationInfo));
9382    }
9383 }
9384
9385 /*******************************************************************
9386  *
9387  * @brief Function to extract cellGrp Info present in cutoDu cont
9388  *
9389  * @details
9390  *
9391  *    Function : extractCellGrpInfo
9392  *
9393  *    Functionality: Function to extract cellGrp Info present
9394  *                   in cutoDu cont
9395  *
9396  * @params[in] ProtocolExtensionContainer_4624P16_t pointer
9397  *
9398  * @return CellGroupConfigRrc_t *
9399  *
9400  * ****************************************************************/
9401
9402 CellGroupConfigRrc_t *extractCellGrpInfo(ProtocolExtensionContainer_4624P16_t *protocolIeExtn,\
9403       DuUeCfg *ueCfgDb)
9404 {
9405    uint8_t idx2 =0;
9406    uint16_t id =0;
9407    uint16_t recvBufLen =0;
9408    CellGroupConfigRrc_t *cellGrpCfg = NULLP;
9409    CUtoDURRCInformation_ExtIEs_t *extIeInfo = NULLP;
9410    asn_dec_rval_t rval; /* Decoder return value */
9411    memset(&rval, 0, sizeof(asn_dec_rval_t));
9412
9413    if(protocolIeExtn)
9414    {
9415       for(idx2 = 0; idx2 < protocolIeExtn->list.count; idx2++)
9416       {
9417          extIeInfo = ((CUtoDURRCInformation_ExtIEs_t *)(protocolIeExtn->list.array[idx2]));
9418          id = extIeInfo->id;
9419          switch(id)
9420          {
9421             case ProtocolIE_ID_id_CellGroupConfig:
9422             {
9423                recvBufLen = extIeInfo->extensionValue.choice.CellGroupConfig.size;
9424                /* decoding the CellGroup Buf received */
9425                DU_ALLOC(cellGrpCfg, sizeof(CellGroupConfigRrc_t));
9426                if(cellGrpCfg)
9427                {
9428                   memset(cellGrpCfg, 0, sizeof(CellGroupConfigRrc_t));
9429                   rval = aper_decode(0, &asn_DEF_CellGroupConfigRrc, (void **)&cellGrpCfg,
9430                      extIeInfo->extensionValue.choice.CellGroupConfig.buf, recvBufLen, 0, 0);
9431                   if(rval.code == RC_FAIL || rval.code == RC_WMORE)
9432                   {
9433                      DU_LOG("\nERROR  -->  F1AP : ASN decode failed at decodeCellGrpCfg()");
9434                      return NULLP;
9435                   }
9436                   xer_fprint(stdout, &asn_DEF_CellGroupConfigRrc, cellGrpCfg);
9437                   if(extractRlcCfgToAddMod(cellGrpCfg->rlc_BearerToAddModList, ueCfgDb))
9438                      return NULLP;
9439                }
9440                break;
9441             }
9442             default:
9443                DU_LOG("\nERROR  -->  F1AP : Invalid IE received CUtoDURRCInformation:%d at decodeCellGrpCfg()", id);
9444                break;
9445          }
9446       }
9447    }
9448    return cellGrpCfg;
9449 }
9450
9451 /*******************************************************************
9452  *
9453  * @brief Fills Srb List received by CU
9454  *
9455  * @details
9456  *
9457  *    Function : procSrbListToSetup
9458  *
9459  *    Functionality: Fills Srb List received  by CU
9460  *
9461  * @params[in] SRBs_ToBeSetup_Item_t *cuSrbItem
9462  *             LcCfg pointer
9463  *             RlcBearerCfg pointer
9464  * @return void
9465  *
9466  * ****************************************************************/
9467 uint8_t procSrbListToSetup(SRBs_ToBeSetup_Item_t * srbItem, LcCfg *macLcToAdd, RlcBearerCfg *rlcLcToAdd)
9468 {
9469    uint8_t ret = ROK;
9470
9471    /* Filling RLC INFO */
9472    procRlcLcCfg(srbItem->sRBID, srbItem->sRBID, RB_TYPE_SRB, RLC_AM, CONFIG_ADD, NULL, rlcLcToAdd);
9473
9474    /* Filling MAC INFO */
9475    ret = procMacLcCfg(srbItem->sRBID, RB_TYPE_SRB, CONFIG_ADD, NULL,NULL, NULL, macLcToAdd, NULL);
9476    if(ret == RFAILED)
9477    {
9478       DU_LOG("\nERROR  -->  F1AP : Failed at MAC LC Cfg in procSrbListToSetup()");
9479       return ret;
9480    }
9481    return ret;
9482 }
9483
9484
9485
9486 /*******************************************************************
9487  *
9488  * @brief extract Srb List received by CU
9489  *
9490  * @details
9491  *
9492  *    Function : extractSrbListToSetup
9493  *
9494  *    Functionality: extract Srb List received by CU
9495  *                   for both MAC and RLC
9496  *
9497  * @params[in] SRBs_ToBeSetup_Item_t pointer
9498  *             DuUeCfg pointer
9499  * @return ROK/RFAIED
9500  *
9501  * ****************************************************************/
9502
9503 uint8_t extractSrbListToSetup(SRBs_ToBeSetup_List_t *srbCfg, DuUeCfg *ueCfgDb)
9504 {
9505    uint8_t ret, srbIdx;
9506    SRBs_ToBeSetup_Item_t *srbItem = NULLP;
9507
9508    if(srbCfg)
9509    {
9510       for(srbIdx = 0; srbIdx < srbCfg->list.count; srbIdx++)
9511       {
9512          srbItem = &srbCfg->list.array[srbIdx]->value.choice.SRBs_ToBeSetup_Item;
9513          if(ueCfgDb->numMacLcs > MAX_NUM_LC)
9514          {
9515             DU_LOG("\nERROR   -->  F1AP:  MAX LC Reached in MAC");
9516             ret = RFAILED;
9517             break;
9518          }
9519          if(ueCfgDb->numRlcLcs > MAX_NUM_LC)
9520          {
9521             DU_LOG("\nERROR   -->  F1AP:  MAX LC Reached in RLC");
9522             ret = RFAILED;
9523             break;
9524          }
9525          memset(&ueCfgDb->macLcCfg[ueCfgDb->numMacLcs], 0, sizeof(LcCfg));
9526          memset(&ueCfgDb->rlcLcCfg[ueCfgDb->numRlcLcs], 0, sizeof(RlcBearerCfg));
9527          ret = procSrbListToSetup(srbItem, &ueCfgDb->macLcCfg[ueCfgDb->numMacLcs],\
9528             &ueCfgDb->rlcLcCfg[ueCfgDb->numRlcLcs]);
9529          ueCfgDb->numRlcLcs++;
9530          ueCfgDb->numMacLcs++;
9531          if(ret == RFAILED)
9532          {
9533             DU_LOG("\nERROR  -->  F1AP:  Failed at extractSrbListToSetup()");
9534             break;
9535          }
9536       }
9537    }
9538    else
9539       ret = RFAILED;
9540
9541    return ret;
9542 }
9543
9544 /*******************************************************************
9545  *
9546  * @brief Fills Drb List received by CU
9547  *
9548  * @details
9549  *
9550  *    Function : procDrbListToSetup
9551  *
9552  *    Functionality: Fills Drb List received by CU
9553  *                   for both MAC and RLC
9554  *
9555  * @params[in] SRBs_ToBeSetup_Item_t pointer
9556  *             LcCfg pointer,
9557  *             RlcBearerCfg pointer
9558  * @return void
9559  *
9560  * ****************************************************************/
9561
9562 uint8_t procDrbListToSetup(uint8_t lcId, DRBs_ToBeSetup_Item_t *drbItem,\
9563 DRBs_ToBeSetupMod_Item_t *drbSetupModItem, LcCfg *macLcToAdd, RlcBearerCfg *rlcLcToAdd, UpTnlCfg *upTnlInfo)
9564 {
9565
9566    if(drbItem != NULLP)
9567    {
9568       /* Filling RLC INFO */
9569       procRlcLcCfg(drbItem->dRBID, lcId, RB_TYPE_DRB, drbItem->rLCMode, CONFIG_ADD, NULL, rlcLcToAdd);
9570
9571       /* Filling MAC INFO */
9572       if(procMacLcCfg(lcId, RB_TYPE_DRB, CONFIG_ADD, drbItem, NULL, NULL, macLcToAdd, upTnlInfo) != ROK)
9573       {
9574          DU_LOG("\nERROR  --> F1AP : Failed at RLC LC Cfg in procDrbListToSetup()");
9575          return RFAILED;
9576       }
9577    }
9578    else if(drbSetupModItem != NULLP)
9579    {
9580       procRlcLcCfg(drbSetupModItem->dRBID, lcId, RB_TYPE_DRB, drbSetupModItem->rLCMode, CONFIG_ADD, NULL, rlcLcToAdd);
9581
9582       if(procMacLcCfg(lcId, RB_TYPE_DRB, CONFIG_ADD, NULL, drbSetupModItem, NULL, macLcToAdd, upTnlInfo) != ROK)
9583       {
9584          DU_LOG("\nERROR  --> F1AP : Failed at RLC LC Cfg in procDrbListToSetup()");
9585          return RFAILED;
9586       }
9587    }
9588    return ROK;
9589 }
9590
9591 /*******************************************************************
9592  *
9593  * @brief extract Drb List received by CU
9594  *
9595  * @details
9596  *
9597  *    Function : extractDrbListToSetup
9598  *
9599  *    Functionality: extract Drb List received by CU
9600  *                   for both MAC and RLC
9601  *
9602  * @params[in] DRBs_ToBeSetup_Item_t pointer
9603  *             DuUeCfg pointer
9604  * @return ROK/RFAIED
9605  *
9606  * ****************************************************************/
9607
9608 uint8_t extractDrbListToSetup(uint8_t lcId, DRBs_ToBeSetup_List_t *drbCfg,DRBs_ToBeSetupMod_List_t *drbSetupModCfg,\
9609 uint8_t drbCount, DuUeCfg *ueCfgDb)
9610 {
9611    uint8_t ret, drbIdx;
9612    DRBs_ToBeSetup_Item_t *drbItem = NULLP;
9613    DRBs_ToBeSetupMod_ItemIEs_t *drbSetupModItem = NULLP;
9614
9615    ret = ROK;
9616    if(drbCount > 0)
9617    {
9618       for(drbIdx = 0; drbIdx < drbCount; drbIdx++)
9619       {
9620          if(ueCfgDb->numMacLcs > MAX_NUM_LC)
9621          {
9622             DU_LOG("\nERROR  -->  F1AP :  MAX LC Reached in MAC at extractDrbListToSetup()");
9623             ret = RFAILED;
9624             break;
9625          }
9626          if(ueCfgDb->numRlcLcs > MAX_NUM_LC)
9627          {
9628             DU_LOG("\nERROR  -->  F1AP :  MAX LC Reached in RLC at extractDrbListToSetup()");
9629             ret = RFAILED;
9630             break;
9631          }
9632          memset(&ueCfgDb->macLcCfg[ueCfgDb->numMacLcs], 0, sizeof(LcCfg));
9633          memset(&ueCfgDb->rlcLcCfg[ueCfgDb->numRlcLcs], 0, sizeof(RlcBearerCfg));
9634
9635          if(drbCfg != NULL)
9636          {
9637             drbItem = &drbCfg->list.array[drbIdx]->value.choice.DRBs_ToBeSetup_Item;
9638             ret = procDrbListToSetup(lcId, drbItem, NULL, &ueCfgDb->macLcCfg[ueCfgDb->numMacLcs],\
9639                &ueCfgDb->rlcLcCfg[ueCfgDb->numRlcLcs], &ueCfgDb->upTnlInfo[ueCfgDb->numDrb]);
9640             if(ret == RFAILED)
9641             {
9642                DU_LOG("\nERROR  --> F1AP : Failed at extractDrbListToSetup()");
9643                break;
9644             }
9645          }
9646          else if(drbSetupModCfg != NULL)
9647          {
9648             drbSetupModItem = (DRBs_ToBeSetupMod_ItemIEs_t *) drbSetupModCfg->list.array[drbIdx];
9649             ret = procDrbListToSetup(lcId, NULL, &(drbSetupModItem->value.choice.DRBs_ToBeSetupMod_Item) ,\
9650             &ueCfgDb->macLcCfg[ueCfgDb->numMacLcs], &ueCfgDb->rlcLcCfg[ueCfgDb->numRlcLcs],\
9651             &ueCfgDb->upTnlInfo[ueCfgDb->numDrb]);
9652             if(ret == RFAILED)
9653             {
9654                DU_LOG("\nERROR  --> F1AP : Failed at extractDrbListToSetup()");
9655                break;
9656             }
9657          }
9658          ueCfgDb->numRlcLcs++;
9659          ueCfgDb->numMacLcs++;
9660          ueCfgDb->numDrb++;
9661          if(ret == RFAILED)
9662          {
9663             DU_LOG("\nERROR  --> F1AP : Failed at extractDrbListToSetup()");
9664             break;
9665          }
9666       }
9667    }
9668    else
9669       ret = RFAILED;
9670
9671    return ret;
9672 }
9673
9674 /*******************************************************************
9675  *
9676  * @brief Function to extract Dl RRC Msg received from CU
9677  *
9678  * @details
9679  *
9680  *    Function : extractDlRrcMsg
9681  *
9682  *    Functionality: Function to extract Dl RRC Msg received from CU
9683  *
9684  * @params[in] F1AP message
9685  * @return ROK     - success
9686  *         RFAILED - failure
9687  *
9688  * ****************************************************************/
9689
9690 uint8_t extractDlRrcMsg(uint32_t gnbDuUeF1apId, uint32_t gnbCuUeF1apId, \
9691    F1DlRrcMsg *dlRrcMsg, RRCContainer_t *rrcContainer)
9692 {
9693    uint8_t ret = ROK;
9694    dlRrcMsg->rrcMsgSize = rrcContainer->size;
9695    if(dlRrcMsg->rrcMsgSize > 0)
9696    {
9697       DU_ALLOC_SHRABL_BUF(dlRrcMsg->rrcMsgPdu, dlRrcMsg->rrcMsgSize);
9698       if(!dlRrcMsg->rrcMsgPdu)
9699       {
9700          DU_LOG("\nERROR  --> DU APP : Memory allocation failed for RRC Msg in extractDlRrcMsg()");
9701          ret = RFAILED;
9702       }
9703       else
9704       {
9705          dlRrcMsg->gnbDuUeF1apId = gnbDuUeF1apId;
9706          dlRrcMsg->gnbCuUeF1apId = gnbCuUeF1apId;
9707          dlRrcMsg->srbId = SRB1_LCID;
9708          memcpy(dlRrcMsg->rrcMsgPdu, rrcContainer->buf, dlRrcMsg->rrcMsgSize);
9709       }
9710    }
9711    return ret;
9712 }
9713
9714 /*******************************************************************
9715  *
9716  * @brief Extract UE capability info
9717  *
9718  * @details
9719  *
9720  *    Function : extractUeCapability
9721  *
9722  *    Functionality: Extract UE capability info and stores in ue Cb
9723  *
9724  * @params[in] Octet string of UE capability RAT container list
9725  * @return ROK     - success
9726  *         RFAILED - failure
9727  *
9728  * ****************************************************************/
9729 UE_NR_Capability_t *extractUeCapability(UE_CapabilityRAT_ContainerList_t *ueCapablityListBuf, DuUeCb *ueCb)
9730 {
9731    uint8_t  idx;
9732    uint16_t recvBufLen;
9733    asn_dec_rval_t rval;
9734    UE_NR_Capability_t  *ueNrCap = NULLP;
9735    UE_CapabilityRAT_ContainerListRRC_t  *ueCapRatContList = NULLP;
9736
9737    /* Decoding UE Capability RAT Container List */
9738    recvBufLen = ueCapablityListBuf->size;
9739    DU_ALLOC(ueCapRatContList, sizeof(UE_CapabilityRAT_ContainerListRRC_t));
9740    if(!ueCapRatContList)
9741    {
9742       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in extractUeCapability");
9743       return NULLP;
9744    }
9745    memset(ueCapRatContList, 0, sizeof(UE_CapabilityRAT_ContainerListRRC_t));
9746    memset(&rval, 0, sizeof(asn_dec_rval_t));
9747    rval = aper_decode(0, &asn_DEF_UE_CapabilityRAT_ContainerListRRC, (void **)&ueCapRatContList,
9748           ueCapablityListBuf->buf, recvBufLen, 0, 0);
9749    if(rval.code == RC_FAIL || rval.code == RC_WMORE)
9750    {
9751       DU_LOG("\nERROR  -->  F1AP : ASN decode failed at decodeCellGrpCfg()");
9752       return NULLP;
9753    }
9754    xer_fprint(stdout, &asn_DEF_UE_CapabilityRAT_ContainerListRRC, ueCapRatContList);
9755
9756    /* Free encoded buffer after decoding */
9757
9758    for(idx = 0; idx < ueCapRatContList->list.count; idx++)
9759    {
9760       if(ueCapRatContList->list.array[idx]->rat_Type == RAT_Type_nr)
9761       {
9762          /* Decoding UE NR Capability */
9763           recvBufLen = ueCapRatContList->list.array[idx]->ue_CapabilityRAT_Container.size;
9764           DU_ALLOC(ueNrCap, sizeof(UE_NR_Capability_t));
9765           if(!ueNrCap)
9766           {
9767              DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in extractUeCapability");
9768              DU_FREE(ueCapRatContList, sizeof(UE_CapabilityRAT_ContainerListRRC_t));
9769              return NULLP;
9770           }
9771           memset(ueNrCap, 0, sizeof(UE_NR_Capability_t));
9772           memset(&rval, 0, sizeof(asn_dec_rval_t));
9773           rval = aper_decode(0, &asn_DEF_UE_NR_Capability, (void **)&ueNrCap,
9774                  ueCapRatContList->list.array[idx]->ue_CapabilityRAT_Container.buf, recvBufLen, 0, 0);
9775           if(rval.code == RC_FAIL || rval.code == RC_WMORE)
9776           {
9777              DU_LOG("\nERROR  -->  F1AP : ASN decode failed at decodeCellGrpCfg()");
9778              return NULLP;
9779           }
9780           xer_fprint(stdout, &asn_DEF_UE_NR_Capability, ueNrCap);
9781
9782           /* Free encoded buffer after decoding */
9783           free(ueCapRatContList->list.array[idx]->ue_CapabilityRAT_Container.buf);
9784       }
9785       free(ueCapRatContList->list.array[idx]);
9786    }
9787
9788    /* Free Memory*/
9789    free(ueCapRatContList->list.array);
9790    DU_FREE(ueCapRatContList, sizeof(UE_CapabilityRAT_ContainerListRRC_t));
9791    return ueNrCap;
9792 }
9793
9794 /*******************************************************************
9795 *
9796 * @brief free UE context setup request from CU
9797 *
9798 * @details
9799 *
9800 *    Function : freeAperDecodeF1UeContextSetupReq
9801 *
9802 *    Functionality: freeing part for the memory allocated by aper_decoder
9803 *
9804 * @params[in] F1AP message
9805 * @return ROK     - success
9806 *         RFAILED - failure
9807 *
9808 * ****************************************************************/
9809 void freeAperDecodeF1UeContextSetupReq(UEContextSetupRequest_t   *ueSetReq)
9810 {
9811    uint8_t ieIdx = 0;
9812
9813    if(ueSetReq->protocolIEs.list.array != NULLP)
9814    {
9815       for(ieIdx = 0; ieIdx < ueSetReq->protocolIEs.list.count; ieIdx++)
9816       {
9817          if(ueSetReq->protocolIEs.list.array[ieIdx])
9818          {
9819             switch(ueSetReq->protocolIEs.list.array[ieIdx]->id)
9820             {
9821                case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
9822                   break;
9823                case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
9824                   break;
9825                case ProtocolIE_ID_id_SpCell_ID:
9826                   freeAperDecodeNrcgi(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.NRCGI);
9827                   break;
9828                case ProtocolIE_ID_id_ServCellIndex:
9829                   break;
9830                case ProtocolIE_ID_id_SpCellULConfigured:
9831                   break;
9832                case ProtocolIE_ID_id_CUtoDURRCInformation:
9833
9834                   freeAperDecodeCuToDuInfo(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.CUtoDURRCInformation);
9835                   break;
9836                case ProtocolIE_ID_id_SCell_ToBeSetup_List:
9837
9838                   freeAperDecodeSplCellList(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.SCell_ToBeSetup_List);
9839                   break;
9840                case ProtocolIE_ID_id_SRBs_ToBeSetup_List:
9841
9842                   freeAperDecodeSRBSetup(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.SRBs_ToBeSetup_List);
9843                   break;
9844                case ProtocolIE_ID_id_DRBs_ToBeSetup_List:
9845
9846                   freeAperDecodeDRBSetup(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.DRBs_ToBeSetup_List);
9847                   break;
9848                case ProtocolIE_ID_id_RRCContainer:
9849                   {
9850
9851                      if(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf != NULLP)
9852                      {
9853
9854                         free(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf);
9855                      }
9856                      break;
9857                   }
9858                case ProtocolIE_ID_id_RRCDeliveryStatusRequest:
9859                   break;
9860                case ProtocolIE_ID_id_GNB_DU_UE_AMBR_UL:
9861                   {
9862                      if(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.BitRate.buf)
9863                      {
9864                         free(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.BitRate.buf);
9865                      }
9866                      break;
9867                   }
9868                default:
9869                   DU_LOG("\nERROR  -->  F1AP: Invalid event type %ld " ,ueSetReq->protocolIEs.list.array[ieIdx]->id);
9870             }
9871             free(ueSetReq->protocolIEs.list.array[ieIdx]);
9872          }
9873       }
9874       free(ueSetReq->protocolIEs.list.array);
9875    }
9876 }
9877 /*******************************************************************
9878  *
9879  * @brief Process UE context setup request from CU
9880  *
9881  * @details
9882  *
9883  *    Function : procF1UeContextSetupReq
9884  *
9885  *    Functionality: Process UE context setup request from CU
9886  *
9887  * @params[in] F1AP message
9888  * @return ROK     - success
9889  *         RFAILED - failure
9890  *
9891  * ****************************************************************/
9892 uint8_t procF1UeContextSetupReq(F1AP_PDU_t *f1apMsg)
9893 {
9894    uint8_t  ret=0, ieIdx=0, ueIdx=0, lcId=0, cellIdx=0;
9895    bool ueCbFound = false;
9896    uint32_t gnbCuUeF1apId=0, gnbDuUeF1apId=0, bitRateSize=0;
9897    DuUeCb   *duUeCb = NULL;
9898    UEContextSetupRequest_t   *ueSetReq = NULL;
9899    DRBs_ToBeSetup_List_t *drbCfg = NULL;
9900
9901    ret = ROK;
9902
9903    ueSetReq = &f1apMsg->choice.initiatingMessage->value.choice.UEContextSetupRequest;
9904    for(ieIdx=0; (ieIdx < ueSetReq->protocolIEs.list.count && ret == ROK); ieIdx++)
9905    {
9906       switch(ueSetReq->protocolIEs.list.array[ieIdx]->id)
9907       {
9908          case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
9909             {
9910                gnbCuUeF1apId = ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID;
9911                break;
9912             }
9913          case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
9914             {
9915                gnbDuUeF1apId = ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID;
9916                break;
9917             }
9918          case ProtocolIE_ID_id_ServCellIndex:
9919             {
9920                cellIdx = ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.ServCellIndex;
9921                for(ueIdx = 0; ueIdx < MAX_NUM_UE; ueIdx++)
9922                {
9923                   if((duCb.actvCellLst[cellIdx]->ueCb[ueIdx].gnbDuUeF1apId == gnbDuUeF1apId)&&\
9924                         (duCb.actvCellLst[cellIdx]->ueCb[ueIdx].gnbCuUeF1apId == gnbCuUeF1apId))
9925                   {
9926                      ueCbFound = true;
9927                      duUeCb = &duCb.actvCellLst[cellIdx]->ueCb[ueIdx];
9928                      DU_ALLOC(duUeCb->f1UeDb, sizeof(F1UeContextSetupDb));
9929                      if(duUeCb->f1UeDb)
9930                      {
9931                         memset(duUeCb->f1UeDb, 0, sizeof(F1UeContextSetupDb));
9932                         duUeCb->f1UeDb->actionType = UE_CTXT_SETUP;
9933                         duUeCb->f1UeDb->cellIdx = cellIdx;
9934                      }
9935                      else
9936                      {
9937                         DU_LOG("\nERROR  -->  F1AP: Memory Alloc Failed at procF1UeContextSetupReq()");
9938                         ret = RFAILED;
9939                      }
9940                   }
9941                   else
9942                      ueCbFound = false;
9943
9944                }
9945                if(!ueCbFound)
9946                {
9947                   DU_LOG("\nERROR  -->  F1AP: DuUeCb is not found at procF1UeContextSetupReq()");
9948                   ret = RFAILED;
9949                }
9950                break;
9951             }
9952          case ProtocolIE_ID_id_SpCellULConfigured:
9953             /* Indicates whether the gNB-CU requests the gNB-DU to configure the uplink as no UL,
9954                UL, SUL or UL+SUL for the indicated cell for the UE */
9955             break;
9956          case ProtocolIE_ID_id_CUtoDURRCInformation:
9957             {
9958                if(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.CUtoDURRCInformation.uE_CapabilityRAT_ContainerList)
9959                {
9960                   duUeCb->f1UeDb->duUeCfg.ueNrCapability = \
9961                   extractUeCapability(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.CUtoDURRCInformation.\
9962                   uE_CapabilityRAT_ContainerList, duUeCb);
9963                }
9964                if(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.CUtoDURRCInformation.iE_Extensions)
9965                {
9966                   duUeCb->f1UeDb->duUeCfg.cellGrpCfg = extractCellGrpInfo(ueSetReq->protocolIEs.list.array[ieIdx]->\
9967                         value.choice.CUtoDURRCInformation.iE_Extensions, &duUeCb->f1UeDb->duUeCfg);
9968                   if(!duUeCb->f1UeDb->duUeCfg.cellGrpCfg)
9969                   {
9970                      DU_LOG("\nERROR  -->  F1AP: Failed to extract cell Grp Info");
9971                      //TODO: Update the failure cause in ue context Setup Response
9972                      ret = RFAILED;
9973                   }
9974                }
9975                break;
9976             }
9977          case ProtocolIE_ID_id_SCell_ToBeSetup_List:
9978             {
9979                DU_LOG("\nINFO   -->  DU_APP: Received SCell_ToBeSetup_List but  Not processing the list");
9980                break;
9981             }
9982          case ProtocolIE_ID_id_SRBs_ToBeSetup_List:
9983             {
9984                if(extractSrbListToSetup(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.SRBs_ToBeSetup_List,\
9985                &duUeCb->f1UeDb->duUeCfg))
9986                {
9987                   DU_LOG("\nERROR  -->  DU APP : Failed at extractSrbListToSetup()");
9988                   //TODO: Update the failure cause in ue context Setup Response
9989                   ret = RFAILED;
9990                }
9991                break;
9992             }
9993          case ProtocolIE_ID_id_DRBs_ToBeSetup_List:
9994             {
9995                lcId = getDrbLcId(&duUeCb->drbBitMap);
9996                if(lcId != RFAILED)
9997                {
9998                   drbCfg = &ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.DRBs_ToBeSetup_List;
9999                   if(extractDrbListToSetup(lcId, drbCfg, NULL, drbCfg->list.count, &duUeCb->f1UeDb->duUeCfg))
10000                   {
10001                      DU_LOG("\nERROR  -->  DU APP : Failed at extractDrbListToSetup()");
10002                      //TODO: Update the failure cause in ue context Setup Response
10003                      ret = RFAILED;
10004                   }
10005                }
10006                else
10007                   ret = RFAILED;
10008                break;
10009             }
10010          case ProtocolIE_ID_id_RRCContainer:
10011             {
10012                /* Filling Dl RRC Msg Info */
10013                DU_ALLOC_SHRABL_BUF(duUeCb->f1UeDb->dlRrcMsg, sizeof(F1DlRrcMsg));
10014                if(!duUeCb->f1UeDb->dlRrcMsg)
10015                {
10016                   DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for DL RRC Msg in procUeCtxtSetupReq()");
10017                   ret = RFAILED;
10018                }
10019                else
10020                {
10021                   duUeCb->f1UeDb->dlRrcMsgPres = true;
10022                   memset(duUeCb->f1UeDb->dlRrcMsg, 0, sizeof(F1DlRrcMsg));
10023                   ret = extractDlRrcMsg(gnbDuUeF1apId, gnbCuUeF1apId, duUeCb->f1UeDb->dlRrcMsg,\
10024                         &ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer);
10025                }
10026                break;
10027             }
10028          case ProtocolIE_ID_id_RRCDeliveryStatusRequest:
10029             {
10030                if(duUeCb->f1UeDb->dlRrcMsg->rrcMsgPdu)
10031                {
10032                   duUeCb->f1UeDb->dlRrcMsg->deliveryStatRpt = true;
10033                }
10034                else
10035                {
10036                   DU_LOG("\nERROR  -->  Ignoring delivery report, since rrcContainer is not present");
10037                }
10038                break;
10039             }
10040          case ProtocolIE_ID_id_GNB_DU_UE_AMBR_UL:
10041             {
10042                /* MaximumBitRate Uplink */
10043                bitRateSize = ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.BitRate.size;
10044                if(bitRateSize > 0)
10045                {
10046                   DU_ALLOC_SHRABL_BUF(duUeCb->f1UeDb->duUeCfg.ambrCfg, bitRateSize);
10047                   if(!duUeCb->f1UeDb->duUeCfg.ambrCfg)
10048                   {
10049                      DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for bitRate in procUeCtxtSetupReq");
10050                      ret = RFAILED;
10051                   }
10052                   else
10053                   {
10054                      memset(duUeCb->f1UeDb->duUeCfg.ambrCfg, 0, sizeof(AmbrCfg));
10055                      memcpy(&duUeCb->f1UeDb->duUeCfg.ambrCfg->ulBr,
10056                            ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.BitRate.buf, bitRateSize);
10057                   }
10058                }
10059                else
10060                   ret = RFAILED;
10061                break;
10062             }
10063          default:
10064             {
10065                break;
10066             }
10067       }
10068    }
10069    if(ret == RFAILED)
10070    {
10071       /*TODO : Negative case*/
10072       // BuildAndSendUeContextSetupRsp(ueIdx, cellId);
10073       DU_LOG("\nERROR  -->  F1AP: Failed to process UE CNTXT SETUP REQ at procF1UeContextSetupReq()");
10074    }
10075    else
10076       ret = duProcUeContextSetupRequest(duUeCb);
10077
10078    freeAperDecodeF1UeContextSetupReq(ueSetReq);
10079    return ret;
10080
10081 }
10082 /*******************************************************************
10083  * @brief Free the memory allocated for Dl Tunnel Info
10084  *
10085  * @details
10086  *
10087  *    Function : freeDlTnlInfo
10088  *
10089  *    Functionality:
10090  *       Free the memory allocated for Dl Tunnel Info
10091  *
10092  * @params[in] DLUPTNLInformation_ToBeSetup_List_t *
10093  * @return void
10094  *
10095  * ****************************************************************/
10096
10097 void freeDlTnlInfo(DLUPTNLInformation_ToBeSetup_List_t *tnlInfo)
10098 {
10099    uint8_t arrIdx = 0;
10100
10101    for(arrIdx=0; arrIdx < tnlInfo->list.count; arrIdx++)
10102    {
10103       DU_FREE(tnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel, sizeof(GTPTunnel_t));
10104    }
10105 }
10106
10107 /*******************************************************************
10108  * @brief Free the memory allocated for DRB setup List
10109  *
10110  * @details
10111  *
10112  *    Function : freeDrbSetupList
10113  *
10114  *    Functionality:
10115  *       Free the memory allocated for DRB setup list
10116  *
10117  * @params[in] DRBs_Setup_List_t *
10118  * @return void
10119  *
10120  * ****************************************************************/
10121 void freeDrbSetupList(DRBs_Setup_List_t *drbSetupList)
10122 {
10123    uint8_t arrIdx = 0;
10124    DRBs_Setup_ItemIEs_t *drbItemIe = NULLP;
10125
10126    for(arrIdx = 0; arrIdx < drbSetupList->list.count; arrIdx++)
10127    {
10128       drbItemIe = ((DRBs_Setup_ItemIEs_t *)drbSetupList->list.array[arrIdx]);
10129       freeDlTnlInfo(&drbItemIe->value.choice.DRBs_Setup_Item.dLUPTNLInformation_ToBeSetup_List);
10130    }
10131 }
10132
10133 /*******************************************************************
10134  * @brief Free the memory allocated for UE Setup response
10135  *
10136  * @details
10137  *
10138  *    Function : FreeUeContextSetupRsp
10139  *
10140  *    Functionality:
10141  *       Free the memory allocated for UE Setup response
10142  *
10143  * @params[in] F1AP PDU for UE setup response
10144  * @return ROK     - success
10145  *         RFAILED - failure
10146  *
10147  * ****************************************************************/
10148 void FreeUeContextSetupRsp(F1AP_PDU_t *f1apMsg)
10149 {
10150    uint8_t idx;
10151    UEContextSetupResponse_t *ueSetRsp = NULLP;
10152
10153    if(f1apMsg)
10154    {
10155       if(f1apMsg->choice.successfulOutcome)
10156       {
10157          ueSetRsp = &f1apMsg->choice.successfulOutcome->value.choice.\
10158                     UEContextSetupResponse;
10159          if(ueSetRsp->protocolIEs.list.array)
10160          {
10161             for(idx = 0; idx < ueSetRsp->protocolIEs.list.count; idx++)
10162             {
10163                if(ueSetRsp->protocolIEs.list.array[idx])
10164                {
10165                   switch(ueSetRsp->protocolIEs.list.array[idx]->id)
10166                   {
10167                      case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
10168                         break;
10169                      case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
10170                         break;
10171                      case ProtocolIE_ID_id_DUtoCURRCInformation:
10172                         {
10173                            CellGroupConfig_t *cellGrpCfg = NULLP;
10174                            cellGrpCfg  = &ueSetRsp->protocolIEs.list.array[idx]->value.choice.\
10175                                          DUtoCURRCInformation.cellGroupConfig;
10176                            if(cellGrpCfg->buf != NULLP)
10177                            {
10178                               DU_FREE(cellGrpCfg->buf, cellGrpCfg->size);
10179                               cellGrpCfg = NULLP;
10180                            }
10181                            break;
10182                         }
10183                     case ProtocolIE_ID_id_DRBs_Setup_List:
10184                         {
10185                            freeDrbSetupList(&ueSetRsp->protocolIEs.list.array[idx]->value.choice.DRBs_Setup_List);
10186                            break;
10187                         }
10188                      default:
10189                         DU_LOG("\nERROR  -->  DUAPP: Invalid Id %ld at FreeUeContextSetupRsp()",\
10190                         ueSetRsp->protocolIEs.list.array[idx]->id);
10191                         break;
10192                   }
10193                   DU_FREE(ueSetRsp->protocolIEs.list.array[idx],\
10194                         sizeof(UEContextSetupResponseIEs_t));
10195                }
10196             }
10197             DU_FREE(ueSetRsp->protocolIEs.list.array, \
10198                   ueSetRsp->protocolIEs.list.size);
10199          }
10200          DU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
10201       }
10202       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
10203    }
10204 }
10205
10206 /*******************************************************************
10207  *
10208  * @brief Builds Ue context Setup Rsp DU To CU Info
10209  *
10210  * @details
10211  *
10212  *    Function : EncodeUeCntxtDuToCuInfo
10213  *
10214  *    Functionality: Builds Ue context Setup Rsp DU To CU Info
10215  *
10216  * @params[in] CellGroupConfig_t *, CellGroupConfigRrc_t *
10217  *
10218  * @return ROK     - success
10219  *         RFAILED - failure
10220  *
10221  ******************************************************************/
10222
10223 uint8_t EncodeUeCntxtDuToCuInfo(CellGroupConfig_t *duToCuCellGrp, CellGroupConfigRrc_t *duCellGrpCfg)
10224 {
10225    asn_enc_rval_t        encRetVal;
10226
10227    xer_fprint(stdout, &asn_DEF_CellGroupConfigRrc, duCellGrpCfg);
10228    memset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
10229    encBufSize = 0;
10230    encRetVal = aper_encode(&asn_DEF_CellGroupConfigRrc, 0, duCellGrpCfg, PrepFinalEncBuf, encBuf);
10231    /* Encode results */
10232    if(encRetVal.encoded == ENCODE_FAIL)
10233    {
10234       DU_LOG( "\nERROR  -->  F1AP : Could not encode UeCntxtDuToCuInfo (at %s)\n",\
10235             encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
10236       return RFAILED;
10237    }
10238    else
10239    {
10240       DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for UeCntxtDuToCuInfo\n");
10241       for(int i=0; i< encBufSize; i++)
10242       {
10243          printf("%x",encBuf[i]);
10244       }
10245    }
10246    duToCuCellGrp->size = encBufSize;
10247    DU_ALLOC(duToCuCellGrp->buf, duToCuCellGrp->size);
10248    if(!duToCuCellGrp->buf)
10249    {
10250       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in UeCntxtDuToCuInfo");
10251    }
10252    memcpy(duToCuCellGrp->buf, encBuf, duToCuCellGrp->size);
10253    return ROK;
10254 }
10255
10256 /*******************************************************************
10257  *
10258  * @brief Fills Dl Gtp tunnel Info
10259  *
10260  * @details
10261  *
10262  *    Function : fillGtpTunnelforDl
10263  *
10264  *    Functionality: Fills Dl Gtp tunnel Info
10265  *
10266  * @params[in]
10267  *
10268  * @return ROK     - success
10269  *         RFAILED - failure
10270  *
10271  * ****************************************************************/
10272
10273 uint8_t fillGtpTunnelforDl(GTPTunnel_t *gtpDl, GtpTnlCfg *gtpUeCfg)
10274 {
10275    uint8_t bufSize = 0;
10276
10277    gtpDl->transportLayerAddress.size    = 4*sizeof(uint8_t);
10278    DU_ALLOC(gtpDl->transportLayerAddress.buf, gtpDl->transportLayerAddress.size);
10279    if(gtpDl->transportLayerAddress.buf == NULLP)
10280    {
10281       return RFAILED;
10282    }
10283    memcpy(gtpDl->transportLayerAddress.buf, &gtpUeCfg->dlTnlAddress, gtpDl->transportLayerAddress.size);
10284
10285    /*GTP TEID*/
10286    gtpDl->gTP_TEID.size = 4 * sizeof(uint8_t);
10287    DU_ALLOC(gtpDl->gTP_TEID.buf, gtpDl->gTP_TEID.size);
10288    if(gtpDl->gTP_TEID.buf == NULLP)
10289    {
10290       return RFAILED;
10291    }
10292    bufSize = 3; /*forming an Octect String*/
10293    fillTeIdString(bufSize, gtpUeCfg->teId, gtpDl->gTP_TEID.buf);
10294
10295    return ROK;
10296 }
10297
10298 /*******************************************************************
10299  *
10300  * @brief Fills DL Tunnel Setup List
10301  *
10302  * @details
10303  *
10304  *    Function : fillDlTnlSetupList
10305  *
10306  *    Functionality: Fills the DL Tunnel Setup List
10307  *
10308  * @params[in]
10309  *
10310  * @return ROK     - success
10311  *         RFAILED - failure
10312  *
10313  * ****************************************************************/
10314
10315 uint8_t fillDlTnlSetupList(DLUPTNLInformation_ToBeSetup_List_t *dlTnlInfo, UpTnlCfg *tnlCfg)
10316 {
10317    uint8_t ret = ROK, arrIdx = 0, eleCount = 0;
10318
10319    eleCount = 1;
10320    dlTnlInfo->list.count = eleCount;
10321    dlTnlInfo->list.size = (eleCount * sizeof(DLUPTNLInformation_ToBeSetup_Item_t *));
10322
10323    /* Initialize the DL Tnl Setup List Members */
10324    DU_ALLOC(dlTnlInfo->list.array, dlTnlInfo->list.size);
10325    if(dlTnlInfo->list.array == NULLP)
10326    {
10327       DU_LOG(" ERROR  -->  F1AP : Memory allocation for DL Tnl Setup List in fillDlTnlSetupList()");
10328       ret = RFAILED;
10329    }
10330    for(arrIdx=0; arrIdx < eleCount; arrIdx++)
10331    {
10332       DU_ALLOC(dlTnlInfo->list.array[arrIdx], sizeof(DLUPTNLInformation_ToBeSetup_Item_t));
10333       if(dlTnlInfo->list.array[arrIdx] == NULLP)
10334       {
10335          DU_LOG(" ERROR  -->  F1AP : Memory allocation for arrIdx [%d] failed in fillDlTnlSetupList()", arrIdx);
10336          return RFAILED;
10337       }
10338       dlTnlInfo->list.array[arrIdx]->dLUPTNLInformation.present = UPTransportLayerInformation_PR_gTPTunnel;
10339       DU_ALLOC(dlTnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel, sizeof(GTPTunnel_t));
10340       if(dlTnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel == NULLP)
10341       {
10342          DU_LOG(" ERROR  -->  F1AP : Memory allocation for DL tunnel info in fillDlTnlSetupList()");
10343          return RFAILED;
10344       }
10345       ret = fillGtpTunnelforDl(dlTnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel,\
10346                tnlCfg->tnlCfg1);
10347       if(ret != ROK)
10348          break;
10349    }
10350    return ret;
10351 }
10352
10353 /*******************************************************************
10354  *
10355  * @brief Fills the Drb Setup List for Ue Context Setup Response
10356  *
10357  * @details
10358  *
10359  *    Function : fillDrbSetupList
10360  *
10361  *    Functionality: Fills the Drb Setup List for Ue Context Setup Response
10362  *
10363  * @params[in]
10364  *
10365  * @return ROK     - success
10366  *         RFAILED - failure
10367  *
10368  * ****************************************************************/
10369 uint8_t fillDrbSetupList(DRBs_Setup_List_t *drbSetupList, DuUeCfg *ueCfg)
10370 {
10371    uint8_t ret = ROK, arrIdx = 0, eleCount = 0;
10372    DRBs_Setup_ItemIEs_t *drbItemIe = NULLP;
10373
10374    eleCount = ueCfg->numDrb;
10375    drbSetupList->list.count = eleCount;
10376    drbSetupList->list.size = \
10377         (eleCount * sizeof(DRBs_Setup_Item_t *));
10378
10379    /* Initialize the Drb Setup List Members */
10380    DU_ALLOC(drbSetupList->list.array, drbSetupList->list.size);
10381    if(drbSetupList->list.array == NULLP)
10382    {
10383       DU_LOG(" ERROR  -->  F1AP : Memory allocation for DRB Setup List in fillDrbSetupList()");
10384       ret = RFAILED;
10385    }
10386
10387    for(arrIdx=0; arrIdx < eleCount; arrIdx++)
10388    {
10389       DU_ALLOC(drbSetupList->list.array[arrIdx], sizeof(DRBs_Setup_Item_t));
10390       if(drbSetupList->list.array[arrIdx] == NULLP)
10391       {
10392          DU_LOG(" ERROR  -->  F1AP : Memory allocation for arrIdx [%d] failed in fillDrbSetupList()", arrIdx);
10393          return RFAILED;
10394       }
10395       drbItemIe = ((DRBs_Setup_ItemIEs_t *)drbSetupList->list.array[arrIdx]);
10396       drbItemIe->id = ProtocolIE_ID_id_DRBs_Setup_Item;
10397       drbItemIe->criticality = Criticality_reject;
10398       drbItemIe->value.present = DRBs_Setup_ItemIEs__value_PR_DRBs_Setup_Item;
10399       drbItemIe->value.choice.DRBs_Setup_Item.dRBID = ueCfg->upTnlInfo[arrIdx].drbId;
10400       ret = fillDlTnlSetupList(&drbItemIe->value.choice.DRBs_Setup_Item.dLUPTNLInformation_ToBeSetup_List,\
10401           &ueCfg->upTnlInfo[arrIdx]);
10402       if(ret != ROK)
10403          break;
10404    }
10405    return ret;
10406 }
10407
10408 /*******************************************************************
10409  *
10410  * @brief Builds and sends the UE Setup Response
10411  *
10412  * @details
10413  *
10414  *    Function : BuildAndSendUeContextSetupRsp
10415  *
10416  *    Functionality: Constructs the UE Setup Response and sends
10417  *                   it to the DU through SCTP.
10418  *
10419  * @params[in]
10420  *
10421  * @return ROK     - success
10422  *         RFAILED - failure
10423  *
10424  * ****************************************************************/
10425 uint8_t BuildAndSendUeContextSetupRsp(uint8_t ueIdx, uint8_t cellId)
10426 {
10427    uint8_t   idx, ret, cellIdx, elementCnt;
10428    uint32_t  gnbCuUeF1apId;   /* gNB-CU UE F1AP Id */
10429    uint32_t  gnbDuUeF1apId;   /* gNB-DU UE F1AP Id */
10430    asn_enc_rval_t  encRetVal;        /* Encoder return value */
10431    F1AP_PDU_t               *f1apMsg = NULLP;
10432    UEContextSetupResponse_t *ueSetRsp = NULLP;
10433    CellGroupConfigRrc_t     *cellGrpCfg = NULLP;
10434    DuUeCb                   *ueCb = NULLP;
10435
10436    DU_LOG("\n INFO   -->  F1AP : Building UE Context Setup Response for cellId %d, ueIdx %d\n", cellId, ueIdx);
10437
10438    while(true)
10439    {
10440       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
10441       if(f1apMsg == NULLP)
10442       {
10443          DU_LOG(" ERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
10444          ret = RFAILED;
10445          break;
10446       }
10447
10448       f1apMsg->present = F1AP_PDU_PR_successfulOutcome;
10449       DU_ALLOC(f1apMsg->choice.successfulOutcome,
10450             sizeof(SuccessfulOutcome_t));
10451       if(f1apMsg->choice.successfulOutcome == NULLP)
10452       {
10453          DU_LOG(" ERROR  -->  F1AP : Memory allocation for      F1AP-PDU failed");
10454          ret = RFAILED;
10455          break;
10456       }
10457
10458       f1apMsg->choice.successfulOutcome->procedureCode = \
10459                                                          ProcedureCode_id_UEContextSetup;
10460       f1apMsg->choice.successfulOutcome->criticality = Criticality_reject;
10461       f1apMsg->choice.successfulOutcome->value.present = \
10462                                                          SuccessfulOutcome__value_PR_UEContextSetupResponse;
10463
10464       ueSetRsp =
10465          &f1apMsg->choice.successfulOutcome->value.choice.UEContextSetupResponse;
10466       elementCnt = 4;
10467       ueSetRsp->protocolIEs.list.count = elementCnt;
10468       ueSetRsp->protocolIEs.list.size = \
10469                                         elementCnt * sizeof(UEContextSetupResponse_t *);
10470
10471       /* Initialize the UESetup members */
10472       DU_ALLOC(ueSetRsp->protocolIEs.list.array, \
10473             ueSetRsp->protocolIEs.list.size);
10474       if(ueSetRsp->protocolIEs.list.array == NULLP)
10475       {
10476          DU_LOG(" ERROR  -->  F1AP : Memory allocation for UE Setup Response failed");
10477          ret = RFAILED;
10478          break;
10479       }
10480
10481       for(idx=0; idx<elementCnt; idx++)
10482       {
10483          DU_ALLOC(ueSetRsp->protocolIEs.list.array[idx],\
10484                sizeof(UEContextSetupResponseIEs_t));
10485          if(ueSetRsp->protocolIEs.list.array[idx] == NULLP)
10486          {
10487             DU_LOG(" ERROR  -->  F1AP : Memory allocation for UE Setup Response failed");
10488             ret = RFAILED;
10489             break;
10490          }
10491       }
10492       /* Fetching Ue Cb Info*/
10493       GET_CELL_IDX(cellId, cellIdx);
10494       gnbDuUeF1apId = duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].gnbDuUeF1apId;
10495       gnbCuUeF1apId = duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].gnbCuUeF1apId;
10496       ueCb = &duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1];
10497
10498       idx = 0;
10499       /*GNB CU UE F1AP ID*/
10500       ueSetRsp->protocolIEs.list.array[idx]->id = \
10501                                                   ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
10502       ueSetRsp->protocolIEs.list.array[idx]->criticality = Criticality_reject;
10503       ueSetRsp->protocolIEs.list.array[idx]->value.present = \
10504                                                              UEContextSetupResponseIEs__value_PR_GNB_CU_UE_F1AP_ID;
10505       ueSetRsp->protocolIEs.list.array[idx]->value.choice.GNB_CU_UE_F1AP_ID = gnbCuUeF1apId;
10506
10507       /*GNB DU UE F1AP ID*/
10508       idx++;
10509       ueSetRsp->protocolIEs.list.array[idx]->id = \
10510                                                   ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
10511       ueSetRsp->protocolIEs.list.array[idx]->criticality = Criticality_reject;
10512       ueSetRsp->protocolIEs.list.array[idx]->value.present = \
10513                                                              UEContextSetupResponseIEs__value_PR_GNB_DU_UE_F1AP_ID;
10514       ueSetRsp->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID = gnbDuUeF1apId;
10515
10516
10517       /*DUtoCURRC Information */
10518       idx++;
10519       ueSetRsp->protocolIEs.list.array[idx]->id  = \
10520                                                    ProtocolIE_ID_id_DUtoCURRCInformation;
10521       ueSetRsp->protocolIEs.list.array[idx]->criticality = Criticality_reject;
10522       ueSetRsp->protocolIEs.list.array[idx]->value.present =\
10523                                                             UEContextSetupResponseIEs__value_PR_DUtoCURRCInformation;
10524       if(ueCb->f1UeDb)
10525       {
10526          if(ueCb->f1UeDb->duUeCfg.cellGrpCfg)
10527          {
10528             cellGrpCfg = (CellGroupConfigRrc_t*)ueCb->f1UeDb->duUeCfg.cellGrpCfg;
10529             ret = EncodeUeCntxtDuToCuInfo(&ueSetRsp->protocolIEs.list.array[idx]->value.\
10530                      choice.DUtoCURRCInformation.cellGroupConfig, cellGrpCfg);
10531             if(ret == RFAILED)
10532             {
10533                DU_LOG("\nERROR  -->  F1AP : Failed to EncodeUeCntxtDuToCuInfo in BuildAndSendUeContextSetupRsp()");
10534                freeF1UeDb(ueCb->f1UeDb);
10535                ueCb->f1UeDb = NULLP;
10536                break;
10537             }
10538          }
10539       }
10540       else
10541       {
10542          DU_LOG("\nERROR  -->  F1AP : Failed to form DUtoCU RRCInfo at BuildAndSendUeContextSetupRsp()");
10543          ret = RFAILED;
10544          break;
10545       }
10546
10547       /* Drb Setup List */
10548       idx++;
10549       ueSetRsp->protocolIEs.list.array[idx]->id  = \
10550                                  ProtocolIE_ID_id_DRBs_Setup_List;
10551       ueSetRsp->protocolIEs.list.array[idx]->criticality = Criticality_reject;
10552       ueSetRsp->protocolIEs.list.array[idx]->value.present =\
10553                                  UEContextSetupResponseIEs__value_PR_DRBs_Setup_List;
10554       ret = fillDrbSetupList(&ueSetRsp->protocolIEs.list.array[idx]->value.choice.DRBs_Setup_List,\
10555                &ueCb->f1UeDb->duUeCfg);
10556       if(ret == RFAILED)
10557       {
10558          DU_LOG("\nERROR  -->  F1AP : Failed to fillDrbSetupList in BuildAndSendUeContextSetupRsp()");
10559          freeF1UeDb(ueCb->f1UeDb);
10560          ueCb->f1UeDb = NULLP;
10561          break;
10562       }
10563
10564        /* Free UeContext Db created during Ue context Req */
10565        freeF1UeDb(ueCb->f1UeDb);
10566        ueCb->f1UeDb = NULLP;
10567
10568       /* TODO: To send Drb list */
10569       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
10570
10571       /* Encode the UE context setup response type as APER */
10572       memset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
10573       encBufSize = 0;
10574       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
10575             encBuf);
10576       /* Encode results */
10577       if(encRetVal.encoded == ENCODE_FAIL)
10578       {
10579          DU_LOG( "\nERROR  -->  F1AP : Could not encode UE Context Setup Response structure (at %s)\n",\
10580                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
10581          ret = RFAILED;
10582          break;
10583       }
10584       else
10585       {
10586          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for UE Context Setup Response\n");
10587          for(int i=0; i< encBufSize; i++)
10588          {
10589             printf("%x",encBuf[i]);
10590          }
10591       }
10592
10593       /* Sending  msg  */
10594       if(SendF1APMsg(DU_APP_MEM_REGION,DU_POOL) != ROK)
10595       {
10596          DU_LOG("\nERROR  -->  F1AP : Sending UE Context Setup Response failed");
10597          ret = RFAILED;
10598          break;
10599       }
10600       break;
10601    }
10602    FreeUeContextSetupRsp(f1apMsg);
10603    return ret;
10604 }/* End of BuildAndSendUeContextSetupRsp */
10605 /*******************************************************************
10606 *
10607 * @brief  Build And Send Ue Context Rsp
10608 *
10609 * @details
10610 *
10611 *    Function : BuildAndSendUeCtxtRsp
10612 *
10613 *    Functionality : Build And Send Ue Context Rsp
10614
10615 * @params[in]
10616 * @return sucess = ROK
10617 *         failure = RFAILED
10618 *
10619 * ****************************************************************/
10620 uint8_t BuildAndSendUeCtxtRsp(uint8_t ueIdx, uint8_t cellId)
10621 {
10622    uint8_t cellIdx = 0, actionType = 0;
10623
10624    GET_CELL_IDX(cellId, cellIdx);
10625    actionType = duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].f1UeDb->actionType;
10626
10627    switch(actionType)
10628    {
10629       case UE_CTXT_SETUP:
10630          BuildAndSendUeContextSetupRsp(ueIdx, cellId);
10631          break;
10632       case UE_CTXT_MOD:
10633          BuildAndSendUeContextModResp(ueIdx, cellId);
10634          break;
10635       default:
10636          DU_LOG("ERROR  -->  F1AP: Invalid Action Type %d at BuildAndSendUeCtxtRsp()", actionType);
10637          break;
10638
10639    }
10640    return ROK;
10641 }
10642
10643 /*******************************************************************
10644  *
10645  * @brief deallocating the memory of  F1reset msg
10646  *
10647  * @details
10648  *
10649  *    Function : FreeF1ResetReq
10650  *
10651  *    Functionality :
10652  *         - freeing memory of F1reset request msg
10653  *
10654  * @params[in]
10655  * @return void
10656  *
10657  *
10658  * ****************************************************************/
10659 void FreeF1ResetReq(F1AP_PDU_t *f1apMsg)
10660 {
10661    uint8_t idx =0 ;
10662    Reset_t *f1ResetMsg;
10663
10664    if(f1apMsg)
10665    {
10666       if(f1apMsg->choice.initiatingMessage)
10667       {
10668          f1ResetMsg = &f1apMsg->choice.initiatingMessage->value.choice.Reset;
10669
10670          if(f1ResetMsg->protocolIEs.list.array)
10671          {
10672             for(idx=0 ;idx < f1ResetMsg->protocolIEs.list.count ; idx++)
10673             {
10674                if(f1ResetMsg->protocolIEs.list.array[idx])
10675                {
10676                   DU_FREE(f1ResetMsg->protocolIEs.list.array[idx],sizeof(ResetIEs_t));
10677                }
10678             }
10679             DU_FREE(f1ResetMsg->protocolIEs.list.array,f1ResetMsg->protocolIEs.list.size);
10680          }
10681          DU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
10682       }
10683       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
10684    }
10685 }
10686 /*******************************************************************
10687  *
10688  * @brief Build and Send F1reset request
10689  *
10690  * @details
10691  *
10692  *    Function : BuildAndSendF1ResetReq
10693  *
10694  *    Functionality:
10695  *         - Build and Send F1reset request msg
10696  *
10697  * @params[in]
10698  * @return ROK     - success
10699  *         RFAILED - failure
10700  *
10701  * ****************************************************************/
10702 uint8_t BuildAndSendF1ResetReq()
10703 {
10704    uint8_t          elementCnt=0;
10705    uint8_t          idx=0;
10706    uint8_t          ret= RFAILED;
10707    Reset_t          *f1ResetMsg = NULLP;
10708    F1AP_PDU_t       *f1apMsg = NULLP;
10709    asn_enc_rval_t   encRetVal;
10710    DU_LOG("\nINFO   -->  F1AP : Building F1 Reset request \n");
10711    do
10712    {
10713       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
10714       if(f1apMsg == NULLP)
10715       {
10716          break;
10717       }
10718       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
10719       DU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
10720       if(f1apMsg->choice.initiatingMessage == NULLP)
10721       {
10722          break;
10723       }
10724       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_Reset;
10725       f1apMsg->choice.initiatingMessage->criticality = Criticality_reject;
10726       f1apMsg->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_Reset;
10727
10728       f1ResetMsg = &f1apMsg->choice.initiatingMessage->value.choice.Reset;
10729
10730       elementCnt = 3;
10731       f1ResetMsg->protocolIEs.list.count = elementCnt;
10732       f1ResetMsg->protocolIEs.list.size = elementCnt * sizeof(ResetIEs_t *);
10733
10734       /* Initialize the F1Setup members */
10735       DU_ALLOC(f1ResetMsg->protocolIEs.list.array,f1ResetMsg->protocolIEs.list.size);
10736       if(f1ResetMsg->protocolIEs.list.array == NULLP)
10737       {
10738          break;
10739       }
10740       for(idx=0; idx<elementCnt; idx++)
10741       {
10742          DU_ALLOC(f1ResetMsg->protocolIEs.list.array[idx],sizeof(ResetIEs_t));
10743          if(f1ResetMsg->protocolIEs.list.array[idx] == NULLP)
10744          {
10745             break;
10746          }
10747       }
10748
10749       /*TransactionID*/
10750       idx=0;
10751       f1ResetMsg->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_TransactionID;
10752       f1ResetMsg->protocolIEs.list.array[idx]->criticality = Criticality_reject;
10753       f1ResetMsg->protocolIEs.list.array[idx]->value.present = ResetIEs__value_PR_TransactionID;
10754       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.TransactionID = 1;
10755
10756       /*Cause*/
10757       idx++;
10758       f1ResetMsg->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_Cause;
10759       f1ResetMsg->protocolIEs.list.array[idx]->criticality = Criticality_ignore;
10760       f1ResetMsg->protocolIEs.list.array[idx]->value.present = ResetIEs__value_PR_Cause;
10761       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.Cause.present = Cause_PR_radioNetwork;
10762       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.Cause.choice.radioNetwork = CauseRadioNetwork_action_desirable_for_radio_reasons;
10763
10764       /*Reset Type*/
10765       idx++;
10766       f1ResetMsg->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_ResetType;
10767       f1ResetMsg->protocolIEs.list.array[idx]->criticality = Criticality_reject;
10768       f1ResetMsg->protocolIEs.list.array[idx]->value.present = ResetIEs__value_PR_ResetType;
10769       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.ResetType.present = ResetType_PR_f1_Interface;
10770       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.ResetType.choice.f1_Interface = ResetAll_reset_all;
10771
10772       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
10773
10774       /* Encode the F1SetupRequest type as APER */
10775       memset(encBuf, 0, ENC_BUF_MAX_LEN);
10776       encBufSize = 0;
10777       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
10778             encBuf);
10779
10780       /* Encode results */
10781       if(encRetVal.encoded == ENCODE_FAIL)
10782       {
10783          DU_LOG("\nERROR  -->  F1AP : Could not encode F1Reset structure (at %s)\n",\
10784                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
10785          break;
10786       }
10787       else
10788       {
10789          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for F1Reset\n");
10790          for(idx=0; idx< encBufSize; idx++)
10791          {
10792             printf("%x",encBuf[idx]);
10793          }
10794       }
10795
10796       if(SendF1APMsg(DU_APP_MEM_REGION, DU_POOL) != ROK)
10797       {
10798          DU_LOG("\nERROR  -->  F1AP : Sending F1 Reset request failed");
10799          break;
10800       }
10801
10802       ret = ROK;
10803       break;
10804    }while(true);
10805
10806    FreeF1ResetReq(f1apMsg);
10807    return ret;
10808 }
10809 /*******************************************************************
10810  *
10811  * @brief Build And Send F1ResetAck
10812  *
10813  * @details
10814  *
10815  *    Function : BuildAndSendF1ResetAck
10816  *
10817  *    Functionality:
10818  *         - Build And Send  F1ResetRSP
10819  *
10820  * @return ROK     - success
10821  *         RFAILED - failure
10822  *
10823  * ****************************************************************/
10824 void FreeF1ResetAck(F1AP_PDU_t *f1apMsg)
10825 {
10826    uint8_t idx;
10827    ResetAcknowledge_t *f1ResetAck;
10828
10829    if(f1apMsg)
10830    {
10831       if(f1apMsg->choice.successfulOutcome)
10832       {
10833          f1ResetAck= &f1apMsg->choice.successfulOutcome->value.choice.ResetAcknowledge;
10834
10835          if(f1ResetAck->protocolIEs.list.array)
10836          {
10837             for(idx=0; idx<f1ResetAck->protocolIEs.list.count ; idx++)
10838             {
10839                if(f1ResetAck->protocolIEs.list.array[idx])
10840                {
10841                   DU_FREE(f1ResetAck->protocolIEs.list.array[idx], sizeof(ResetAcknowledgeIEs_t));
10842                }
10843             }
10844             DU_FREE(f1ResetAck->protocolIEs.list.array, f1ResetAck->protocolIEs.list.size );
10845          }
10846          DU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
10847       }
10848       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
10849    }
10850 }
10851
10852 /*******************************************************************
10853  *
10854  * @brief Build And Send F1ResetAck
10855  *
10856  * @details
10857  *
10858  *    Function : BuildAndSendF1ResetAck
10859  *
10860  *    Functionality:
10861  *         - Build And Send  F1ResetRSP
10862  *
10863  *  @params[in]
10864  * @return ROK     - success
10865  *         RFAILED - failure
10866  *
10867  * ****************************************************************/
10868 uint8_t BuildAndSendF1ResetAck()
10869 {
10870    uint8_t                idx = 0;
10871    uint8_t                elementCnt = 0;
10872    uint8_t                ret = RFAILED;
10873    F1AP_PDU_t             *f1apMsg = NULL;
10874    ResetAcknowledge_t     *f1ResetAck = NULLP;
10875    asn_enc_rval_t         encRetVal;
10876    DU_LOG("\nINFO   -->  F1AP : Building F1 Reset Acknowledgment \n");
10877
10878    do{
10879       /* Allocate the memory for F1ResetRequest_t */
10880       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
10881       if(f1apMsg == NULLP)
10882       {
10883          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
10884          break;
10885       }
10886
10887       f1apMsg->present =  F1AP_PDU_PR_successfulOutcome;
10888
10889       DU_ALLOC(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
10890       if(f1apMsg->choice.successfulOutcome == NULLP)
10891       {
10892          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
10893          break;
10894       }
10895       f1apMsg->choice.successfulOutcome->criticality   = Criticality_reject;
10896       f1apMsg->choice.successfulOutcome->value.present = SuccessfulOutcome__value_PR_ResetAcknowledge;
10897       f1ResetAck = &f1apMsg->choice.successfulOutcome->value.choice.ResetAcknowledge;
10898
10899       elementCnt = 1;
10900
10901       f1ResetAck->protocolIEs.list.count = elementCnt;
10902       f1ResetAck->protocolIEs.list.size = elementCnt*sizeof(ResetAcknowledgeIEs_t *);
10903
10904       DU_ALLOC(f1ResetAck->protocolIEs.list.array, f1ResetAck->protocolIEs.list.size );
10905       if(f1ResetAck->protocolIEs.list.array == NULLP)
10906       {
10907          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1ResetAckIEs failed");
10908          break;
10909       }
10910
10911       for(idx=0; idx<elementCnt; idx++)
10912       {
10913          DU_ALLOC(f1ResetAck->protocolIEs.list.array[idx], sizeof(ResetAcknowledgeIEs_t));
10914          if(f1ResetAck->protocolIEs.list.array[idx] == NULLP)
10915          {
10916             break;
10917          }
10918       }
10919       /*TransactionID*/
10920       idx = 0;
10921       f1ResetAck->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_TransactionID;
10922       f1ResetAck->protocolIEs.list.array[idx]->criticality = Criticality_reject;
10923       f1ResetAck->protocolIEs.list.array[idx]->value.present = ResetAcknowledgeIEs__value_PR_TransactionID;
10924       f1ResetAck->protocolIEs.list.array[idx]->value.choice.TransactionID = TRANS_ID;
10925
10926       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
10927
10928       /* Encode the F1SetupRequest type as UPER */
10929       memset(encBuf, 0, ENC_BUF_MAX_LEN);
10930       encBufSize = 0;
10931       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
10932
10933       /* Check encode results */
10934       if(encRetVal.encoded == ENCODE_FAIL)
10935       {
10936          DU_LOG("\nERROR  -->  F1AP : Could not encode F1ResetAck structure (at %s)\n",\
10937                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
10938          break;
10939       }
10940       else
10941       {
10942          DU_LOG("\nDUBUG   -->  F1AP : Created APER encoded buffer for F1ResetAck\n");
10943          for(int i=0; i< encBufSize; i++)
10944          {
10945             printf("%x",encBuf[i]);
10946          }
10947       }
10948       /* Sending msg */
10949       if(SendF1APMsg(DU_APP_MEM_REGION, DU_POOL) != ROK)
10950       {
10951          DU_LOG("\nERROR  -->  F1AP : Sending F1 Reset Acknowledgement failed");
10952          break;
10953       }
10954
10955       ret = ROK;
10956       break;
10957    }while(true);
10958
10959    FreeF1ResetAck(f1apMsg);
10960    return ret;
10961 }
10962 /******************************************************************
10963 *
10964 * @brief free F1 reset msg allocated by aper_decoder
10965 *
10966 * @details
10967 *
10968 *    Function : freeAperDecodeF1ResetMsg
10969 *
10970 *    Functionality: free F1 reset msg allocated by aper_decoder
10971 *
10972 * @params[in] Reset_t *f1ResetMsg
10973 * @return void
10974 *
10975 * ****************************************************************/
10976
10977 void freeAperDecodeF1ResetMsg(Reset_t *f1ResetMsg)
10978 {
10979    uint8_t ieIdx =0;
10980    if(f1ResetMsg->protocolIEs.list.array)
10981    {
10982       for(ieIdx=0 ;ieIdx < f1ResetMsg->protocolIEs.list.count ; ieIdx++)
10983       {
10984          if(f1ResetMsg->protocolIEs.list.array[ieIdx])
10985          {
10986             free(f1ResetMsg->protocolIEs.list.array[ieIdx]);
10987          }
10988       }
10989       free(f1ResetMsg->protocolIEs.list.array);
10990    }
10991 }
10992
10993 /******************************************************************
10994  *
10995  * @brief Processes DL RRC Message Transfer  sent by CU
10996  *
10997  * @details
10998  *
10999  *    Function : procF1ResetReq
11000  *
11001  *    Functionality: Processes DL RRC Message Transfer sent by CU
11002  *
11003  * @params[in] F1AP_PDU_t ASN decoded F1AP message
11004  * @return ROK     - success
11005  *         RFAILED - failure
11006  *
11007  * ****************************************************************/
11008 uint8_t procF1ResetReq(F1AP_PDU_t *f1apMsg)
11009 {
11010    /* we are currently not supporting Ue release. right now we are supporting only init case of fireset */
11011    uint8_t       ieIdx = 0;
11012    uint8_t        ret = ROK;
11013    Reset_t       *f1ResetMsg = NULLP;
11014
11015    DU_LOG("\nINFO   -->  Processing F1 reset request");
11016    f1ResetMsg = &f1apMsg->choice.initiatingMessage->value.choice.Reset;
11017
11018    for(ieIdx=0; ieIdx<f1ResetMsg->protocolIEs.list.count; ieIdx++)
11019    {
11020       switch(f1ResetMsg->protocolIEs.list.array[ieIdx]->id)
11021       {
11022          case ProtocolIE_ID_id_TransactionID:
11023             break;
11024
11025          case ProtocolIE_ID_id_Cause:
11026             break;
11027
11028          case ProtocolIE_ID_id_ResetType:
11029             {
11030                break;
11031             }
11032
11033          default:
11034             break;
11035       }
11036    }
11037    ret = BuildAndSendF1ResetAck();
11038    DU_LOG("\nINFO   -->  UE release is not supported for now");
11039
11040    freeAperDecodeF1ResetMsg(f1ResetMsg);
11041
11042    return ret;
11043 }
11044
11045 /*******************************************************************
11046  *
11047  * @brief free the RRC delivery report
11048  *
11049  * @details
11050  *
11051  *    Function : freeRrcDeliveryReport
11052  *
11053  *    Functionality: free the RRC delivery report
11054  *
11055  * @params[in]
11056  * @return ROK     - success
11057  *         RFAILED - failure
11058  *
11059  * ****************************************************************/
11060 void freeRrcDeliveryReport(F1AP_PDU_t  *f1apMsg )
11061 {
11062    uint8_t idx=0;
11063    RRCDeliveryReport_t *rrcDeliveryReport= NULLP;
11064
11065    if(f1apMsg)
11066    {
11067       if(f1apMsg->choice.initiatingMessage)
11068       {
11069          rrcDeliveryReport = &f1apMsg->choice.initiatingMessage->value.choice.RRCDeliveryReport;
11070          if(rrcDeliveryReport->protocolIEs.list.array)
11071          {
11072             for(idx =0 ;idx <rrcDeliveryReport->protocolIEs.list.count ;
11073                   idx++)
11074             {
11075                if(rrcDeliveryReport->protocolIEs.list.array[idx])
11076                {
11077                   DU_FREE(rrcDeliveryReport->protocolIEs.list.array[idx],
11078                         sizeof(RRCDeliveryReportIEs_t));
11079                }
11080             }
11081             DU_FREE(rrcDeliveryReport->protocolIEs.list.array,
11082                   rrcDeliveryReport->protocolIEs.list.size);
11083          }
11084          DU_FREE(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
11085       }
11086       DU_FREE(f1apMsg,
11087             sizeof(F1AP_PDU_t));
11088    }
11089 }
11090
11091 /*******************************************************************
11092 *
11093 * @brief Builds and sends the RRC delivery report
11094 *
11095 * @details
11096 *
11097 *    Function : BuildAndSendRrcDeliveryReport
11098 *
11099 *    Functionality: Builds and sends the RRC delivery report
11100 *
11101 * @params[in]
11102 *
11103 * @return ROK     - success
11104 *         RFAILED - failure
11105 *
11106 * ****************************************************************/
11107 uint8_t BuildAndSendRrcDeliveryReport(uint32_t gnbCuUeF1apId, \
11108    uint32_t gnbDuUeF1apId, RrcDeliveryReport *rrcDelivery)
11109 {
11110    uint8_t             ret = RFAILED;
11111    uint8_t             idx    = 0;
11112    uint8_t             idx1   = 0;
11113    uint8_t             elementCnt = 0;
11114    F1AP_PDU_t          *f1apMsg = NULLP;
11115    asn_enc_rval_t      encRetVal;
11116    RRCDeliveryReport_t *rrcDeliveryReport= NULLP;
11117
11118    do{
11119
11120       DU_LOG("\nINFO   -->  F1AP : Building RRC delivery Message Transfer Message\n");
11121       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
11122       if(f1apMsg == NULLP)
11123       {
11124          DU_LOG(" ERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
11125          break;
11126       }
11127       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
11128       DU_ALLOC(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
11129       if(f1apMsg->choice.initiatingMessage == NULLP)
11130       {
11131          DU_LOG(" ERROR  -->  F1AP : Memory allocation for  F1AP-PDU  failed");
11132          break;
11133       }
11134       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_RRCDeliveryReport;
11135       f1apMsg->choice.initiatingMessage->criticality   = Criticality_ignore;
11136       f1apMsg->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_RRCDeliveryReport;
11137
11138       rrcDeliveryReport = &f1apMsg->choice.initiatingMessage->value.choice.RRCDeliveryReport;
11139       elementCnt = 4;
11140       rrcDeliveryReport->protocolIEs.list.count = elementCnt;
11141       rrcDeliveryReport->protocolIEs.list.size = elementCnt * sizeof(RRCDeliveryReportIEs_t *);
11142
11143       /* Initialize the F1Setup members */
11144       DU_ALLOC(rrcDeliveryReport->protocolIEs.list.array, rrcDeliveryReport->protocolIEs.list.size);
11145       if(rrcDeliveryReport->protocolIEs.list.array == NULLP)
11146       {
11147          DU_LOG(" ERROR  -->  F1AP : Memory allocation for RRC Delivery  failed");
11148          break;
11149       }
11150       for(idx =0 ;idx <elementCnt; idx++)
11151       {
11152          DU_ALLOC(rrcDeliveryReport->protocolIEs.list.array[idx], sizeof(RRCDeliveryReportIEs_t));
11153          if(rrcDeliveryReport->protocolIEs.list.array[idx] == NULLP)
11154          {
11155             break;
11156          }
11157       }
11158
11159       idx1 = 0;
11160
11161       /*GNB CU UE F1AP ID*/
11162       rrcDeliveryReport->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
11163       rrcDeliveryReport->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
11164       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.present = RRCDeliveryReportIEs__value_PR_GNB_CU_UE_F1AP_ID;
11165       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.choice.GNB_CU_UE_F1AP_ID = gnbCuUeF1apId;
11166
11167       /*GNB DU UE F1AP ID*/
11168       idx1++;
11169       rrcDeliveryReport->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
11170       rrcDeliveryReport->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
11171       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.present = RRCDeliveryReportIEs__value_PR_GNB_DU_UE_F1AP_ID;
11172       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.choice.GNB_DU_UE_F1AP_ID = gnbDuUeF1apId;
11173
11174       /*RRC delivery status*/
11175       idx1++;
11176       rrcDeliveryReport->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_RRCDeliveryStatus;
11177       rrcDeliveryReport->protocolIEs.list.array[idx1]->criticality = Criticality_ignore;
11178       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.present = RRCDeliveryReportIEs__value_PR_RRCDeliveryStatus;
11179       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.choice.RRCDeliveryStatus.delivery_status =\
11180       rrcDelivery->rrcDeliveryStatus.deliveryStatus;
11181       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.choice.RRCDeliveryStatus.triggering_message =\
11182       rrcDelivery->rrcDeliveryStatus.triggeringMessage;
11183
11184       /* SRB ID */
11185       idx1++;
11186       rrcDeliveryReport->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_SRBID;
11187       rrcDeliveryReport->protocolIEs.list.array[idx1]->criticality = Criticality_ignore;
11188       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.present = RRCDeliveryReportIEs__value_PR_SRBID;
11189       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.choice.SRBID =  rrcDelivery->srbId;
11190
11191       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
11192
11193       /* Encode the RRC DELIVERY REPORT type as APER */
11194       memset(encBuf, 0, ENC_BUF_MAX_LEN);
11195       encBufSize = 0;
11196       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
11197             encBuf);
11198
11199       /* Encode results */
11200       if(encRetVal.encoded == ENCODE_FAIL)
11201       {
11202          DU_LOG("\nERROR  -->  F1AP : Could not encode RRC Delivery Msg structure (at %s)\n",\
11203                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
11204          break;
11205       }
11206       else
11207       {
11208          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for RRC Delivery Msg \n");
11209          for(idx=0; idx< encBufSize; idx++)
11210          {
11211             printf("%x",encBuf[idx]);
11212          }
11213       }
11214
11215       /* Sending msg */
11216       if(SendF1APMsg(DU_APP_MEM_REGION, DU_POOL) != ROK)
11217       {
11218          DU_LOG("\nERROR  -->  F1AP : Sending RRC delivery  msg request failed");
11219          break;
11220       }
11221       ret = ROK;
11222       break;
11223
11224    }while(true);
11225
11226    freeRrcDeliveryReport(f1apMsg);
11227    return ret;
11228 }
11229
11230 /*******************************************************************
11231  *
11232  * @brief Processes cells to be activated
11233  *
11234  * @details
11235  *
11236  *    Function : extractCellsToBeActivated
11237  *
11238  *    Functionality:
11239  *      - Processes cells to be activated list received in F1SetupRsp
11240  *
11241  * @params[in] void
11242  * @return ROK     - success
11243  *         RFAILED - failure
11244  *
11245  * ****************************************************************/
11246
11247 uint8_t extractCellsToBeActivated(Cells_to_be_Activated_List_t cellsToActivate)
11248 {
11249    uint8_t  ret = ROK;
11250    uint16_t idx, nci, pci = 0;
11251    Cells_to_be_Activated_List_Item_t cell;
11252
11253    for(idx=0; idx<cellsToActivate.list.count; idx++)
11254    {
11255       nci = 0;
11256       cell = cellsToActivate.list.array[idx]->value.choice.Cells_to_be_Activated_List_Item;
11257       bitStringToInt(&cell.nRCGI.nRCellIdentity, &nci);
11258
11259       if(cell.nRPCI)
11260       {
11261          pci = *cell.nRPCI;
11262       }
11263       ret = duProcCellsToBeActivated(cell.nRCGI.pLMN_Identity.buf, nci, pci);
11264    }
11265    return ret;
11266 }
11267 /******************************************************************
11268 *
11269 * @brief Processes F1 Setup Response allocated by aper_decoder
11270 *
11271 * @details
11272 *
11273 *    Function : freeF1SetupRsp
11274 *
11275 *    Functionality: free F1 Setup Response allocated by aper_decoder
11276 *
11277 * @params[in] F1SetupResponse_t *f1SetRspMsg
11278 * @return void
11279 *
11280 * ****************************************************************/
11281
11282 void freeAperDecodeF1SetupRsp(F1SetupResponse_t *f1SetRspMsg)
11283 {
11284    uint8_t ieIdx =0;
11285    uint8_t arrIdx =0;
11286    Cells_to_be_Activated_List_t *cellToActivate =NULLP;
11287    RRC_Version_t      *rrcVer =NULLP;
11288
11289    if(f1SetRspMsg->protocolIEs.list.array)
11290    {
11291       for(ieIdx=0; ieIdx<f1SetRspMsg->protocolIEs.list.count; ieIdx++)
11292       {
11293          if(f1SetRspMsg->protocolIEs.list.array[ieIdx])
11294          {
11295             switch(f1SetRspMsg->protocolIEs.list.array[ieIdx]->id)
11296             {
11297                case ProtocolIE_ID_id_Cells_to_be_Activated_List:
11298                   {
11299                      cellToActivate =
11300                         &f1SetRspMsg->protocolIEs.list.array[ieIdx]->value.choice.Cells_to_be_Activated_List;
11301                      if(cellToActivate->list.array)
11302                      {
11303                         for(arrIdx=0; arrIdx<cellToActivate->list.count ; arrIdx++)
11304                         {
11305                            if(cellToActivate->list.array[arrIdx])
11306                            {
11307
11308                               if(cellToActivate->list.array[0]->value.choice.Cells_to_be_Activated_List_Item.nRCGI.\
11309                               pLMN_Identity.buf)
11310                               {
11311                                  if(cellToActivate->list.array[0]->value.choice.\
11312                                        Cells_to_be_Activated_List_Item.nRCGI.nRCellIdentity.buf)
11313                                  {
11314                                     free(cellToActivate->list.array[0]->value.choice.\
11315                                           Cells_to_be_Activated_List_Item.nRCGI.nRCellIdentity.buf);
11316                                  }
11317
11318                                  free(cellToActivate->list.array[0]->value.choice.Cells_to_be_Activated_List_Item.\
11319                                        nRCGI.pLMN_Identity.buf);
11320                               }
11321                               free(cellToActivate->list.array[arrIdx]);
11322                            }
11323                         }
11324                         free(cellToActivate->list.array);
11325                      }
11326                      break;
11327                   }
11328                case ProtocolIE_ID_id_TransactionID:
11329                   {
11330                      break;
11331                   }
11332                case ProtocolIE_ID_id_gNB_CU_Name:
11333                   {
11334                      free(f1SetRspMsg->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_Name.buf);
11335                      break;
11336                   }
11337                case ProtocolIE_ID_id_GNB_CU_RRC_Version:
11338                   {
11339                      rrcVer = &f1SetRspMsg->protocolIEs.list.array[ieIdx]->value.choice.RRC_Version;
11340                      if(rrcVer->latest_RRC_Version.buf)
11341                      {
11342                         if(rrcVer->iE_Extensions)
11343                         {
11344                            if(rrcVer->iE_Extensions->list.array)
11345                            {
11346                               if(rrcVer->iE_Extensions->list.array[0])
11347                               {
11348                                  if(rrcVer->iE_Extensions->list.\
11349                                        array[0]->extensionValue.choice.Latest_RRC_Version_Enhanced.buf)
11350                                  {
11351                                     free(rrcVer->iE_Extensions->list.\
11352                                           array[0]->extensionValue.choice.Latest_RRC_Version_Enhanced.buf);
11353                                  }
11354                                  free(rrcVer->iE_Extensions->list.array[0]);
11355                               }
11356                               free(rrcVer->iE_Extensions->list.array);
11357                            }
11358                            free(rrcVer->iE_Extensions);
11359                         }
11360                         free(rrcVer->latest_RRC_Version.buf);
11361                      }
11362                      break;
11363
11364                   }
11365                default:
11366                   {
11367                      DU_LOG("\nERROR  -->  DU_APP : Invalid IE received in F1SetupRsp:%ld",
11368                            f1SetRspMsg->protocolIEs.list.array[ieIdx]->id);
11369                   }
11370             }
11371             free(f1SetRspMsg->protocolIEs.list.array[ieIdx]);
11372          }
11373       }
11374       free(f1SetRspMsg->protocolIEs.list.array);
11375    }
11376 }
11377 /******************************************************************
11378  *
11379  * @brief Processes F1 Setup Response sent by CU
11380  *
11381  * @details
11382  *
11383  *    Function : procF1SetupRsp
11384  *
11385  *    Functionality: Processes F1 Setup Response sent by CU
11386  *
11387  * @params[in] F1AP_PDU_t ASN decoded F1AP message
11388  * @return ROK     - success
11389  *         RFAILED - failure
11390  *
11391  * ****************************************************************/
11392 uint8_t procF1SetupRsp(F1AP_PDU_t *f1apMsg)
11393 {
11394    uint8_t ret = ROK;
11395    uint16_t idx =0;
11396    F1SetupResponse_t *f1SetRspMsg = NULLP;
11397    GNB_CU_Name_t     *cuName = NULLP;
11398    F1SetupRsp  f1SetRspDb;
11399    RRC_Version_t      *rrcVer =NULLP;
11400
11401    memset(&f1SetRspDb, 0, sizeof(F1SetupRsp));
11402
11403    DU_LOG("\nINFO   -->  F1AP : F1 Setup Response received");
11404    f1SetRspMsg = &f1apMsg->choice.successfulOutcome->value.choice.F1SetupResponse;
11405
11406    for(idx=0; idx<f1SetRspMsg->protocolIEs.list.count; idx++)
11407    {
11408       switch(f1SetRspMsg->protocolIEs.list.array[idx]->id)
11409       {
11410          case ProtocolIE_ID_id_Cells_to_be_Activated_List:
11411             {
11412                extractCellsToBeActivated(f1SetRspMsg->protocolIEs.list.array[idx]->\
11413                      value.choice.Cells_to_be_Activated_List);
11414                break;
11415             }
11416          case ProtocolIE_ID_id_TransactionID:
11417             {
11418                f1SetRspDb.transId = f1SetRspMsg->protocolIEs.list.array[idx]->\
11419                                     value.choice.TransactionID;
11420                break;
11421             }
11422          case ProtocolIE_ID_id_gNB_CU_Name:
11423             {
11424                cuName = &f1SetRspMsg->protocolIEs.list.array[idx]->\
11425                         value.choice.GNB_CU_Name;
11426                strcpy(f1SetRspDb.cuName, (const char*)cuName->buf);
11427                break;
11428             }
11429          case ProtocolIE_ID_id_GNB_CU_RRC_Version:
11430             {
11431                rrcVer = &f1SetRspMsg->protocolIEs.list.array[idx]->value.choice.RRC_Version;
11432                strcpy(f1SetRspDb.rrcVersion.rrcVer,
11433                      (const char*)rrcVer->latest_RRC_Version.buf);
11434                break;
11435             }
11436          default:
11437             DU_LOG("\nERROR  -->  DU_APP : Invalid IE received in F1SetupRsp:%ld",
11438                   f1SetRspMsg->protocolIEs.list.array[idx]->id);
11439       }
11440       duProcF1SetupRsp();
11441    }
11442
11443    freeAperDecodeF1SetupRsp(f1SetRspMsg);
11444    return ret;
11445 }
11446 /*******************************************************************
11447 *
11448 * @brief free GNB DU config update ack
11449 *
11450 * @details
11451 *
11452 *    Function : freeAperDecodeGnbDuAck
11453 *
11454 *    Functionality: Processes GNB DU config update ack And
11455 *                     added free part for the memory allocated by aper_decoder
11456 *
11457 * @params[in] F1AP_PDU_t ASN decoded F1AP message
11458 * @return ROK     - success
11459 *         RFAILED - failure
11460 *
11461 * ****************************************************************/
11462
11463 void freeAperDecodeGnbDuAck(GNBDUConfigurationUpdateAcknowledge_t *gnbDuAck)
11464 {
11465    uint8_t ieIdx = 0;
11466
11467    if(gnbDuAck->protocolIEs.list.array)
11468    {
11469       for(ieIdx=0; ieIdx < gnbDuAck->protocolIEs.list.count; ieIdx++)
11470       {
11471          if(gnbDuAck->protocolIEs.list.array[ieIdx])
11472          {
11473             free(gnbDuAck->protocolIEs.list.array[ieIdx]);
11474          }
11475       }
11476       free(gnbDuAck->protocolIEs.list.array);
11477    }
11478 }
11479 /*******************************************************************
11480 *
11481 * @brief Processes GNB DU config update ack
11482 *
11483 * @details
11484 *
11485 *    Function : procF1GNBDUCfgUpdAck
11486 *
11487 *    Functionality: added free part for the memory allocated by aper_decoder
11488 *
11489 * @params[in] F1AP_PDU_t *f1apMsg
11490 * @return void
11491 *
11492 * ****************************************************************/
11493 uint8_t procF1GNBDUCfgUpdAck(F1AP_PDU_t *f1apMsg)
11494 {
11495    uint8_t ieIdx;
11496    GNBDUConfigurationUpdateAcknowledge_t *gnbDuAck = NULLP;
11497
11498    DU_LOG("\nINFO   -->  F1AP : GNB-DU config update acknowledgment");
11499    gnbDuAck = &f1apMsg->choice.successfulOutcome->value.choice.GNBDUConfigurationUpdateAcknowledge;
11500
11501    for(ieIdx=0; ieIdx < gnbDuAck->protocolIEs.list.count; ieIdx++)
11502    {
11503       switch(gnbDuAck->protocolIEs.list.array[ieIdx]->id)
11504       {
11505          case ProtocolIE_ID_id_TransactionID:
11506             break;
11507          case ProtocolIE_ID_id_Cells_to_be_Activated_List:
11508             break;
11509          default :
11510             DU_LOG("\nERROR  -->  F1AP: Invalid IE Received: %ld, at procF1GNBDUCfgUpdAck()", \
11511             gnbDuAck->protocolIEs.list.array[ieIdx]->id);
11512             break;
11513       }
11514    }
11515    duProcGnbDuCfgUpdAckMsg();
11516 #if 0
11517    if(BuildAndSendF1ResetReq() != ROK)
11518    {
11519       return RFAILED;
11520    }
11521 #endif
11522
11523    freeAperDecodeGnbDuAck(gnbDuAck);
11524    return ROK;
11525 }
11526 /******************************************************************
11527 *
11528 * @brief free DL RRC Message Transfer allocated by aper_decoder
11529 *
11530 * @details
11531 *
11532 *    Function : freeAperDecodef1DlRrcMsg
11533 *
11534 *    Functionality: free DL RRC Message Transfer allocated by aper_decoder
11535 *
11536 * @params[in] DLRRCMessageTransfer_t *f1DlRrcMsg
11537 * @return ROK     - success
11538 *         RFAILED - failure
11539 *
11540 * ****************************************************************/
11541
11542 void freeAperDecodef1DlRrcMsg(DLRRCMessageTransfer_t *f1DlRrcMsg)
11543 {
11544    uint8_t ieIdx =0;
11545    RRCContainer_t *rrcContainer = NULLP;
11546
11547    if(f1DlRrcMsg->protocolIEs.list.array)
11548    {
11549       for(ieIdx=0; ieIdx<f1DlRrcMsg->protocolIEs.list.count; ieIdx++)
11550       {
11551          if(f1DlRrcMsg->protocolIEs.list.array[ieIdx])
11552          {
11553             switch(f1DlRrcMsg->protocolIEs.list.array[ieIdx]->id)
11554             {
11555                case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
11556                   break;
11557                case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
11558                   break;
11559                case ProtocolIE_ID_id_SRBID:
11560                   break;
11561                case ProtocolIE_ID_id_RRCContainer:
11562                   {
11563                      rrcContainer =&f1DlRrcMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer;
11564                      free(rrcContainer->buf);
11565                   }
11566                case ProtocolIE_ID_id_ExecuteDuplication:
11567                   break;
11568                case ProtocolIE_ID_id_RRCDeliveryStatusRequest:
11569                   break;
11570                   break;
11571             }
11572             free(f1DlRrcMsg->protocolIEs.list.array[ieIdx]);
11573          }
11574       }
11575       free(f1DlRrcMsg->protocolIEs.list.array);
11576    }
11577 }
11578 /******************************************************************
11579  *
11580  * @brief Processes DL RRC Message Transfer  sent by CU
11581  *
11582  * @details
11583  *
11584  *    Function : procF1DlRrcMsgTrans
11585  *
11586  *    Functionality: Processes DL RRC Message Transfer sent by CU
11587  *
11588  * @params[in] F1AP_PDU_t ASN decoded F1AP message
11589  * @return ROK     - success
11590  *         RFAILED - failure
11591  *
11592  * ****************************************************************/
11593 uint8_t procF1DlRrcMsgTrans(F1AP_PDU_t *f1apMsg)
11594 {
11595    uint8_t  idx, ret;
11596    DLRRCMessageTransfer_t *f1DlRrcMsg = NULLP;
11597    F1DlRrcMsg dlMsg;
11598    memset(&dlMsg, 0, sizeof(F1DlRrcMsg));
11599
11600    DU_LOG("\nINFO   -->  DU_APP : DL RRC message transfer Recevied");
11601    f1DlRrcMsg = &f1apMsg->choice.initiatingMessage->value.choice.DLRRCMessageTransfer;
11602
11603    ret = ROK;
11604
11605    for(idx=0; idx<f1DlRrcMsg->protocolIEs.list.count; idx++)
11606    {
11607       switch(f1DlRrcMsg->protocolIEs.list.array[idx]->id)
11608       {
11609          case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
11610             {
11611                dlMsg.gnbCuUeF1apId = f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.GNB_CU_UE_F1AP_ID;
11612                break;
11613             }
11614          case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
11615             {
11616                dlMsg.gnbDuUeF1apId = f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID;
11617                break;
11618             }
11619          case ProtocolIE_ID_id_SRBID:
11620             {
11621                dlMsg.srbId = f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.SRBID;
11622                break;
11623             }
11624          case ProtocolIE_ID_id_ExecuteDuplication:
11625             dlMsg.execDup = true;
11626             break;
11627
11628          case ProtocolIE_ID_id_RRCContainer:
11629             {
11630                if(f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.size > 0)
11631                {
11632                   dlMsg.rrcMsgSize = f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.size;
11633                   DU_ALLOC(dlMsg.rrcMsgPdu, dlMsg.rrcMsgSize);
11634                   if(dlMsg.rrcMsgPdu)
11635                   {
11636                      memcpy(dlMsg.rrcMsgPdu, f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.buf,\
11637                         dlMsg.rrcMsgSize);
11638                   }
11639                   else
11640                   {
11641                      DU_LOG("\nERROR  -->  DU APP : Memory alloc Failed at RRC Container at procF1DlRrcMsgTrans()");
11642                      return RFAILED;
11643                   }
11644                }
11645                else
11646                {
11647                   DU_LOG("\nERROR  -->  DU_APP : RRC Container Size is invalid:%ld",\
11648                   f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.size);
11649                   return RFAILED;
11650                }
11651                break;
11652             }
11653          case ProtocolIE_ID_id_RRCDeliveryStatusRequest:
11654             {
11655                dlMsg.deliveryStatRpt = true;
11656                break;
11657             }
11658          default:
11659             DU_LOG("\nERROR  -->  DU_APP : Invalid IE received in DL RRC Msg Transfer:%ld",
11660                   f1DlRrcMsg->protocolIEs.list.array[idx]->id);
11661       }
11662    }
11663
11664    ret = duProcDlRrcMsg(&dlMsg);
11665
11666    freeAperDecodef1DlRrcMsg(f1DlRrcMsg);
11667    return ret;
11668 }
11669 /*******************************************************************
11670  *
11671 * @brief Builds the DRB to be Setup Mod list
11672 *
11673 * @details
11674 *
11675 *    Function :
11676 *
11677 *    Functionality: Constructs the DRB to be Setup Mod list
11678 *
11679 * @params[in] DRBs_SetupMod_List_t *drbSet
11680 *
11681 * @return ROK     - success
11682 *         RFAILED - failure
11683 *
11684 * ****************************************************************/
11685
11686 uint8_t BuildDrbSetupModList(DRBs_SetupMod_List_t *drbSet , DuUeCfg *ueCfg)
11687 {
11688    uint8_t arrIdx =0;
11689    uint8_t drbCnt =0;
11690    struct DRBs_SetupMod_ItemIEs *drbItemIe;
11691
11692    drbCnt = 1;
11693    drbSet->list.count = drbCnt;
11694    drbSet->list.size = drbCnt * sizeof(DRBs_SetupMod_ItemIEs_t *);
11695    DU_ALLOC(drbSet->list.array, drbSet->list.size);
11696    if(drbSet->list.array == NULLP)
11697    {
11698       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDrbToBeSetupModList");
11699       return  RFAILED;
11700    }
11701    for(arrIdx=0; arrIdx<drbCnt; arrIdx++)
11702    {
11703       DU_ALLOC(drbSet->list.array[arrIdx], sizeof(DRBs_SetupMod_ItemIEs_t));
11704       if(drbSet->list.array[arrIdx] == NULLP)
11705       {
11706               DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDrbToBeSetupModList");
11707               return  RFAILED;
11708       }
11709
11710       drbItemIe = (struct DRBs_SetupMod_ItemIEs *)drbSet->list.array[arrIdx];
11711       drbItemIe->id = ProtocolIE_ID_id_DRBs_SetupMod_Item;
11712       drbItemIe->criticality = Criticality_reject;
11713       drbItemIe->value.present = DRBs_SetupMod_ItemIEs__value_PR_DRBs_SetupMod_Item;
11714       drbItemIe->value.choice.DRBs_SetupMod_Item.dRBID = ueCfg->upTnlInfo[arrIdx].drbId;
11715       if(fillDlTnlSetupList(&drbItemIe->value.choice.DRBs_SetupMod_Item.dLUPTNLInformation_ToBeSetup_List,\
11716       &ueCfg->upTnlInfo[arrIdx])!= ROK)
11717       {
11718          DU_LOG("\nERROR  -->  F1AP : Failed to fill DlTnl SetupList in BuildDrbToBeSetupModList");
11719          return RFAILED;
11720       }
11721
11722    }
11723
11724    return ROK;
11725 }
11726 /*******************************************************************
11727 * @brief Free the memory allocated for DRB setup List
11728 *
11729 * @details
11730 *
11731 *    Function : FreeDrbSetupModList
11732 *
11733 *    Functionality:
11734 *       Free the memory allocated for DRB setup list
11735 *
11736 * @params[in] DRBs_Setup_List_t *
11737 * @return void
11738 *
11739 * ****************************************************************/
11740 void FreeDrbSetupModList(DRBs_SetupMod_List_t *drbSetupList)
11741 {
11742    uint8_t arrIdx = 0;
11743    DRBs_SetupMod_ItemIEs_t *drbItemIe = NULLP;
11744
11745    for(arrIdx = 0; arrIdx < drbSetupList->list.count; arrIdx++)
11746    {
11747       drbItemIe = ((DRBs_SetupMod_ItemIEs_t *)drbSetupList->list.array[arrIdx]);
11748       freeDlTnlInfo(&drbItemIe->value.choice.DRBs_SetupMod_Item.dLUPTNLInformation_ToBeSetup_List);
11749    }
11750 }
11751 /*******************************************************************
11752 * @brief Free the memory allocated for UE Context Mod Response
11753 *
11754 * @details
11755 *
11756 *    Function : FreeUeContextModResp
11757 *
11758 *    Functionality:
11759 *       Free the memory allocated for UE Context Mod Response
11760 *
11761 * @params[in] F1AP_PDU_t *f1apMsg
11762 * @return void
11763 *
11764 * ****************************************************************/
11765
11766 void FreeUeContextModResp(F1AP_PDU_t *f1apMsg)
11767 {
11768    uint8_t ieIdx;
11769    UEContextModificationResponse_t *ueContextModifyRes = NULLP;
11770    if(f1apMsg)
11771    {
11772       if(f1apMsg->choice.successfulOutcome)
11773       {
11774          ueContextModifyRes =&f1apMsg->choice.successfulOutcome->value.choice.UEContextModificationResponse;
11775          if(ueContextModifyRes->protocolIEs.list.array)
11776          {
11777             for(ieIdx=0 ; ieIdx<ueContextModifyRes->protocolIEs.list.count; ieIdx++)
11778             {
11779                if(ueContextModifyRes->protocolIEs.list.array[ieIdx])
11780                {
11781                   switch(ueContextModifyRes->protocolIEs.list.array[ieIdx]->id)
11782                   {
11783                      case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
11784                         break;
11785                      case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
11786                         break;
11787                      case ProtocolIE_ID_id_DRBs_SetupMod_List:
11788                         {
11789                             FreeDrbSetupModList(&(ueContextModifyRes->protocolIEs.list.array[ieIdx]->\
11790                             value.choice.DRBs_SetupMod_List));
11791                             break;
11792                         }
11793                   }
11794                   DU_FREE(ueContextModifyRes->protocolIEs.list.array[ieIdx], sizeof(UEContextModificationResponse_t));
11795                }
11796
11797             }
11798             DU_FREE(ueContextModifyRes->protocolIEs.list.array, ueContextModifyRes->protocolIEs.list.size);
11799          }
11800          DU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
11801       }
11802       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
11803    }
11804 }
11805
11806 /*****************************************************************i
11807 *
11808 * @brief Creating the ue context modifcation response and sending
11809 *
11810 * @details
11811 *
11812 *    Function : BuildAndSendUeContextModResp
11813 *
11814 *    Functionality:
11815 *         - Creating the ue context modifcation response
11816 *
11817 * @params[in]
11818 * @return ROK     - success
11819 *         RFAILED - failure
11820 *
11821 * ****************************************************************/
11822 uint8_t BuildAndSendUeContextModResp(uint8_t ueIdx, uint8_t cellId)
11823 {
11824    uint8_t   ieIdx = 0;
11825    uint8_t   cellIdx =0;
11826    uint8_t   elementCnt = 0;
11827    uint8_t   ret = RFAILED;
11828    uint32_t  gnbCuUeF1apId;   /* gNB-CU UE F1AP Id */
11829    uint32_t  gnbDuUeF1apId;   /* gNB-DU UE F1AP Id */
11830    F1AP_PDU_t *f1apMsg = NULLP;
11831    asn_enc_rval_t         encRetVal;
11832    UEContextModificationResponse_t *ueContextModifyRes = NULLP;
11833    DuUeCb                   *ueCb = NULLP;
11834
11835    DU_LOG("\nINFO  -->  F1AP : Building Ue context modification response\n");
11836
11837    while(1)
11838    {
11839       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
11840       if(f1apMsg == NULLP)
11841       {
11842          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed Ue context modification");
11843          break;
11844       }
11845
11846       f1apMsg->present =  F1AP_PDU_PR_successfulOutcome;
11847
11848       DU_ALLOC(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
11849       if(f1apMsg->choice.successfulOutcome == NULLP)
11850       {
11851          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed Ue context modification");
11852          break;
11853       }
11854       f1apMsg->choice.successfulOutcome->procedureCode = ProcedureCode_id_UEContextModification;
11855       f1apMsg->choice.successfulOutcome->criticality = Criticality_reject;
11856       f1apMsg->choice.successfulOutcome->value.present = SuccessfulOutcome__value_PR_UEContextModificationResponse;
11857
11858       ueContextModifyRes =&f1apMsg->choice.successfulOutcome->value.choice.UEContextModificationResponse;
11859
11860       elementCnt = 3;
11861       ueContextModifyRes->protocolIEs.list.count = elementCnt;
11862       ueContextModifyRes->protocolIEs.list.size = elementCnt*sizeof(UEContextModificationResponse_t*);
11863
11864       /* Initialize the UE context modification members */
11865       DU_ALLOC(ueContextModifyRes->protocolIEs.list.array, ueContextModifyRes->protocolIEs.list.size);
11866       if(ueContextModifyRes->protocolIEs.list.array == NULLP)
11867       {
11868          DU_LOG("\nERROR  -->  F1AP : Memory allocation for UE context modifcation Request failed");
11869          break;
11870       }
11871
11872       for(ieIdx=0 ; ieIdx<elementCnt; ieIdx++)
11873       {
11874          DU_ALLOC(ueContextModifyRes->protocolIEs.list.array[ieIdx], sizeof(UEContextModificationResponse_t));
11875          if(ueContextModifyRes->protocolIEs.list.array[ieIdx] == NULLP)
11876          {
11877             DU_LOG("\nERROR  -->  F1AP : Memory allocation for UE context modifcation Request failed");
11878             break;
11879          }
11880       }
11881
11882       /* Fetching Ue Cb Info*/
11883       GET_CELL_IDX(cellId, cellIdx);
11884       gnbDuUeF1apId = duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].gnbDuUeF1apId;
11885       gnbCuUeF1apId = duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].gnbCuUeF1apId;
11886       ueCb = &duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1];
11887
11888       ieIdx=0;
11889       ueContextModifyRes->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
11890       ueContextModifyRes->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
11891       ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.present =\
11892       UEContextModificationResponseIEs__value_PR_GNB_CU_UE_F1AP_ID;
11893       ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID = gnbCuUeF1apId;
11894
11895       ieIdx++;
11896       ueContextModifyRes->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
11897       ueContextModifyRes->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
11898       ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.present=\
11899       UEContextModificationResponseIEs__value_PR_GNB_DU_UE_F1AP_ID;
11900       ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID = gnbDuUeF1apId;
11901
11902       ieIdx++;
11903       ueContextModifyRes->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_DRBs_SetupMod_List;
11904       ueContextModifyRes->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
11905       ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.present =\
11906       UEContextModificationResponseIEs__value_PR_DRBs_SetupMod_List;
11907       if(ueCb->f1UeDb)
11908       {
11909          ret = BuildDrbSetupModList(&(ueContextModifyRes->protocolIEs.list.array[ieIdx]->\
11910                   value.choice.DRBs_SetupMod_List) , &ueCb->f1UeDb->duUeCfg);
11911          if(ret != ROK)
11912          {
11913             DU_LOG( "\nERROR  -->  F1AP : Failed to build drb setupmod List ");
11914             break;
11915          }
11916          freeF1UeDb(ueCb->f1UeDb);
11917          ueCb->f1UeDb = NULLP;
11918       }
11919       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
11920
11921       /* Encode the F1SetupRequest type as APER */
11922       memset(encBuf, 0, ENC_BUF_MAX_LEN);
11923       encBufSize = 0;
11924       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,encBuf);
11925
11926       /* Encode results */
11927       if(encRetVal.encoded == ENCODE_FAIL)
11928       {
11929          DU_LOG( "\nERROR  -->  F1AP : Could not encode UE Context Setup Request structure (at %s)\n",\
11930                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
11931          ret = RFAILED;
11932          break;
11933       }
11934       else
11935       {
11936          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for UE Context Modification Response\n");
11937          for(int i=0; i< encBufSize; i++)
11938          {
11939             printf("%x",encBuf[i]);
11940          }
11941       }
11942
11943       /* Sending  msg  */
11944       if(SendF1APMsg(DU_APP_MEM_REGION,DU_POOL) != ROK)
11945       {
11946          DU_LOG("\nERROR  -->  F1AP : Sending UE Context Setup Res Failed");
11947          ret = RFAILED;
11948          break;
11949       }
11950       break;
11951    }
11952    FreeUeContextModResp(f1apMsg);
11953    return ret;
11954
11955 }
11956 /*******************************************************************
11957  *
11958  * @brief Deallocating the memory allocated by the aper decoder
11959  *          for QOSInfo
11960  *
11961  * @details
11962  *
11963  *    Function : freeAperDecodeQosInfo
11964  *
11965  *    Functionality:  Deallocating the memory allocated for QOSInfo
11966  *
11967  * @params[in] QoSFlowLevelQoSParameters_t *drbQos
11968  *
11969  * @return void
11970  *
11971  * ****************************************************************/
11972
11973 void freeAperDecodeQosInfo(QoSFlowLevelQoSParameters_t *drbQos)
11974 {
11975    if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI != NULLP)
11976    {
11977       if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow!=NULLP)
11978       {
11979          if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume!=NULLP)
11980          {
11981             free(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume);
11982          }
11983          free(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow);
11984       }
11985       free(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI);
11986    }
11987 }
11988 /*******************************************************************
11989  *
11990  * @brief Deallocating the memory allocated by the aper decoder
11991  *          for UlTnlInfoforDrb
11992  *
11993  * @details
11994  *
11995  *    Function : freeAperDecodeUlTnlInfoforDrbSetupMod
11996  *
11997  *    Functionality:  Deallocating memory allocated for UlTnlInfoforDrb
11998  *
11999  * @params[in] ULUPTNLInformation_ToBeSetup_List_t *ulInfo
12000  *
12001  * @return void
12002  *
12003  * ****************************************************************/
12004 void freeAperDecodeUlTnlInfoforDrbSetupMod(ULUPTNLInformation_ToBeSetup_List_t *ulInfo)
12005 {
12006    uint8_t arrIdx =0;
12007
12008    if(ulInfo->list.array)
12009    {
12010       for(arrIdx=0; arrIdx<ulInfo->list.count ; arrIdx++)
12011       {
12012          if(ulInfo->list.array[arrIdx])
12013          {
12014             if(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel )
12015             {
12016                if(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf)
12017                {
12018                   if(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf)
12019                   {
12020                      free(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
12021                            gTP_TEID.buf);
12022                   }
12023                   free(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
12024                         transportLayerAddress.buf);
12025                }
12026                free(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel);
12027             }
12028             free(ulInfo->list.array[arrIdx]);
12029          }
12030       }
12031       free(ulInfo->list.array);
12032    }
12033 }
12034 /*******************************************************************
12035  *
12036  * @brief Deallocating the memory allocated by the aper decoder
12037  *          for DrbSetupModItem
12038  *
12039  * @details
12040  *
12041  *    Function : freeAperDecodeDrbSetupModItem
12042  *
12043  *    Functionality:  Deallocating memory allocated for DrbSetupModItem
12044  *
12045  * @params[in] DRBs_ToBeSetupMod_Item_t *drbItem
12046  *
12047  * @return void
12048  *
12049  * ****************************************************************/
12050
12051 void freeAperDecodeDrbSetupModItem(DRBs_ToBeSetupMod_Item_t *drbItem)
12052 {
12053    uint8_t arrIdx =0;
12054    SNSSAI_t *snssai =NULLP;
12055    Flows_Mapped_To_DRB_List_t *flowMap = NULLP;
12056
12057    drbItem->qoSInformation.present = QoSInformation_PR_choice_extension;
12058    switch(drbItem->qoSInformation.present)
12059    {
12060       case QoSInformation_PR_NOTHING:
12061          break;
12062       case QoSInformation_PR_eUTRANQoS:
12063          {
12064             if(drbItem->qoSInformation.choice.eUTRANQoS)
12065             {
12066                free(drbItem->qoSInformation.choice.eUTRANQoS);
12067             }
12068             break;
12069          }
12070       case QoSInformation_PR_choice_extension:
12071          {
12072             if(drbItem->qoSInformation.choice.choice_extension)
12073             {
12074                freeAperDecodeQosInfo(&drbItem->qoSInformation.choice.choice_extension->value.choice.\
12075                      DRB_Information.dRB_QoS);
12076                snssai = &drbItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI;
12077                if(snssai->sST.buf)
12078                {
12079                   free(snssai->sST.buf);
12080                }
12081                if(snssai->sD)
12082                {
12083                   if(snssai->sD->buf)
12084                   {
12085                      free(snssai->sD->buf);
12086                   }
12087                   free(snssai->sD);
12088                }
12089
12090                flowMap = &drbItem->qoSInformation.choice.choice_extension->value.choice.\
12091                          DRB_Information.flows_Mapped_To_DRB_List;
12092                if(flowMap->list.array)
12093                {
12094                   for(arrIdx=0; arrIdx<flowMap->list.count; arrIdx++)
12095                   {
12096                      if(flowMap->list.array[arrIdx] )
12097                      {
12098                         freeAperDecodeQosInfo(&flowMap->list.array[arrIdx]->qoSFlowLevelQoSParameters);
12099                         free(flowMap->list.array[arrIdx]);
12100                      }
12101                   }
12102                   free(flowMap->list.array);
12103                }
12104
12105                free(drbItem->qoSInformation.choice.choice_extension);
12106             }
12107             break;
12108          }
12109
12110    }
12111    freeAperDecodeUlTnlInfoforDrbSetupMod(&drbItem->uLUPTNLInformation_ToBeSetup_List);
12112    if(drbItem->uLConfiguration)
12113    {
12114       free(drbItem->uLConfiguration);
12115    }
12116 }
12117
12118 /*******************************************************************
12119  *
12120  * @brief Deallocating the memory allocated by the aper decoder
12121  *          for DrbToBeSetupModList
12122  *
12123  * @details
12124  *
12125  *    Function : freeAperDecodeDrbToBeSetupModList
12126  *
12127  *    Functionality:  Deallocating memory allocated for DrbToBeSetupModList
12128  *
12129  * @params[in] DRBs_ToBeSetupMod_List_t *drbSet
12130  *
12131  * @return void
12132  *
12133  * ****************************************************************/
12134
12135 void freeAperDecodeDrbToBeSetupModList(DRBs_ToBeSetupMod_List_t *drbSet)
12136 {
12137    uint8_t arrIdx =0;
12138    struct DRBs_ToBeSetupMod_ItemIEs *drbItemIe;
12139
12140    if(drbSet->list.array)
12141    {
12142       for(arrIdx=0; arrIdx<drbSet->list.count ; arrIdx++)
12143       {
12144          if(drbSet->list.array[arrIdx] != NULLP)
12145          {
12146             if(arrIdx == 0)
12147             {
12148                drbItemIe = (DRBs_ToBeSetupMod_ItemIEs_t *)drbSet->list.array[arrIdx];
12149                freeAperDecodeDrbSetupModItem(&(drbItemIe->value.choice.DRBs_ToBeSetupMod_Item));
12150             }
12151             free(drbSet->list.array[arrIdx]);
12152          }
12153       }
12154       free(drbSet->list.array);
12155    }
12156
12157 }
12158 /*******************************************************************
12159  *
12160  * @brief Deallocating the memory allocated by the aper decoder
12161  *          for UeContextModificationReqMsg
12162  *
12163  * @details
12164  *
12165  *    Function : freeAperDecodeUeContextModificationReqMsg
12166  *
12167  *    Functionality:  Deallocating memory allocated for
12168  *                  UeContextModificationReqMsg
12169  *
12170  * @params[in] UEContextModificationRequest_t *UeContextModifyReq
12171  *
12172  * @return void
12173  *
12174  * ****************************************************************/
12175 void freeAperDecodeUeContextModificationReqMsg(UEContextModificationRequest_t *UeContextModifyReq )
12176 {
12177    uint8_t arrIdx, ieId;
12178
12179    if(UeContextModifyReq->protocolIEs.list.array)
12180    {
12181       for( arrIdx = 0 ; arrIdx<UeContextModifyReq->protocolIEs.list.count ; arrIdx++)
12182       {
12183          if(UeContextModifyReq->protocolIEs.list.array[arrIdx])
12184          {
12185             ieId = UeContextModifyReq->protocolIEs.list.array[arrIdx]->id;
12186             switch(ieId)
12187             {
12188                case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
12189                   break;
12190                case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
12191                   break;
12192                case ProtocolIE_ID_id_DRBs_ToBeSetupMod_List:
12193                   {
12194                      freeAperDecodeDrbToBeSetupModList(&UeContextModifyReq->protocolIEs.list.array[arrIdx]->\
12195                            value.choice.DRBs_ToBeSetupMod_List);
12196                      break;
12197                   }
12198             }
12199             free(UeContextModifyReq->protocolIEs.list.array[arrIdx]);
12200          }
12201       }
12202       free(UeContextModifyReq->protocolIEs.list.array);
12203    }
12204 }
12205 /*******************************************************************
12206  *
12207  * @brief processing the F1 UeContextModificationReq
12208  *
12209  * @details
12210  *
12211  *    Function : procF1UeContextModificationReq
12212  *
12213  *    Functionality:  processing the F1 UeContextModificationReq
12214  *
12215  * @params[in] F1AP_PDU_t *f1apMsg
12216  *
12217  * @return
12218  * ****************************************************************/
12219 uint8_t procF1UeContextModificationReq(F1AP_PDU_t *f1apMsg)
12220 {
12221    UEContextModificationRequest_t *ueContextModifyReq = NULLP;
12222    uint8_t  ret = ROK, ieIdx = 0, lcId =0,cellIdx=0, ueIdx=0;
12223    DuUeCb   *duUeCb = NULLP;
12224    DRBs_ToBeSetupMod_List_t *drbSetupModCfg;
12225    uint32_t gnbCuUeF1apId, gnbDuUeF1apId;
12226
12227    ueContextModifyReq = &f1apMsg->choice.initiatingMessage->value.choice.UEContextModificationRequest;
12228    for(ieIdx=0; (ieIdx < ueContextModifyReq->protocolIEs.list.count && ret == ROK); ieIdx++)
12229    {
12230       switch(ueContextModifyReq->protocolIEs.list.array[ieIdx]->id)
12231       {
12232          case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
12233             {
12234                gnbCuUeF1apId = ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID;
12235                break;
12236             }
12237          case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
12238             {
12239                gnbDuUeF1apId = ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID;
12240                break;
12241             }
12242          case ProtocolIE_ID_id_DRBs_ToBeSetupMod_List:
12243             {
12244                for(cellIdx = 0; cellIdx < duCb.numActvCells; cellIdx++)
12245                {
12246                   for(ueIdx = 0; ueIdx < duCb.numUe; ueIdx++)
12247                   {
12248                      if((duCb.actvCellLst[cellIdx]->ueCb[ueIdx].gnbDuUeF1apId == gnbDuUeF1apId)&&\
12249                            (duCb.actvCellLst[cellIdx]->ueCb[ueIdx].gnbCuUeF1apId == gnbCuUeF1apId))
12250                      {
12251
12252                         duUeCb = &duCb.actvCellLst[cellIdx]->ueCb[ueIdx];
12253                         lcId = getDrbLcId(&duUeCb->drbBitMap);
12254                         if(lcId != RFAILED)
12255                         {
12256                            DU_ALLOC(duUeCb->f1UeDb, sizeof(F1UeContextSetupDb));
12257                            if(duUeCb->f1UeDb)
12258                            {
12259                               duUeCb->f1UeDb->actionType = UE_CTXT_MOD;
12260                               drbSetupModCfg = &ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.\
12261                               choice.DRBs_ToBeSetupMod_List;
12262                               if(extractDrbListToSetup(lcId, NULL, drbSetupModCfg ,drbSetupModCfg->list.count, \
12263                               &duUeCb->f1UeDb->duUeCfg))
12264                               {
12265                                  DU_LOG("\nERROR  -->  DU APP : Failed at extractDrbListToSetup()");
12266                                  ret = RFAILED;
12267                               }
12268                            }
12269                         }
12270                      }
12271                      else
12272                      {
12273                         DU_LOG("\nERROR  -->  DU APP : wrong values of gnbCuUeF1apId and gnbDuUeF1apId ");
12274                         ret = RFAILED;
12275                      }
12276                   }
12277                }
12278                break;
12279             }
12280       }
12281    }
12282    if(ret != RFAILED)
12283    {
12284       ret = duProcUeContextModReq(duUeCb);
12285    }
12286    freeAperDecodeUeContextModificationReqMsg(ueContextModifyReq);
12287    return ret;
12288 }
12289 /*****************************************************************i
12290  *
12291  * @brief Handles received F1AP message and sends back response
12292  *
12293  * @details
12294  *
12295  *    Function : F1APMsgHdlr
12296  *
12297  *    Functionality:
12298  *         - Decodes received F1AP control message
12299  *         - Prepares response message, encodes and sends to SCTP
12300  *
12301  * @params[in]
12302  * @return ROK     - success
12303  *         RFAILED - failure
12304  *
12305  * ****************************************************************/
12306 void F1APMsgHdlr(Buffer *mBuf)
12307 {
12308    int i =0;
12309    char *recvBuf =NULLP;
12310    MsgLen copyCnt =0;
12311    MsgLen recvBufLen =0;
12312    F1AP_PDU_t *f1apMsg =NULLP;
12313    asn_dec_rval_t rval; /* Decoder return value */
12314    F1AP_PDU_t f1apasnmsg ;
12315    DU_LOG("\nINFO  -->  F1AP : Received F1AP message buffer");
12316    ODU_PRINT_MSG(mBuf, 0,0);
12317
12318    /* Copy mBuf into char array to decode it */
12319    ODU_GET_MSG_LEN(mBuf, &recvBufLen);
12320    DU_ALLOC(recvBuf, (Size)recvBufLen);
12321
12322    if(recvBuf == NULLP)
12323    {
12324       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed");
12325       return;
12326    }
12327    if(ODU_COPY_MSG_TO_FIX_BUF(mBuf, 0, recvBufLen, (Data *)recvBuf, &copyCnt) != ROK)
12328    {
12329       DU_LOG("\nERROR   -->  F1AP : Failed while copying %d", copyCnt);
12330       return;
12331    }
12332
12333    printf("\nDEBUG   -->  F1AP : Received flat buffer to be decoded : ");
12334    for(i=0; i< recvBufLen; i++)
12335    {
12336       printf("%x",recvBuf[i]);
12337    }
12338
12339    /* Decoding flat buffer into F1AP messsage */
12340    f1apMsg = &f1apasnmsg;
12341    memset(f1apMsg, 0, sizeof(F1AP_PDU_t));
12342
12343    rval = aper_decode(0, &asn_DEF_F1AP_PDU, (void **)&f1apMsg, recvBuf, recvBufLen, 0, 0);
12344    DU_FREE(recvBuf, (Size)recvBufLen);
12345
12346    if(rval.code == RC_FAIL || rval.code == RC_WMORE)
12347    {
12348       DU_LOG("\nERROR  -->  F1AP : ASN decode failed");
12349       return;
12350    }
12351    printf("\n");
12352    xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
12353
12354    switch(f1apMsg->present)
12355    {
12356       case F1AP_PDU_PR_successfulOutcome:
12357          {
12358             switch(f1apMsg->choice.successfulOutcome->value.present)
12359             {
12360                case SuccessfulOutcome__value_PR_ResetAcknowledge:
12361                   {
12362                      DU_LOG("\nINFO   -->  F1AP : F1ResetAcknowledge is received successfully ");
12363                      break;
12364                   }
12365                case SuccessfulOutcome__value_PR_F1SetupResponse:
12366                   {
12367 #ifndef ODU_TEST_STUB
12368                      procF1SetupRsp(f1apMsg);
12369 #endif
12370                      break;
12371                   }
12372
12373                case SuccessfulOutcome__value_PR_GNBDUConfigurationUpdateAcknowledge:
12374                   {
12375                      procF1GNBDUCfgUpdAck(f1apMsg);
12376                      break;
12377                   }
12378
12379                default:
12380                   {
12381                      DU_LOG("\nERROR  -->  F1AP : Invalid type of SuccessfulOutcome__value_PR_ResetAcknowledge [%d]",\
12382                            f1apMsg->choice.successfulOutcome->value.present);
12383                      return;
12384                   }
12385             }/* End of switch(successfulOutcome) */
12386             free(f1apMsg->choice.successfulOutcome);
12387             break;
12388          }
12389       case F1AP_PDU_PR_initiatingMessage:
12390          {
12391             switch(f1apMsg->choice.initiatingMessage->value.present)
12392             {
12393                case InitiatingMessage__value_PR_Reset:
12394                   {
12395                      procF1ResetReq(f1apMsg);
12396                      break;
12397                   }
12398                case InitiatingMessage__value_PR_DLRRCMessageTransfer:
12399                   {
12400                      procF1DlRrcMsgTrans(f1apMsg);
12401                      break;
12402                   }
12403                case InitiatingMessage__value_PR_UEContextSetupRequest:
12404                   {
12405                      procF1UeContextSetupReq(f1apMsg);
12406                      break;
12407                   }
12408                case InitiatingMessage__value_PR_UEContextModificationRequest:
12409                   {
12410                      procF1UeContextModificationReq(f1apMsg);
12411                      break;
12412                   }
12413                default:
12414                   {
12415                      DU_LOG("\nERROR  -->  F1AP : Invalid type of F1AP_PDU_PR_initiatingMessage [%d]",
12416                            f1apMsg->choice.initiatingMessage->value.present);
12417                      return;
12418                   }
12419             }/* End of switch(initiatingMessage) */
12420             free(f1apMsg->choice.initiatingMessage);
12421             break;
12422          }
12423
12424       default:
12425          {
12426             DU_LOG("\nERROR  -->  F1AP : Invalid type of f1apMsg->present [%d]",f1apMsg->present);
12427             return;
12428          }
12429          free(f1apMsg);
12430
12431    }/* End of switch(f1apMsg->present) */
12432
12433 } /* End of F1APMsgHdlr */
12434
12435 /**********************************************************************
12436   End of file
12437  **********************************************************************/