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 DuCfgParams duCfgParam;
 106
 107 /************************************************************************
 108  *
 109  * @brief Converts enum values into actual value of Poll retransmit timer
 110  *
 111  * @details
 112  *
 113  *    Function : getPollPdu
 114  *
 115  *    Functionality: Converts enum values into actual value of poll
 116  *    retransmit timer
 117  *
 118  * @params[in] Enum value of pollPdu
 119  * @return Actual value of pollPdu
 120  *
 121  * **********************************************************************/
 122
 123 uint16_t getPollRetxTmr(uint8_t pollRetxTmrCfg)
 124 {
 125    uint16_t pollRetxTmr;
 126
 127    /* All values of poll retx timer are at interval of 5ms.
 128     * This is valid upto 250ms
 129     * Hence converting the enum value to actual value by multiplying it to 5
 130     */
 131    if(pollRetxTmrCfg <= T_PollRetransmit_ms250)
 132       pollRetxTmr = (pollRetxTmrCfg + 1) * 5;
 133    else
 134    {
 135       switch(pollRetxTmrCfg)
 136       {
 137          case T_PollRetransmit_ms300:
 138             pollRetxTmr = 300;
 139             break;
 140          case T_PollRetransmit_ms350:
 141             pollRetxTmr = 350;
 142             break;
 143          case T_PollRetransmit_ms400:
 144             pollRetxTmr = 400;
 145             break;
 146          case T_PollRetransmit_ms450:
 147             pollRetxTmr = 450;
 148             break;
 149          case T_PollRetransmit_ms500:
 150             pollRetxTmr = 500;
 151             break;
 152          case T_PollRetransmit_ms800:
 153             pollRetxTmr = 800;
 154             break;
 155          default:
 156             DU_LOG("\nERROR  -->  F1AP: Invalid value of Poll Retransmit timer");
 157             pollRetxTmr = 0;
 158       }
 159    }
 160    return pollRetxTmr;
 161 }
 162
 163 /*******************************************************************
 164  *
 165  * @brief Converts enum values into actual value of PollPdu
 166  *
 167  * @details
 168  *
 169  *    Function : getPollPdu
 170  *
 171  *    Functionality: Converts enum values into actual value of PollPdu
 172  *
 173  * @params[in] Enum value of pollPdu
 174  * @return Actual value of pollPdu
 175  *
 176  * ****************************************************************/
 177 int32_t getPollPdu(uint8_t pollPduCfg)
 178 {
 179    int32_t pollPdu;
 180    switch(pollPduCfg)
 181    {
 182       case PollPDU_p4:
 183          pollPdu = 4;
 184          break;
 185       case PollPDU_p8:
 186          pollPdu = 8;
 187          break;
 188       case PollPDU_p16:
 189          pollPdu = 16;
 190          break;
 191       case PollPDU_p32:
 192          pollPdu = 32;
 193          break;
 194       case PollPDU_p64:
 195          pollPdu = 64;
 196          break;
 197       case PollPDU_p128:
 198          pollPdu = 128;
 199          break;
 200       case PollPDU_p256:
 201          pollPdu = 256;
 202          break;
 203       case PollPDU_p512:
 204          pollPdu = 512;
 205          break;
 206       case PollPDU_p1024:
 207          pollPdu = 1024;
 208          break;
 209       case PollPDU_p2048:
 210          pollPdu = 2048;
 211          break;
 212       case PollPDU_p4096:
 213          pollPdu = 4096;
 214          break;
 215       case PollPDU_p6144:
 216          pollPdu = 6144;
 217          break;
 218       case PollPDU_p8192:
 219          pollPdu = 8192;
 220          break;
 221       case PollPDU_p12288:
 222          pollPdu = 12288;
 223          break;
 224       case PollPDU_p16384:
 225          pollPdu = 16384;
 226          break;
 227       case PollPDU_p20480:
 228          pollPdu = 20480;
 229          break;
 230       case PollPDU_p24576:
 231          pollPdu = 24576;
 232          break;
 233       case PollPDU_p28672:
 234          pollPdu = 28672;
 235          break;
 236       case PollPDU_p32768:
 237          pollPdu = 32768;
 238          break;
 239       case PollPDU_p40960:
 240          pollPdu = 40960;
 241          break;
 242       case PollPDU_p49152:
 243          pollPdu = 49152;
 244          break;
 245       case PollPDU_p57344:
 246          pollPdu = 57344;
 247          break;
 248       case PollPDU_p65536:
 249          pollPdu = 65536;
 250          break;
 251       case PollPDU_infinity:
 252          pollPdu = -1;
 253          break;
 254       default:
 255          DU_LOG("\nERROR  -->  F1AP: Invalid value of poll pdu");
 256          pollPdu = 0;
 257          break;
 258    }
 259    return pollPdu;
 260 }
 261
 262 /*******************************************************************
 263  *
 264  * @brief Converts enum values into actual value of poll bytes
 265  *
 266  * @details
 267  *
 268  *    Function : getPollByte
 269  *
 270  *    Functionality: Converts enum values into actual value of pollBytes
 271  *
 272  * @params[in] Enum value
 273  * @return Actual value
 274  *
 275  * ****************************************************************/
 276 int32_t getPollByte(uint16_t pollBytesCfg)
 277 {
 278    int32_t pollBytes;
 279    switch(pollBytesCfg)
 280    {
 281       case PollByte_kB1:
 282          pollBytes = 1000;
 283          break;
 284       case PollByte_kB2:
 285          pollBytes = 2000;
 286          break;
 287       case PollByte_kB5:
 288          pollBytes = 5000;
 289          break;
 290       case PollByte_kB8:
 291          pollBytes = 8000;
 292          break;
 293       case PollByte_kB10:
 294          pollBytes = 10000;
 295          break;
 296       case PollByte_kB15:
 297          pollBytes = 15000;
 298          break;
 299       case PollByte_kB25:
 300          pollBytes = 25000;
 301          break;
 302       case PollByte_kB50:
 303          pollBytes = 50000;
 304          break;
 305       case PollByte_kB75:
 306          pollBytes = 75000;
 307          break;
 308       case PollByte_kB100:
 309          pollBytes = 100000;
 310          break;
 311       case PollByte_kB125:
 312          pollBytes = 125000;
 313          break;
 314       case PollByte_kB250:
 315          pollBytes = 250000;
 316          break;
 317       case PollByte_kB375:
 318          pollBytes = 375000;
 319          break;
 320       case PollByte_kB500:
 321          pollBytes = 500000;
 322          break;
 323       case PollByte_kB750:
 324          pollBytes = 750000;
 325          break;
 326       case PollByte_kB1000:
 327          pollBytes = 1000000;
 328          break;
 329       case PollByte_kB1250:
 330          pollBytes = 1250000;
 331          break;
 332       case PollByte_kB1500:
 333          pollBytes = 1500000;
 334          break;
 335       case PollByte_kB2000:
 336          pollBytes = 2000000;
 337          break;
 338       case PollByte_kB3000:
 339          pollBytes = 3000000;
 340          break;
 341       case PollByte_kB4000:
 342          pollBytes = 4000000;
 343          break;
 344       case PollByte_kB4500:
 345          pollBytes = 4500000;
 346          break;
 347       case PollByte_kB5000:
 348          pollBytes = 5000000;
 349          break;
 350       case PollByte_kB5500:
 351          pollBytes = 5500000;
 352          break;
 353       case PollByte_kB6000:
 354          pollBytes = 6000000;
 355          break;
 356       case PollByte_kB6500:
 357          pollBytes = 6500000;
 358          break;
 359       case PollByte_kB7000:
 360          pollBytes = 7000000;
 361          break;
 362       case PollByte_kB7500:
 363          pollBytes = 7500000;
 364          break;
 365       case PollByte_mB8:
 366          pollBytes = 8000000;
 367          break;
 368       case PollByte_mB9:
 369          pollBytes = 9000000;
 370          break;
 371       case PollByte_mB10:
 372          pollBytes = 10000000;
 373          break;
 374       case PollByte_mB11:
 375          pollBytes = 11000000;
 376          break;
 377       case PollByte_mB12:
 378          pollBytes = 12000000;
 379          break;
 380       case PollByte_mB13:
 381          pollBytes = 13000000;
 382          break;
 383       case PollByte_mB14:
 384          pollBytes = 14000000;
 385          break;
 386       case PollByte_mB15:
 387          pollBytes = 15000000;
 388          break;
 389       case PollByte_mB16:
 390          pollBytes = 16000000;
 391          break;
 392       case PollByte_mB17:
 393          pollBytes = 17000000;
 394          break;
 395       case PollByte_mB18:
 396          pollBytes = 18000000;
 397          break;
 398       case PollByte_mB20:
 399          pollBytes = 20000000;
 400          break;
 401       case PollByte_mB25:
 402          pollBytes = 25000000;
 403          break;
 404       case PollByte_mB30:
 405          pollBytes = 30000000;
 406          break;
 407       case PollByte_mB40:
 408          pollBytes = 40000000;
 409          break;
 410       case PollByte_infinity:
 411          pollBytes = -1;
 412          break;
 413       default:
 414          DU_LOG("\nERROR  -->  F1AP: Invalid value of poll bytes");
 415          pollBytes = 0;
 416    }
 417    return pollBytes;
 418 }
 419
 420 /*******************************************************************
 421  *
 422  * @brief Converts enum values into actual value of maxRetx
 423  *
 424  * @details
 425  *
 426  *    Function : getMaxRetx
 427  *
 428  *    Functionality: Converts enum values into actual value of maxRetx
 429  *
 430  * @params[in] Enum value
 431  * @return Actual value
 432  *
 433  * ****************************************************************/
 434 uint8_t getMaxRetx(uint8_t maxRetxCfg)
 435 {
 436    uint8_t maxRetx;
 437    switch(maxRetxCfg)
 438    {
 439       case UL_AM_RLC__maxRetxThreshold_t1:
 440          maxRetx = 1;
 441          break;
 442       case UL_AM_RLC__maxRetxThreshold_t2:
 443          maxRetx = 2;
 444          break;
 445       case UL_AM_RLC__maxRetxThreshold_t3:
 446          maxRetx = 3;
 447          break;
 448       case UL_AM_RLC__maxRetxThreshold_t4:
 449          maxRetx = 4;
 450          break;
 451       case UL_AM_RLC__maxRetxThreshold_t6:
 452          maxRetx = 6;
 453          break;
 454       case UL_AM_RLC__maxRetxThreshold_t8:
 455          maxRetx = 8;
 456          break;
 457       case UL_AM_RLC__maxRetxThreshold_t16:
 458          maxRetx = 16;
 459          break;
 460       case UL_AM_RLC__maxRetxThreshold_t32:
 461          maxRetx = 32;
 462          break;
 463       default:
 464          DU_LOG("\nERROR  -->  F1AP: Invalid configuration for Max retransmission threshold");
 465          maxRetx = 0;
 466    }
 467    return maxRetx;
 468 }
 469
 470 /*******************************************************************
 471  * @brief Converts enum values into actual value of reassembly timer
 472  *
 473  * @details
 474  *
 475  *    Function : getReAsmblTmr
 476  *
 477  *    Functionality: Converts enum values into actual value of reassembly
 478  *    timer
 479  *
 480  * @params[in] Enum value of reassembly timer
 481  * @return Actual value of reassembly timer
 482  *
 483  * **********************************************************************/
 484
 485 int8_t getReAsmblTmr(uint8_t reAsmblTmrCfg)
 486 {
 487    int8_t reAsmblTmr = 0;
 488
 489    if(reAsmblTmrCfg == T_Reassembly_ms0)
 490    {
 491       reAsmblTmr = 0;
 492    }
 493    else if(reAsmblTmrCfg >= T_Reassembly_ms5 || reAsmblTmrCfg <= T_Reassembly_ms100)
 494    {
 495      /* All values of re assembly timer are at interval of 5ms.
 496       * This is valid upto 100ms
 497       * Hence converting the enum value to actual value by multiplying it to 5
 498       */
 499       reAsmblTmr = reAsmblTmrCfg * 5;
 500    }
 501    else if(reAsmblTmrCfg >= T_Reassembly_ms110 || reAsmblTmrCfg <= T_Reassembly_ms200)
 502    {
 503      /* All values of re assembly timer are at interval of 10ms.
 504       * This is valid upto 200ms
 505       * since enum value starts from 20 for 100ms, subtracting 10 and
 506       * converting the enum value to actual value by multiplying it to 10
 507       */
 508       reAsmblTmr = ((reAsmblTmrCfg-10) * 10);
 509    }
 510    else
 511    {
 512       DU_LOG("\nERROR  -->  F1AP : Invalid value of Re Assembly timer %d", reAsmblTmrCfg);
 513       reAsmblTmr = -1;
 514    }
 515    return reAsmblTmr;
 516 }
 517
 518 /************************************************************************
 519  *
 520  * @brief Converts enum values into actual value of status prohibit timer
 521  *
 522  * @details
 523  *
 524  *    Function : getStatProhTmr
 525  *
 526  *    Functionality: Converts enum values into actual value of status prohibit
 527  *    timer
 528  *
 529  * @params[in] Enum value of status prohibit timer
 530  * @return Actual value of status prohibit timer
 531  *
 532  * **********************************************************************/
 533
 534 int16_t getStatProhTmr(uint8_t statProhTmrCfg)
 535 {
 536    int16_t statProhTmr =0;
 537
 538    if(statProhTmrCfg == T_StatusProhibit_ms0)
 539    {
 540       statProhTmr = 0;
 541    }
 542    else if(statProhTmrCfg >= T_StatusProhibit_ms5 || statProhTmrCfg <= T_StatusProhibit_ms250)
 543    {
 544       /* All values of re assembly timer are at interval of 5ms.
 545        * This is valid upto 250ms
 546        * Hence converting the enum value to actual value by multiplying it to 5
 547        */
 548       statProhTmr = statProhTmrCfg * 5;
 549    }
 550    else
 551    {
 552       switch(statProhTmrCfg)
 553       {
 554          case T_StatusProhibit_ms300:
 555             statProhTmr = 300;
 556             break;
 557          case T_StatusProhibit_ms350:
 558             statProhTmr = 350;
 559             break;
 560          case T_StatusProhibit_ms400:
 561             statProhTmr = 400;
 562             break;
 563          case T_StatusProhibit_ms450:
 564             statProhTmr = 450;
 565             break;
 566          case T_StatusProhibit_ms500:
 567             statProhTmr = 500;
 568             break;
 569          case T_StatusProhibit_ms800:
 570             statProhTmr = 800;
 571             break;
 572          case T_StatusProhibit_ms1000:
 573             statProhTmr = 1000;
 574             break;
 575          case T_StatusProhibit_ms1200:
 576             statProhTmr = 1200;
 577             break;
 578          case T_StatusProhibit_ms1600:
 579             statProhTmr = 1600;
 580             break;
 581          case T_StatusProhibit_ms2000:
 582             statProhTmr = 2000;
 583             break;
 584          case T_StatusProhibit_ms2400:
 585             statProhTmr = 2400;
 586             break;
 587          default:
 588             DU_LOG("\nInvalid value of Status Prohibit timer %d", statProhTmrCfg);
 589             statProhTmr = -1;
 590             break;
 591       }
 592    }
 593    return statProhTmr;
 594 }
 595
 596 /*******************************************************************
 597  *
 598  * @brief Builds Uplink Info for NR
 599  *
 600  * @details
 601  *
 602  *    Function : BuildULNRInfo
 603  *
 604  *    Functionality: Building NR Uplink Info
 605  *
 606  * @params[in] NRFreqInfo_t *ulnrfreq
 607  * @return ROK     - success
 608  *         RFAILED - failure
 609  *
 610  * ****************************************************************/
 611 uint8_t BuildULNRInfo(NRFreqInfo_t *ulnrfreq)
 612 {
 613    uint8_t idx=0;
 614    ulnrfreq->nRARFCN = duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.\
 615                        fdd.ulNrFreqInfo.nrArfcn;
 616    ulnrfreq->freqBandListNr.list.count = 1;
 617    ulnrfreq->freqBandListNr.list.size = sizeof(FreqBandNrItem_t *);
 618    DU_ALLOC(ulnrfreq->freqBandListNr.list.array,ulnrfreq->freqBandListNr.list.size);
 619    if(ulnrfreq->freqBandListNr.list.array == NULLP)
 620    {
 621       return RFAILED;
 622    }
 623    for(idx=0;idx<ulnrfreq->freqBandListNr.list.count;idx++)
 624    {
 625       DU_ALLOC(ulnrfreq->freqBandListNr.list.array[idx],sizeof(FreqBandNrItem_t));
 626       if(ulnrfreq->freqBandListNr.list.array[idx] == NULLP)
 627       {
 628          return RFAILED;
 629       }
 630    }
 631    ulnrfreq->freqBandListNr.list.array[0]->freqBandIndicatorNr = \
 632                                                                  duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.fdd.ulNrFreqInfo.\
 633                                                                  freqBand[0].nrFreqBand;
 634    ulnrfreq->freqBandListNr.list.array[0]->supportedSULBandList.list.count = SUL_BAND_COUNT;
 635    return ROK;
 636 }
 637 /*******************************************************************
 638  *
 639  * @brief Builds Downlink NR Info
 640  *
 641  * @details
 642  *
 643  *    Function : BuildDLNRInfo
 644  *
 645  *    Functionality: Building Downlink NR Info
 646  *
 647  * @params[in] NRFreqInfo_t *dlnrfreq
 648  * @return ROK     - success
 649  *         RFAILED - failure
 650  *
 651  * ****************************************************************/
 652 uint8_t BuildDLNRInfo(NRFreqInfo_t *dlnrfreq)
 653 {
 654    uint8_t idx=0;
 655    dlnrfreq->nRARFCN = duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.\
 656                        fdd.dlNrFreqInfo.nrArfcn;
 657    dlnrfreq->freqBandListNr.list.count = 1;
 658    dlnrfreq->freqBandListNr.list.size = sizeof(FreqBandNrItem_t *);
 659    DU_ALLOC(dlnrfreq->freqBandListNr.list.array,dlnrfreq->freqBandListNr.list.size);
 660    if(dlnrfreq->freqBandListNr.list.array == NULLP)
 661    {
 662       return RFAILED;
 663    }
 664    for(idx=0;idx< dlnrfreq->freqBandListNr.list.count;idx++)
 665    {
 666       DU_ALLOC(dlnrfreq->freqBandListNr.list.array[idx],sizeof(FreqBandNrItem_t));
 667       if(dlnrfreq->freqBandListNr.list.array[idx] == NULLP)
 668       {
 669          return RFAILED;
 670       }
 671    }
 672    dlnrfreq->freqBandListNr.list.array[0]->freqBandIndicatorNr = \
 673                                                                  duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.fdd.dlNrFreqInfo.\
 674                                                                  freqBand[0].nrFreqBand;
 675    dlnrfreq->freqBandListNr.list.array[0]->supportedSULBandList.list.count = SUL_BAND_COUNT;
 676
 677    return ROK;
 678 }
 679
 680 /*******************************************************************
 681  *
 682  * @brief Builds NRCell ID
 683  *
 684  * @details
 685  *
 686  *    Function : BuildNrCellId
 687  *
 688  *    Functionality: Building the NR Cell ID
 689  *
 690  * @params[in] BIT_STRING_t *nrcell
 691  * @return ROK     - success
 692  *         RFAILED - failure
 693  *
 694  * ****************************************************************/
 695
 696 S16 BuildNrCellId(BIT_STRING_t *nrcell)
 697 {
 698    memset(nrcell->buf, 0, nrcell->size);
 699    nrcell->buf[4]   = 16;
 700    nrcell->bits_unused = 4;
 701    return ROK;
 702 }
 703
 704 /*******************************************************************
 705  *
 706  * @brief Builds Nrcgi
 707  *
 708  * @details
 709  *
 710  *    Function : BuildNrcgi
 711  *
 712  *    Functionality: Building the PLMN ID and NR Cell id
 713  *
 714  * @params[in] NRCGI_t *nrcgi
 715  * @return ROK     - success
 716  *         RFAILED - failure
 717  *
 718  * ****************************************************************/
 719 uint8_t BuildNrcgi(NRCGI_t *nrcgi)
 720 {
 721    uint8_t ret;
 722    uint8_t byteSize = 5;
 723    /* Allocate Buffer Memory */
 724    nrcgi->pLMN_Identity.size = PLMN_SIZE * sizeof(uint8_t);
 725    DU_ALLOC(nrcgi->pLMN_Identity.buf, nrcgi->pLMN_Identity.size);
 726    if(nrcgi->pLMN_Identity.buf == NULLP)
 727    {
 728       return RFAILED;
 729    }
 730    ret = buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrCgi.plmn,\
 731          nrcgi->pLMN_Identity.buf); // Building PLMN function
 732    if(ret != ROK)
 733    {
 734       return RFAILED;
 735    }
 736    /*nrCellIdentity*/
 737    nrcgi->nRCellIdentity.size = byteSize * sizeof(uint8_t);
 738    DU_ALLOC(nrcgi->nRCellIdentity.buf, nrcgi->nRCellIdentity.size);
 739    if(nrcgi->nRCellIdentity.buf == NULLP)
 740    {
 741       return RFAILED;
 742    }
 743    BuildNrCellId(&nrcgi->nRCellIdentity);
 744
 745    return ROK;
 746 }
 747 /*******************************************************************
 748  *
 749  * @brief Builds FiveGStac
 750  *
 751  * @details
 752  *
 753  *    Function : BuildFiveGSTac
 754  *
 755  *    Functionality: Building the FiveGSTac
 756  *
 757  * @params[in] OCTET_STRING_t *fivegsTac
 758  * @return ROK     - success
 759  *         RFAILED - failure
 760  *
 761  * ****************************************************************/
 762 uint8_t BuildFiveGSTac(Served_Cell_Information_t *servcell)
 763 {
 764    DU_ALLOC(servcell->fiveGS_TAC,sizeof(FiveGS_TAC_t));
 765    if(servcell->fiveGS_TAC == NULLP)
 766    {
 767       return RFAILED;
 768    }
 769    servcell->fiveGS_TAC->size = 3 * sizeof(uint8_t);
 770    DU_ALLOC(servcell->fiveGS_TAC->buf,\
 771          sizeof(servcell->fiveGS_TAC->size));
 772    if(servcell->fiveGS_TAC->buf == NULLP)
 773    {
 774       return RFAILED;
 775    }
 776    servcell->fiveGS_TAC->buf[0] = 0;
 777    servcell->fiveGS_TAC->buf[1] = 0;
 778    servcell->fiveGS_TAC->buf[2] = duCfgParam.srvdCellLst[0].duCellInfo.tac;
 779    return ROK;
 780 }
 781 /*******************************************************************
 782  *
 783  * @brief Builds NR Mode
 784  *
 785  * @details
 786  *
 787  *    Function : BuildNrMode
 788  *
 789  *    Functionality: Building the NR Mode
 790  *
 791  * @params[in] NR_Mode_Info_t *fdd
 792  * @return ROK     - success
 793  *         RFAILED - failure
 794  *
 795  * ****************************************************************/
 796 uint8_t BuildNrMode(NR_Mode_Info_t *mode)
 797 {
 798    uint8_t BuildDLNRInforet=0;
 799    uint8_t BuildULNRInforet=0;
 800    /* FDD Mode */
 801    mode->present = NR_Mode_Info_PR_fDD;
 802    if(mode->present == NR_Mode_Info_PR_fDD)
 803    {
 804       DU_ALLOC(mode->choice.fDD,sizeof(FDD_Info_t));
 805       if(mode->choice.fDD == NULLP)
 806       {
 807          return RFAILED;
 808       }
 809       BuildULNRInforet = BuildULNRInfo(&mode->choice.fDD->uL_NRFreqInfo);
 810       if(BuildULNRInforet != ROK)
 811       {
 812          return RFAILED;
 813       }
 814       BuildDLNRInforet = BuildDLNRInfo(&mode->choice.fDD->dL_NRFreqInfo);
 815       if(BuildDLNRInforet != ROK)
 816       {
 817          return RFAILED;
 818       }
 819    }
 820    mode->choice.fDD->uL_Transmission_Bandwidth.nRSCS = \
 821                                                        duCfgParam.srvdCellLst[0].duCellInfo.\
 822                                                        f1Mode.mode.fdd.ulTxBw.nrScs;
 823    mode->choice.fDD->uL_Transmission_Bandwidth.nRNRB = \
 824                                                        duCfgParam.srvdCellLst[0].duCellInfo.\
 825                                                        f1Mode.mode.fdd.ulTxBw.nrb;
 826    mode->choice.fDD->dL_Transmission_Bandwidth.nRSCS = \
 827                                                        duCfgParam.srvdCellLst[0].duCellInfo.\
 828                                                        f1Mode.mode.fdd.dlTxBw.nrScs;
 829    mode->choice.fDD->dL_Transmission_Bandwidth.nRNRB = \
 830                                                        duCfgParam.srvdCellLst[0].duCellInfo.\
 831                                                        f1Mode.mode.fdd.dlTxBw.nrb;
 832    return ROK;
 833 }
 834 /*******************************************************************
 835  *
 836  * @brief Builds IE Extensions for Served PLMNs
 837  *
 838  * @details
 839  *
 840  *    Function : BuildExtensions
 841  *
 842  *    Functionality: Building the IE Extensions
 843  *
 844  * @params[in] struct ProtocolExtensionContainer_4624P3 *buildextend
 845  * @return ROK     - success
 846  *         RFAILED - failure
 847  *
 848  * ****************************************************************/
 849 uint8_t BuildExtensions(ProtocolExtensionContainer_4624P3_t **ieExtend)
 850 {
 851    uint8_t idx;
 852    uint8_t plmnidx;
 853    uint8_t extensionCnt=1;
 854    uint8_t sliceId=0;
 855    uint8_t sdId;
 856    DU_ALLOC(*ieExtend,sizeof(ProtocolExtensionContainer_4624P3_t));
 857    if((*ieExtend) == NULLP)
 858    {
 859       return RFAILED;
 860    }
 861    (*ieExtend)->list.count = extensionCnt;
 862    (*ieExtend)->list.size = \
 863                             extensionCnt * sizeof(ServedPLMNs_ItemExtIEs_t *);
 864    DU_ALLOC((*ieExtend)->list.array,(*ieExtend)->list.size);
 865    if((*ieExtend)->list.array == NULLP)
 866    {
 867       return RFAILED;
 868    }
 869    for(plmnidx=0;plmnidx<extensionCnt;plmnidx++)
 870    {
 871       DU_ALLOC((*ieExtend)->list.array[plmnidx],\
 872             sizeof(ServedPLMNs_ItemExtIEs_t));
 873       if((*ieExtend)->list.array[plmnidx] == NULLP)
 874       {
 875          return RFAILED;
 876       }
 877    }
 878    idx = 0;
 879    (*ieExtend)->list.array[idx]->id = ProtocolIE_ID_id_TAISliceSupportList;
 880    (*ieExtend)->list.array[idx]->criticality = Criticality_ignore;
 881    (*ieExtend)->list.array[idx]->extensionValue.present = \
 882                                                           ServedPLMNs_ItemExtIEs__extensionValue_PR_SliceSupportList;
 883    (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 884       list.count = 1;
 885    (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 886       list.size = sizeof(SliceSupportItem_t *);
 887    DU_ALLOC((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 888          list.array,sizeof(SliceSupportItem_t *));
 889    if((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 890          list.array == NULLP)
 891    {
 892       return RFAILED;
 893    }
 894    DU_ALLOC((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 895          list.array[sliceId],sizeof(SliceSupportItem_t));
 896    if((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 897          list.array[sliceId] == NULLP)
 898    {
 899       return RFAILED;
 900    }
 901    (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 902       list.array[sliceId]->sNSSAI.sST.size = sizeof(uint8_t);
 903    DU_ALLOC((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList\
 904          .list.array[sliceId]->sNSSAI.sST.buf,(*ieExtend)->list.array[idx]->\
 905          extensionValue.choice.SliceSupportList.\
 906          list.array[sliceId]->sNSSAI.sST.size);
 907    if((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList\
 908          .list.array[sliceId]->sNSSAI.sST.buf == NULLP)
 909    {
 910       return RFAILED;
 911    }
 912    (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 913       list.array[sliceId]->sNSSAI.sST.buf[0] = 3;
 914    DU_ALLOC((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 915          list.array[sliceId]->sNSSAI.sD,sizeof(OCTET_STRING_t));
 916    if((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 917          list.array[sliceId]->sNSSAI.sD == NULLP)
 918    {
 919       return RFAILED;
 920    }
 921    (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 922       list.array[sliceId]->sNSSAI.sD->size = 3*sizeof(uint8_t);
 923    DU_ALLOC((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 924          list.array[sliceId]->sNSSAI.sD->buf,(*ieExtend)->list.array[idx]->extensionValue.choice.\
 925          SliceSupportList.list.array[sliceId]->sNSSAI.sD->size);
 926    if((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 927          list.array[sliceId]->sNSSAI.sD->buf == NULLP)
 928    {
 929       return RFAILED;
 930    }
 931    sdId = 0;
 932    (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 933       list.array[sliceId]->sNSSAI.sD->buf[sdId] = 3;
 934    sdId++;
 935    (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 936       list.array[sliceId]->sNSSAI.sD->buf[sdId] = 6;
 937    sdId++;
 938    (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 939       list.array[sliceId]->sNSSAI.sD->buf[sdId] = 9;
 940    return ROK;
 941 }
 942 /*******************************************************************
 943  *
 944  * @brief Builds Served PLMN
 945  *
 946  * @details
 947  *
 948  *    Function : BuildServedPlmn
 949  *
 950  *    Functionality: Building the Served PLMN
 951  *
 952  * @params[in] GNB_DU_Served_Cells_Item_t *srvCellItem
 953  * @return ROK     - success
 954  *         RFAILED - failure
 955  *
 956  * ****************************************************************/
 957 uint8_t  BuildServedPlmn(ServedPLMNs_List_t *srvplmn)
 958 {
 959    uint8_t  plmnidx;
 960    uint8_t  servPlmnCnt=1;
 961    uint8_t buildPlmnIdret=0;
 962    uint8_t BuildExtensionsret=0;
 963    srvplmn->list.count = servPlmnCnt;
 964    srvplmn->list.size = \
 965                         servPlmnCnt*sizeof(ServedPLMNs_Item_t *);
 966    DU_ALLOC(srvplmn->list.array,srvplmn->list.size);
 967    if(srvplmn->list.array == NULLP)
 968    {
 969       return RFAILED;
 970    }
 971    for(plmnidx=0; plmnidx<servPlmnCnt; plmnidx++)
 972    {
 973       DU_ALLOC(srvplmn->list.array[plmnidx],\
 974             sizeof(ServedPLMNs_Item_t));
 975       if(srvplmn->list.array[plmnidx] == NULLP)
 976       {
 977          return RFAILED;
 978       }
 979    }
 980    srvplmn->list.array[0]->pLMN_Identity.size = PLMN_SIZE * sizeof(uint8_t);
 981    DU_ALLOC(srvplmn->list.array[0]->pLMN_Identity.buf, srvplmn->list.array[0]->pLMN_Identity.size);
 982    buildPlmnIdret = buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrCgi.plmn,\
 983          srvplmn->list.array[0]->pLMN_Identity.buf);
 984    if(buildPlmnIdret!= ROK)
 985    {
 986       return RFAILED;
 987    }
 988    BuildExtensionsret = BuildExtensions(&srvplmn->list.array[0]->iE_Extensions);
 989    if(BuildExtensionsret!= ROK)
 990    {
 991       return RFAILED;
 992    }
 993    return ROK;
 994 }
 995 /*******************************************************************
 996  *
 997  * @brief Builds Served Cell List
 998  *
 999  * @details
1000  *
1001  *    Function : BuildServedCellList
1002  *
1003  *    Functionality: Building Served Cell List
1004  *
1005  * @params[in] PLMNID plmn
1006  * @return ROK     - success
1007  *         RFAILED - failure
1008  *
1009  * ****************************************************************/
1010
1011 uint8_t BuildServedCellList(GNB_DU_Served_Cells_List_t *duServedCell)
1012 {
1013    uint8_t  BuildNrcgiret=0;
1014    uint8_t  BuildFiveGSTacret=0;
1015    uint8_t  BuildServedPlmnret=0;
1016    uint8_t  BuildNrModeret=0;
1017    uint8_t  idx;
1018    uint8_t  plmnidx;
1019    uint8_t  plmnCnt=1;
1020    GNB_DU_Served_Cells_Item_t *srvCellItem;
1021    duServedCell->list.size = plmnCnt * sizeof(GNB_DU_Served_Cells_ItemIEs_t *);
1022    duServedCell->list.count = plmnCnt;
1023
1024    DU_ALLOC(duServedCell->list.array, duServedCell->list.size);
1025    if(duServedCell->list.array == NULLP)
1026    {
1027       return RFAILED;
1028    }
1029    for(plmnidx=0; plmnidx<plmnCnt; plmnidx++)
1030    {
1031       DU_ALLOC(duServedCell->list.array[plmnidx],\
1032             sizeof(GNB_DU_Served_Cells_ItemIEs_t));
1033       if(duServedCell->list.array[plmnidx] == NULLP)
1034       {
1035          return RFAILED;
1036       }
1037    }
1038    idx = 0;
1039    duServedCell->list.array[idx]->id = ProtocolIE_ID_id_GNB_DU_Served_Cells_Item;
1040    duServedCell->list.array[idx]->criticality = Criticality_reject;
1041    duServedCell->list.array[idx]->value.present = \
1042                                                   GNB_DU_Served_Cells_ItemIEs__value_PR_GNB_DU_Served_Cells_Item;
1043    srvCellItem = \
1044                  &duServedCell->list.array[idx]->value.choice.GNB_DU_Served_Cells_Item;
1045    /*nRCGI*/
1046    BuildNrcgiret = BuildNrcgi(&srvCellItem->served_Cell_Information.nRCGI);
1047    if(BuildNrcgiret != ROK)
1048    {
1049       return RFAILED;
1050    }
1051    /*nRPCI*/
1052    srvCellItem->served_Cell_Information.nRPCI = \
1053                                                 duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrPci;
1054
1055    /*fiveGS_TAC*/
1056    BuildFiveGSTacret = BuildFiveGSTac(&srvCellItem->served_Cell_Information);
1057    if(BuildFiveGSTacret != ROK)
1058    {
1059       return RFAILED;
1060    }
1061    /*Served PLMNs*/
1062    BuildServedPlmnret = BuildServedPlmn(&srvCellItem->served_Cell_Information.servedPLMNs);
1063    if(BuildServedPlmnret !=ROK)
1064    {
1065       return RFAILED;
1066    }
1067    /*nR Mode Info with FDD*/
1068    BuildNrModeret = BuildNrMode(&srvCellItem->served_Cell_Information.nR_Mode_Info);
1069    if(BuildNrModeret != ROK)
1070    {
1071       return RFAILED;
1072    }
1073    /*Measurement timing Config*/
1074    srvCellItem->served_Cell_Information.measurementTimingConfiguration.\
1075       size = sizeof(uint8_t);
1076    DU_ALLOC(srvCellItem->served_Cell_Information.\
1077          measurementTimingConfiguration.buf,srvCellItem->served_Cell_Information.measurementTimingConfiguration.size);
1078    if(srvCellItem->served_Cell_Information.\
1079          measurementTimingConfiguration.buf == NULLP)
1080    {
1081       return RFAILED;
1082    }
1083    srvCellItem->served_Cell_Information.measurementTimingConfiguration.buf[0] = \
1084                                                                                 duCfgParam.srvdCellLst[0].duCellInfo.measTimeCfg;
1085
1086    /* GNB DU System Information */
1087    DU_ALLOC(srvCellItem->gNB_DU_System_Information,
1088          sizeof(GNB_DU_System_Information_t));
1089    if(!srvCellItem->gNB_DU_System_Information)
1090    {
1091       return RFAILED;
1092    }
1093    /* MIB */
1094    srvCellItem->gNB_DU_System_Information->mIB_message.size = duCfgParam.srvdCellLst[0].duSysInfo.mibLen;
1095    DU_ALLOC(srvCellItem->gNB_DU_System_Information->mIB_message.buf,
1096          srvCellItem->gNB_DU_System_Information->mIB_message.size);
1097    if(!srvCellItem->gNB_DU_System_Information->mIB_message.buf)
1098    {
1099       return RFAILED;
1100    }
1101    memcpy(srvCellItem->gNB_DU_System_Information->mIB_message.buf, duCfgParam.srvdCellLst[0].duSysInfo.mibMsg, \
1102                    srvCellItem->gNB_DU_System_Information->mIB_message.size);
1103
1104    /* SIB1 */
1105    srvCellItem->gNB_DU_System_Information->sIB1_message.size =\
1106                                                               duCfgParam.srvdCellLst[0].duSysInfo.sib1Len;
1107
1108    DU_ALLOC(srvCellItem->gNB_DU_System_Information->sIB1_message.buf,
1109          srvCellItem->gNB_DU_System_Information->sIB1_message.size);
1110    if(!srvCellItem->gNB_DU_System_Information->sIB1_message.buf)
1111    {
1112       return RFAILED;
1113    }
1114    for(int x=0; x<srvCellItem->gNB_DU_System_Information->sIB1_message.size; x++)
1115    {
1116       srvCellItem->gNB_DU_System_Information->sIB1_message.buf[x]=\
1117                                                                   duCfgParam.srvdCellLst[0].duSysInfo.sib1Msg[x];
1118    }
1119    return ROK;
1120 }
1121 /*******************************************************************
1122  *
1123  * @brief Builds RRC Version
1124  *
1125  * @details
1126  *
1127  *    Function : BuildRrcVer
1128  *
1129  *    Functionality: Building RRC Version
1130  *
1131  * @params[in] int idx,int elementCnt,RRC_Version_t *rrcver
1132  * @return ROK     - success
1133  *         RFAILED - failure
1134  *
1135  * ****************************************************************/
1136 uint8_t BuildRrcVer(RRC_Version_t *rrcVer)
1137 {
1138    uint8_t rrcExt;
1139    uint8_t rrcLatest;
1140    rrcVer->latest_RRC_Version.size = sizeof(uint8_t);
1141    DU_ALLOC(rrcVer->latest_RRC_Version.buf,sizeof(uint8_t));
1142    if(rrcVer->latest_RRC_Version.buf == NULLP)
1143    {
1144       return RFAILED;
1145    }
1146    rrcVer->latest_RRC_Version.buf[0] = 0;
1147    rrcVer->latest_RRC_Version.bits_unused = 5;
1148    DU_ALLOC(rrcVer->iE_Extensions,sizeof(ProtocolExtensionContainer_4624P81_t));
1149    if(rrcVer->iE_Extensions == NULLP)
1150    {
1151       return RFAILED;
1152    }
1153    rrcVer->iE_Extensions->list.count = 1;
1154    rrcVer->iE_Extensions->list.size = sizeof(RRC_Version_ExtIEs_t *);
1155    DU_ALLOC(rrcVer->iE_Extensions->list.array,rrcVer->iE_Extensions->list.size);
1156    if(rrcVer->iE_Extensions->list.array == NULLP)
1157    {
1158       return RFAILED;
1159    }
1160    rrcExt = 0;
1161    DU_ALLOC(rrcVer->iE_Extensions->list.array[0],\
1162          sizeof(RRC_Version_ExtIEs_t));
1163    if(rrcVer->iE_Extensions->list.array[0] == NULLP)
1164    {
1165       return RFAILED;
1166    }
1167    rrcVer->iE_Extensions->list.array[rrcExt]->id = \
1168                                                    ProtocolIE_ID_id_latest_RRC_Version_Enhanced;
1169    rrcVer->iE_Extensions->list.array[rrcExt]->criticality = Criticality_reject;
1170    rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.present =\
1171                                                                       RRC_Version_ExtIEs__extensionValue_PR_Latest_RRC_Version_Enhanced;
1172    rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.choice\
1173       .Latest_RRC_Version_Enhanced.size = 3*sizeof(uint8_t);
1174    DU_ALLOC(rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.choice\
1175          .Latest_RRC_Version_Enhanced.buf,rrcVer->iE_Extensions->list.\
1176          array[rrcExt]->extensionValue.choice.Latest_RRC_Version_Enhanced.size);
1177    if(rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.choice\
1178          .Latest_RRC_Version_Enhanced.buf == NULLP)
1179    {
1180       return RFAILED;
1181    }
1182    rrcLatest = 0;
1183    rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.choice.\
1184       Latest_RRC_Version_Enhanced.buf[rrcLatest] = 15;
1185    rrcLatest++;
1186    rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.choice.\
1187       Latest_RRC_Version_Enhanced.buf[rrcLatest] = 5;
1188    rrcLatest++;
1189    rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.choice.\
1190       Latest_RRC_Version_Enhanced.buf[rrcLatest] = 0;
1191    return ROK;
1192 }
1193 /*******************************************************************
1194  *
1195  * @brief Sends F1 msg over SCTP
1196  *
1197  * @details
1198  *
1199  *    Function : SendF1APMsg
1200  *
1201  *    Functionality: Sends F1 msg over SCTP
1202  *
1203  * @params[in] Region region
1204  *             Pool pool
1205  * @return ROK     - success
1206  *         RFAILED - failure
1207  *
1208  * ****************************************************************/
1209 uint8_t SendF1APMsg(Region region, Pool pool)
1210 {
1211    Buffer *mBuf = NULLP;
1212
1213    if(ODU_GET_MSG_BUF(region, pool, &mBuf) == ROK)
1214    {
1215       if(ODU_ADD_POST_MSG_MULT((Data *)encBuf, encBufSize, mBuf) == ROK)
1216       {
1217             ODU_PRINT_MSG(mBuf, 0,0);
1218
1219             if(sctpSend(mBuf, F1_INTERFACE) != ROK)
1220             {
1221                DU_LOG("\nERROR  -->  F1AP : SCTP Send failed");
1222                ODU_PUT_MSG_BUF(mBuf);
1223                return RFAILED;
1224             }
1225       }
1226       else
1227       {
1228          DU_LOG("\nERROR  -->  F1AP : ODU_ADD_POST_MSG_MULT failed");
1229          ODU_PUT_MSG_BUF(mBuf);
1230          return RFAILED;
1231       }
1232       ODU_PUT_MSG_BUF(mBuf);
1233    }
1234    else
1235    {
1236       DU_LOG("\nERROR  -->  F1AP : Failed to allocate memory");
1237       return RFAILED;
1238    }
1239    return ROK;
1240 } /* SendF1APMsg */
1241
1242 /*******************************************************************
1243  *
1244  * @brief  deallocating the memory of function BuildAndSendF1SetupReq()
1245  *
1246  * @details
1247  *
1248  *    Function :  FreeRrcVer
1249  *
1250  *    Functionality: deallocating the memory of function BuildRrcVer
1251  *
1252  * @params[in] RRC_Version_t *rrcVer
1253  *
1254  * @return void
1255  *
1256  *****************************************************************/
1257 void FreeRrcVer(RRC_Version_t *rrcVer)
1258 {
1259    if(rrcVer->latest_RRC_Version.buf != NULLP)
1260    {
1261       if(rrcVer->iE_Extensions != NULLP)
1262       {
1263          if(rrcVer->iE_Extensions->list.array != NULLP)
1264          {
1265             if(rrcVer->iE_Extensions->list.array[0] != NULLP)
1266             {
1267                if(rrcVer->iE_Extensions->list.array[0]->extensionValue.choice.Latest_RRC_Version_Enhanced.buf
1268                      != NULLP)
1269                {
1270                   DU_FREE(rrcVer->iE_Extensions->list.array[0]->extensionValue.choice\
1271                         .Latest_RRC_Version_Enhanced.buf,rrcVer->iE_Extensions->list.\
1272                         array[0]->extensionValue.choice.Latest_RRC_Version_Enhanced.size);
1273                }
1274                DU_FREE(rrcVer->iE_Extensions->list.array[0],sizeof(RRC_Version_ExtIEs_t));
1275             }
1276             DU_FREE(rrcVer->iE_Extensions->list.array,sizeof(RRC_Version_ExtIEs_t*));
1277          }
1278          DU_FREE(rrcVer->iE_Extensions,sizeof(ProtocolExtensionContainer_4624P81_t));
1279       }
1280       DU_FREE(rrcVer->latest_RRC_Version.buf,rrcVer->latest_RRC_Version.size);
1281    }
1282 }
1283 /*******************************************************************
1284  *
1285  * @brief  deallocating the memory of function BuildAndSendF1SetupReq()
1286  *
1287  * @details
1288  *
1289  *    Function :  FreeServedCellList
1290  *
1291  *    Functionality:  deallocating the memory of function BuildServedCellList
1292
1293  *
1294  * @params[in] GNB_DU_Served_Cells_List_t *duServedCell
1295  *
1296  * @return void
1297  *
1298  * ****************************************************************/
1299 void FreeServedCellList( GNB_DU_Served_Cells_List_t *duServedCell)
1300 {
1301    uint8_t   plmnCnt=1;
1302    uint8_t  servId=0;
1303    uint8_t sliceId=0;
1304    uint8_t  ieId=0;
1305    uint8_t   extensionCnt=1;
1306    uint8_t plmnidx=0;
1307    GNB_DU_Served_Cells_Item_t *srvCellItem= &duServedCell->list.array[0]->value.choice.GNB_DU_Served_Cells_Item;
1308    if(duServedCell->list.array!=NULLP)
1309    {
1310       if(duServedCell->list.array[0]!=NULLP)
1311       {
1312          if(srvCellItem->served_Cell_Information.nRCGI.pLMN_Identity.buf!=NULLP)
1313          {
1314             if(srvCellItem->served_Cell_Information.nRCGI.nRCellIdentity.buf !=NULLP)
1315             {
1316                if(srvCellItem->served_Cell_Information.fiveGS_TAC!=NULLP)
1317                {
1318                   if(srvCellItem->served_Cell_Information.fiveGS_TAC->buf!=NULLP)
1319                   {
1320                      if(srvCellItem->served_Cell_Information.servedPLMNs.list.array!=NULLP)
1321                      {
1322                         if(srvCellItem->served_Cell_Information.servedPLMNs.list.array[0]!=NULLP)
1323                         {
1324                            if(srvCellItem->served_Cell_Information.servedPLMNs.list.array[servId]->pLMN_Identity.buf!=NULLP)
1325                            {
1326                               if(srvCellItem->served_Cell_Information.servedPLMNs.list.array[servId]->iE_Extensions!=NULLP)
1327                               {
1328                                  if(srvCellItem->served_Cell_Information.servedPLMNs.list.array[servId]->iE_Extensions->list.array!=NULLP)
1329                                  {
1330                                     if(srvCellItem->served_Cell_Information.servedPLMNs.list.array[servId]->iE_Extensions->list.array[0]!=NULLP)
1331                                     {
1332                                        if(srvCellItem->served_Cell_Information.servedPLMNs.list.array[servId]->iE_Extensions->list.array[0]->\
1333                                              extensionValue.choice.SliceSupportList.list.array!=NULLP)
1334                                        {
1335                                           if(srvCellItem->served_Cell_Information.servedPLMNs.list.array[servId]->iE_Extensions->list.array[0]->\
1336                                                 extensionValue.choice.SliceSupportList.list.array[sliceId]!= NULLP)
1337                                           {
1338                                              if(srvCellItem->served_Cell_Information.servedPLMNs.list.array[servId]->iE_Extensions->list.array[0]->\
1339                                                    extensionValue.choice.SliceSupportList.list.array[sliceId]->sNSSAI.sST.buf!=NULLP)
1340                                              {
1341                                                 if(srvCellItem->served_Cell_Information.servedPLMNs.list.array[servId]->iE_Extensions->list.array[0]->\
1342                                                       extensionValue.choice.SliceSupportList.list.array[sliceId]->sNSSAI.sD!=NULLP)
1343                                                 {
1344                                                    if(srvCellItem->served_Cell_Information.servedPLMNs.list.array[servId]->iE_Extensions->\
1345                                                          list.array[0]->extensionValue.choice.SliceSupportList.list.array[sliceId]->sNSSAI.sD->buf!=NULLP)
1346                                                    {
1347                                                       if(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD!=NULLP)
1348                                                       {
1349                                                          if(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD->uL_NRFreqInfo.\
1350                                                                freqBandListNr.list.array!=NULLP)
1351                                                          {
1352                                                             if(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD->uL_NRFreqInfo.\
1353                                                                   freqBandListNr.list.array[0]!=NULLP)
1354                                                             {
1355                                                                if(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD->dL_NRFreqInfo.\
1356                                                                      freqBandListNr.list.array)
1357                                                                {
1358                                                                   if(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD->dL_NRFreqInfo.\
1359                                                                         freqBandListNr.list.array[0]!=NULLP)
1360                                                                   {
1361                                                                      if(srvCellItem->served_Cell_Information.measurementTimingConfiguration.buf!=NULLP)
1362                                                                      {
1363                                                                         if(!srvCellItem->gNB_DU_System_Information)
1364                                                                         {
1365                                                                            if(srvCellItem->gNB_DU_System_Information->mIB_message.buf!=NULLP)
1366                                                                            {
1367                                                                               if(srvCellItem->gNB_DU_System_Information->sIB1_message.buf!=NULLP)
1368                                                                               {
1369                                                                                  DU_FREE(srvCellItem->gNB_DU_System_Information->sIB1_message.buf,\
1370                                                                                        srvCellItem->gNB_DU_System_Information->sIB1_message.size);
1371                                                                                  DU_FREE(duCfgParam.srvdCellLst[0].duSysInfo.sib1Msg,\
1372                                                                                        srvCellItem->gNB_DU_System_Information->sIB1_message.size);
1373                                                                               }
1374                                                                               DU_FREE(srvCellItem->gNB_DU_System_Information->mIB_message.buf,\
1375                                                                                     srvCellItem->gNB_DU_System_Information->mIB_message.size);
1376                                                                               DU_FREE(duCfgParam.srvdCellLst[0].duSysInfo.mibMsg,\
1377                                                                                     strlen((char*)duCfgParam.srvdCellLst[0].duSysInfo.mibMsg));
1378                                                                            }
1379                                                                            DU_FREE(srvCellItem->gNB_DU_System_Information,sizeof(GNB_DU_System_Information_t));
1380                                                                         }
1381                                                                         DU_FREE(srvCellItem->served_Cell_Information.measurementTimingConfiguration.buf,\
1382                                                                               srvCellItem->served_Cell_Information.measurementTimingConfiguration.size);
1383                                                                      }
1384                                                                      DU_FREE(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD->dL_NRFreqInfo.\
1385                                                                            freqBandListNr.list.array[0],sizeof(FreqBandNrItem_t));
1386                                                                   }
1387                                                                   DU_FREE(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD->dL_NRFreqInfo.\
1388                                                                         freqBandListNr.list.array,sizeof(FreqBandNrItem_t *));
1389                                                                }
1390                                                                DU_FREE(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD->uL_NRFreqInfo.freqBandListNr.\
1391                                                                      list.array[0],sizeof(FreqBandNrItem_t));
1392                                                             }
1393                                                             DU_FREE(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD->uL_NRFreqInfo.freqBandListNr.\
1394                                                                   list.array,sizeof(FreqBandNrItem_t*));
1395                                                          }
1396                                                          DU_FREE(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD,sizeof(FDD_Info_t));
1397                                                       }
1398                                                       DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.array[servId]->\
1399                                                             iE_Extensions->list.array[ieId]->extensionValue.choice.SliceSupportList.list.array[sliceId]->\
1400                                                             sNSSAI.sD->buf,srvCellItem->served_Cell_Information.servedPLMNs.list.array[servId]->iE_Extensions->
1401                                                             list.array[ieId]->extensionValue.choice.SliceSupportList.list.array[sliceId]->sNSSAI.sD->size);
1402                                                    }
1403                                                    DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.array[servId]->\
1404                                                          iE_Extensions->list.array[ieId]->extensionValue.choice.SliceSupportList.\
1405                                                          list.array[sliceId]->sNSSAI.sD,sizeof(OCTET_STRING_t));
1406                                                 }
1407                                                 DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.array[servId]->\
1408                                                       iE_Extensions->list.array[ieId]->extensionValue.choice.SliceSupportList.list.array[sliceId]->\
1409                                                       sNSSAI.sST.buf,sizeof(uint8_t));
1410                                              }
1411                                              DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.array[servId]->iE_Extensions->list.array[0]->\
1412                                                    extensionValue.choice.SliceSupportList.list.array[sliceId],sizeof(SliceSupportItem_t));
1413                                           }
1414                                           DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.array[servId]->iE_Extensions->list.array[0]->\
1415                                                 extensionValue.choice.SliceSupportList.list.array,sizeof(SliceSupportItem_t*));
1416                                        }
1417                                        DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.\
1418                                              array[servId]->iE_Extensions->list.array[plmnidx],sizeof(ServedPLMNs_ItemExtIEs_t));
1419                                     }
1420                                     DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.\
1421                                           array[servId]->iE_Extensions->list.array,\
1422                                           extensionCnt*sizeof(ServedPLMNs_ItemExtIEs_t*));
1423                                  }
1424                                  DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.\
1425                                        array[servId]->iE_Extensions,sizeof(ProtocolExtensionContainer_4624P3_t));
1426                               }
1427                               DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.\
1428                                     array[servId]->pLMN_Identity.buf,srvCellItem->served_Cell_Information.\
1429                                     servedPLMNs.list.array[servId]->pLMN_Identity.size
1430                                     * sizeof(uint8_t));
1431                            }
1432                            DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.array[plmnidx],\
1433                                  sizeof(ServedPLMNs_Item_t *));
1434                         }
1435                         DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.array,\
1436                               sizeof(ServedPLMNs_Item_t *));
1437                      }
1438                      DU_FREE(srvCellItem->served_Cell_Information.fiveGS_TAC->buf,\
1439                            sizeof(srvCellItem->served_Cell_Information.fiveGS_TAC->size));
1440                   }
1441                   DU_FREE(srvCellItem->served_Cell_Information.fiveGS_TAC,sizeof(FiveGS_TAC_t));
1442                }
1443                DU_FREE(srvCellItem->served_Cell_Information.nRCGI.nRCellIdentity.buf,\
1444                      srvCellItem->served_Cell_Information.nRCGI.nRCellIdentity.size *
1445                      sizeof(uint8_t));
1446             }
1447             DU_FREE(srvCellItem->served_Cell_Information.nRCGI.pLMN_Identity.buf,\
1448                   srvCellItem->served_Cell_Information.nRCGI.pLMN_Identity.size *
1449                   sizeof(uint8_t));
1450          }
1451          DU_FREE(duServedCell->list.array[plmnidx],sizeof(GNB_DU_Served_Cells_ItemIEs_t));
1452       }
1453       DU_FREE(duServedCell->list.array,plmnCnt*sizeof(GNB_DU_Served_Cells_ItemIEs_t*));
1454    }
1455 }
1456 /*******************************************************************
1457  *
1458  * @brief  deallocating the memory of function BuildAndSendF1SetupReq()
1459  *
1460  * @details
1461  *
1462  *    Function :  FreeF1SetupReq
1463  *
1464  *    Functionality:  deallocating the memory of function BuildAndSendF1SetupReq
1465  *
1466  * @params[in] F1AP_PDU_t *f1apMsg
1467  *
1468  * @return void
1469  *
1470  * ****************************************************************/
1471 void FreeF1SetupReq(F1AP_PDU_t *f1apMsg)
1472 {
1473    uint8_t ieIdx, ieIdx2;
1474    F1SetupRequest_t *f1SetupReq=NULLP;
1475
1476    if(f1apMsg != NULLP)
1477    {
1478       if(f1apMsg->choice.initiatingMessage != NULLP)
1479       {
1480          f1SetupReq = &f1apMsg->choice.initiatingMessage->value.choice.F1SetupRequest;
1481          if(f1SetupReq->protocolIEs.list.array != NULLP)
1482          {
1483             for(ieIdx = 0; ieIdx < f1SetupReq->protocolIEs.list.count; ieIdx++)
1484             {
1485                if(f1SetupReq->protocolIEs.list.array[ieIdx] != NULLP)
1486                {
1487                   switch(f1SetupReq->protocolIEs.list.array[ieIdx]->id)
1488                   {
1489                      case ProtocolIE_ID_id_TransactionID:
1490                         break;
1491                      case ProtocolIE_ID_id_gNB_DU_ID:
1492                         DU_FREE(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf,\
1493                               f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.size);
1494                         break;
1495                      case ProtocolIE_ID_id_gNB_DU_Name:
1496                         DU_FREE(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_Name.buf,\
1497                               strlen((char *)duCfgParam.duName));
1498                         break;
1499                      case ProtocolIE_ID_id_gNB_DU_Served_Cells_List:
1500                         FreeServedCellList(&f1SetupReq->protocolIEs.list.\
1501                               array[ieIdx]->value.choice.GNB_DU_Served_Cells_List);
1502                         break;
1503                      case ProtocolIE_ID_id_GNB_DU_RRC_Version:
1504                         FreeRrcVer(&f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.RRC_Version);
1505                         break;
1506                      default:
1507                         DU_LOG("\nERROR  -->  Invalid Event Type %ld", f1SetupReq->protocolIEs.list.array[ieIdx]->id);
1508                         break;
1509                   }
1510                }
1511                break;
1512             }
1513             for(ieIdx2=0; ieIdx2< ieIdx; ieIdx2++)
1514             {
1515                DU_FREE(f1SetupReq->protocolIEs.list.array[ieIdx2],sizeof(F1SetupRequestIEs_t));
1516             }
1517             DU_FREE(f1SetupReq->protocolIEs.list.array,\
1518                   f1SetupReq->protocolIEs.list.size);
1519          }
1520          DU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
1521       }
1522       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
1523    }
1524 }
1525 /*******************************************************************
1526  *
1527  * @brief Builds and Send the F1SetupRequest
1528  *
1529  * @details
1530  *
1531  *    Function : BuildAndSendF1SetupReq
1532  *
1533  * Functionality:Fills the F1SetupRequest
1534  *
1535  * @return ROK     - success
1536  *         RFAILED - failure
1537  *
1538  ******************************************************************/
1539 uint8_t BuildAndSendF1SetupReq()
1540 {
1541    uint8_t   ret, ieIdx, elementCnt;
1542    F1AP_PDU_t                 *f1apMsg = NULLP;
1543    F1SetupRequest_t           *f1SetupReq=NULLP;
1544    GNB_DU_Served_Cells_List_t *duServedCell=NULLP;
1545    RRC_Version_t              *rrcVer=NULLP;
1546    asn_enc_rval_t             encRetVal;        /* Encoder return value */
1547    ret= RFAILED;
1548
1549    DU_LOG("\nINFO   -->  F1AP : Building F1 Setup Request\n");
1550    do
1551    {
1552       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
1553       if(f1apMsg == NULLP)
1554       {
1555          break;
1556       }
1557       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
1558       DU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
1559       if(f1apMsg->choice.initiatingMessage == NULLP)
1560       {
1561          break;
1562       }
1563       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_F1Setup;
1564       f1apMsg->choice.initiatingMessage->criticality = Criticality_reject;
1565       f1apMsg->choice.initiatingMessage->value.present = \
1566                                                          InitiatingMessage__value_PR_F1SetupRequest;
1567
1568       f1SetupReq = &f1apMsg->choice.initiatingMessage->value.choice.F1SetupRequest;
1569
1570       elementCnt = (duCfgParam.duName != NULL) ? 5 : 4;
1571
1572       f1SetupReq->protocolIEs.list.count = elementCnt;
1573       f1SetupReq->protocolIEs.list.size = elementCnt * sizeof(F1SetupRequestIEs_t );
1574
1575       /* Initialize the F1Setup members */
1576       DU_ALLOC(f1SetupReq->protocolIEs.list.array,f1SetupReq->protocolIEs.list.size);
1577       if(f1SetupReq->protocolIEs.list.array == NULLP)
1578       {
1579          break;
1580       }
1581       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
1582       {
1583          DU_ALLOC(f1SetupReq->protocolIEs.list.array[ieIdx],\
1584                sizeof(F1SetupRequestIEs_t));
1585          if(f1SetupReq->protocolIEs.list.array[ieIdx] == NULLP)
1586          {
1587             break;
1588          }
1589       }
1590
1591       ieIdx = 0;
1592       /*TransactionID*/
1593       f1SetupReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_TransactionID;
1594       f1SetupReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
1595       f1SetupReq->protocolIEs.list.array[ieIdx]->value.present =\
1596                                                                F1SetupRequestIEs__value_PR_TransactionID;
1597       f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.TransactionID = \
1598                                                                              TRANS_ID;
1599
1600       /*DU ID*/
1601       ieIdx++;
1602       f1SetupReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_ID;
1603       f1SetupReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
1604       f1SetupReq->protocolIEs.list.array[ieIdx]->value.present = \
1605                                                                 F1SetupRequestIEs__value_PR_GNB_DU_ID;
1606       f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.size =\
1607                                                                              sizeof(uint8_t);
1608
1609       DU_ALLOC(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf,\
1610             f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.size);
1611       if(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf == \
1612             NULLP)
1613       {
1614          break;
1615       }
1616
1617       f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf[0] =\
1618          duCfgParam.duId;
1619
1620       /*DU Name*/
1621       if(duCfgParam.duName != NULL)
1622       {
1623          ieIdx++;
1624          f1SetupReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_Name;
1625          f1SetupReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_ignore;
1626          f1SetupReq->protocolIEs.list.array[ieIdx]->value.present = F1SetupRequestIEs__value_PR_GNB_DU_Name;
1627          f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_Name.size =\
1628             strlen((char *)duCfgParam.duName);
1629          DU_ALLOC(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.\
1630                GNB_DU_Name.buf, strlen((char *)duCfgParam.duName));
1631          if(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_Name.\
1632                buf == NULLP)
1633          {
1634             break;
1635          }
1636          strcpy((char*)f1SetupReq->protocolIEs.list.array[ieIdx]->value.\
1637                choice.GNB_DU_Name.buf,
1638                (char*)&duCfgParam.duName);
1639
1640       }
1641
1642       /*Served Cell list */
1643       ieIdx++;
1644       f1SetupReq->protocolIEs.list.array[ieIdx]->id = \
1645                                                      ProtocolIE_ID_id_gNB_DU_Served_Cells_List;
1646       f1SetupReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
1647       f1SetupReq->protocolIEs.list.array[ieIdx]->value.present = \
1648                                                                 F1SetupRequestIEs__value_PR_GNB_DU_Served_Cells_List;
1649       duServedCell = &f1SetupReq->protocolIEs.list.\
1650                      array[ieIdx]->value.choice.GNB_DU_Served_Cells_List;
1651       if(BuildServedCellList(duServedCell))
1652       {
1653          break;
1654       }
1655       /*RRC Version*/
1656       ieIdx++;
1657       f1SetupReq->protocolIEs.list.array[ieIdx]->id = \
1658                                                      ProtocolIE_ID_id_GNB_DU_RRC_Version ;
1659       f1SetupReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
1660       f1SetupReq->protocolIEs.list.array[ieIdx]->value.present = \
1661                                                                 F1SetupRequestIEs__value_PR_RRC_Version;
1662       rrcVer = &f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.RRC_Version;
1663       if(BuildRrcVer(rrcVer))
1664       {
1665          break;
1666       }
1667       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
1668
1669       /* Encode the F1SetupRequest type as APER */
1670       memset(encBuf, 0, ENC_BUF_MAX_LEN);
1671       encBufSize = 0;
1672       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
1673             encBuf);
1674
1675       /* Encode results */
1676       if(encRetVal.encoded == ENCODE_FAIL)
1677       {
1678          DU_LOG("\nERROR  -->  F1AP : Could not encode F1SetupRequest structure (at %s)\n",\
1679                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
1680          break;
1681       }
1682       else
1683       {
1684          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for F1SetupRequest\n");
1685          for(ieIdx=0; ieIdx< encBufSize; ieIdx++)
1686          {
1687             printf("%x",encBuf[ieIdx]);
1688          }
1689       }
1690
1691       /* Sending msg */
1692       if(SendF1APMsg(DU_APP_MEM_REGION, DU_POOL) != ROK)
1693       {
1694          DU_LOG("\nERROR  -->  F1AP : Sending F1 Setup request failed");
1695          break;
1696       }
1697
1698       ret=ROK;
1699       break;
1700    }while(true);
1701
1702    FreeF1SetupReq(f1apMsg);
1703
1704    return ret;
1705 }/* End of BuildAndSendF1SetupReq */
1706
1707 /*******************************************************************
1708  *
1709  * @brief Deallocating memory of BuildAndSendDUConfigUpdate
1710  *
1711  * @details
1712  *
1713  *    Function : FreeDUConfigUpdate
1714  *
1715  *    Functionality: Deallocating memory of variables allocated in
1716  *                    BuildAndSendDUConfigUpdate function
1717  *
1718  * @params[in]  F1AP_PDU_t *f1apDuCfg
1719  *
1720  * @return ROK     - void
1721  *
1722  * ****************************************************************/
1723 void FreeDUConfigUpdate(F1AP_PDU_t *f1apDuCfg)
1724 {
1725    uint8_t  i;
1726    uint8_t  idx;
1727    GNBDUConfigurationUpdate_t *duCfgUpdate = NULLP;
1728    Served_Cells_To_Modify_List_t  *cellsToModify;
1729    Served_Cells_To_Modify_Item_t *modifyItem;
1730    idx=0;
1731    i=1;
1732    if(f1apDuCfg != NULLP)
1733    {
1734       if(f1apDuCfg->choice.initiatingMessage != NULLP)
1735       {
1736          duCfgUpdate = &f1apDuCfg->choice.initiatingMessage->\
1737                        value.choice.GNBDUConfigurationUpdate;
1738          if(duCfgUpdate->protocolIEs.list.array != NULLP)
1739          {
1740             if(duCfgUpdate->protocolIEs.list.array[i] != NULLP)
1741             {
1742                cellsToModify = &duCfgUpdate->protocolIEs.list.array[i]->\
1743                                value.choice.Served_Cells_To_Modify_List;
1744                if(cellsToModify->list.array != NULLP)
1745                {
1746                   if(cellsToModify->list.array[idx] != NULLP)
1747                   {
1748                      modifyItem=&cellsToModify->list.array[idx]->value.choice.\
1749                                 Served_Cells_To_Modify_Item;
1750                      if(modifyItem->oldNRCGI.pLMN_Identity.buf != NULLP)
1751                      {
1752                         if(modifyItem->oldNRCGI.nRCellIdentity.buf != NULLP)
1753                         {
1754                            if(modifyItem->served_Cell_Information.nRCGI.pLMN_Identity.buf != NULLP)
1755                            {
1756                               if(modifyItem->served_Cell_Information.nRCGI.nRCellIdentity.buf
1757                                     != NULLP)
1758                               {
1759                                  if(modifyItem->served_Cell_Information.servedPLMNs.list.array\
1760                                        != NULLP)
1761                                  {
1762                                     if(!modifyItem->served_Cell_Information.servedPLMNs.list.array[idx])
1763                                     {
1764                                        if(modifyItem->served_Cell_Information.servedPLMNs.list.\
1765                                              array[idx]->pLMN_Identity.buf != NULLP)
1766                                        {
1767                                           if(modifyItem->served_Cell_Information.servedPLMNs.list.\
1768                                                 array[idx]->iE_Extensions!= NULLP)
1769                                           {
1770                                              if(modifyItem->served_Cell_Information.servedPLMNs.list.\
1771                                                    array[idx]->iE_Extensions->list.array != NULLP)
1772                                              {
1773                                                 if(modifyItem->served_Cell_Information.servedPLMNs.list.\
1774                                                       array[idx]->iE_Extensions->list.array[idx])
1775                                                 {
1776                                                    if(modifyItem->served_Cell_Information.servedPLMNs.list.array[idx]->\
1777                                                          iE_Extensions->list.array[idx]->extensionValue.choice.SliceSupportList.\
1778                                                          list.array !=NULLP)
1779                                                    {
1780                                                       if(modifyItem->served_Cell_Information.servedPLMNs.list.array[idx]->\
1781                                                             iE_Extensions->list.array[idx]->extensionValue.choice.SliceSupportList.\
1782                                                             list.array[idx]!=NULLP)
1783                                                       {
1784                                                          if(modifyItem->served_Cell_Information.servedPLMNs.list.array[idx]->\
1785                                                                iE_Extensions->list.array[idx]->extensionValue.choice.SliceSupportList.\
1786                                                                list.array[idx]->sNSSAI.sST.buf!=NULLP)
1787                                                          {
1788                                                             if(modifyItem->served_Cell_Information.servedPLMNs.list.array[idx]->\
1789                                                                   iE_Extensions->list.array[idx]->extensionValue.choice.SliceSupportList.\
1790                                                                   list.array[idx]->sNSSAI.sD != NULLP)
1791                                                             {
1792                                                                if(modifyItem->served_Cell_Information.servedPLMNs.list.array[idx]->\
1793                                                                      iE_Extensions->list.array[idx]->extensionValue.choice.SliceSupportList.\
1794                                                                      list.array[idx]->sNSSAI.sD->buf!=NULLP)
1795                                                                {
1796                                                                   if(modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD
1797                                                                         !=NULLP)
1798                                                                   {
1799                                                                      if(modifyItem->served_Cell_Information.nR_Mode_Info.choice.\
1800                                                                            fDD->uL_NRFreqInfo.freqBandListNr.list.array!=NULLP)
1801                                                                      {
1802                                                                         if(modifyItem->served_Cell_Information.nR_Mode_Info.choice.\
1803                                                                               fDD->uL_NRFreqInfo.freqBandListNr.list.array[idx]!=NULLP)
1804                                                                         {
1805                                                                            if(modifyItem->served_Cell_Information.nR_Mode_Info.choice.\
1806                                                                                  fDD->dL_NRFreqInfo.freqBandListNr.list.array !=NULLP)
1807                                                                            {
1808                                                                               if(modifyItem->served_Cell_Information.nR_Mode_Info.\
1809                                                                                     choice.fDD->dL_NRFreqInfo.freqBandListNr.list.\
1810                                                                                     array[idx]!= NULLP)
1811                                                                               {
1812                                                                                  if(modifyItem->served_Cell_Information.\
1813                                                                                        measurementTimingConfiguration.buf !=NULLP)
1814                                                                                  {
1815                                                                                     idx=2;
1816                                                                                     if(duCfgUpdate->protocolIEs.list.array[idx]->value.\
1817                                                                                           choice.GNB_DU_ID.buf!=NULLP)
1818                                                                                     {
1819                                                                                        DU_FREE(duCfgUpdate->protocolIEs.list.\
1820                                                                                              array[idx]->value.choice.GNB_DU_ID.buf,\
1821                                                                                              duCfgUpdate->protocolIEs.list.array[idx]->\
1822                                                                                              value.choice.GNB_DU_ID.size);
1823                                                                                     }
1824                                                                                     idx=0;
1825                                                                                     DU_FREE(modifyItem->served_Cell_Information.\
1826                                                                                           measurementTimingConfiguration.\
1827                                                                                           buf,modifyItem->served_Cell_Information.\
1828                                                                                           measurementTimingConfiguration.size);
1829                                                                                  }
1830                                                                                  DU_FREE(modifyItem->served_Cell_Information.\
1831                                                                                        nR_Mode_Info.choice.fDD->dL_NRFreqInfo.freqBandListNr.\
1832                                                                                        list.array[idx],sizeof(FreqBandNrItem_t));
1833                                                                               }
1834                                                                               DU_FREE(modifyItem->served_Cell_Information.nR_Mode_Info\
1835                                                                                     .choice.fDD->dL_NRFreqInfo.freqBandListNr.list.array,\
1836                                                                                     modifyItem->served_Cell_Information.nR_Mode_Info.\
1837                                                                                     choice.fDD->dL_NRFreqInfo.freqBandListNr.list.size);
1838                                                                            }
1839                                                                            DU_FREE(modifyItem->served_Cell_Information.nR_Mode_Info.\
1840                                                                                  choice.fDD->uL_NRFreqInfo.freqBandListNr.list.\
1841                                                                                  array[idx],sizeof(FreqBandNrItem_t));
1842                                                                         }
1843                                                                         DU_FREE(modifyItem->served_Cell_Information.nR_Mode_Info.\
1844                                                                               choice.\
1845                                                                               fDD->uL_NRFreqInfo.freqBandListNr.list.\
1846                                                                               array,modifyItem->served_Cell_Information.nR_Mode_Info.choice.\
1847                                                                               fDD->uL_NRFreqInfo.freqBandListNr.list.size);
1848                                                                      }
1849                                                                      DU_FREE(modifyItem->served_Cell_Information.nR_Mode_Info.choice.\
1850                                                                            fDD,sizeof(FDD_Info_t));
1851                                                                   }
1852                                                                   DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.\
1853                                                                         array[idx]->iE_Extensions->list.array[idx]->extensionValue.choice.\
1854                                                                         SliceSupportList.\
1855                                                                         list.array[idx]->sNSSAI.sD->buf,modifyItem->served_Cell_Information.\
1856                                                                         servedPLMNs.list.array[idx]->iE_Extensions->list.array[idx]->\
1857                                                                         extensionValue.choice.SliceSupportList.list.array[idx]->\
1858                                                                         sNSSAI.sD->size);
1859
1860                                                                }
1861                                                                DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.\
1862                                                                      array[idx]->\
1863                                                                      iE_Extensions->list.array[idx]->extensionValue.choice.SliceSupportList.\
1864                                                                      list.array[idx]->sNSSAI.sD,sizeof(OCTET_STRING_t));
1865                                                             }
1866                                                             DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.array[idx]->\
1867                                                                   iE_Extensions->list.array[idx]->extensionValue.choice.SliceSupportList.\
1868                                                                   list.array[idx]->sNSSAI.sST.buf,modifyItem->served_Cell_Information.\
1869                                                                   servedPLMNs.\
1870                                                                   list.array[idx]->iE_Extensions->list.array[idx]->extensionValue.choice.\
1871                                                                   SliceSupportList.list.array[idx]->sNSSAI.sST.size);
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],sizeof(SliceSupportItem_t));
1876                                                       }
1877                                                       DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.array[idx]->\
1878                                                             iE_Extensions->list.array[idx]->extensionValue.choice.SliceSupportList.\
1879                                                             list.array,\
1880                                                             modifyItem->served_Cell_Information.servedPLMNs.list.array[idx]->\
1881                                                             iE_Extensions->list.array[idx]->extensionValue.choice.SliceSupportList.list.size);
1882                                                    }
1883                                                 }
1884                                                 for(i=0;i<modifyItem->served_Cell_Information.servedPLMNs.list.\
1885                                                       array[idx]->iE_Extensions->list.count;i++)
1886                                                 {
1887                                                    DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.\
1888                                                          array[idx]->iE_Extensions->list.array[i],\
1889                                                          sizeof(ServedPLMNs_ItemExtIEs_t ));
1890                                                 }
1891                                                 DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.\
1892                                                       array[idx]->iE_Extensions->list.array,modifyItem->served_Cell_Information.servedPLMNs.
1893                                                       list.array[idx]->iE_Extensions->list.size);
1894                                              }
1895                                              DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.\
1896                                                    array[idx]->iE_Extensions,sizeof(ProtocolExtensionContainer_4624P3_t));
1897                                           }
1898                                           DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.\
1899                                                 array[idx]->pLMN_Identity.buf,
1900                                                 modifyItem->served_Cell_Information.servedPLMNs.list.array[idx]->pLMN_Identity.size);
1901                                        }
1902                                     }
1903                                     for(i=0;i<modifyItem->served_Cell_Information.servedPLMNs.list.count;i++)
1904                                     {
1905                                        if(modifyItem->served_Cell_Information.servedPLMNs.list.array[i]
1906                                              != NULLP)
1907                                        {
1908                                           DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.array[i],\
1909                                                 sizeof(ServedPLMNs_Item_t));
1910                                        }
1911                                     }
1912                                     DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.array,\
1913                                           modifyItem->served_Cell_Information.servedPLMNs.list.size);
1914                                  }
1915                                  DU_FREE(modifyItem->served_Cell_Information.nRCGI.nRCellIdentity.buf,\
1916                                        modifyItem->served_Cell_Information.nRCGI.nRCellIdentity.size);
1917                               }
1918                               DU_FREE(modifyItem->served_Cell_Information.nRCGI.pLMN_Identity.buf,\
1919                                     modifyItem->served_Cell_Information.nRCGI.pLMN_Identity.size);
1920                            }
1921                            DU_FREE(modifyItem->oldNRCGI.nRCellIdentity.buf,\
1922                                  modifyItem->oldNRCGI.nRCellIdentity.size);
1923                         }
1924                         DU_FREE(modifyItem->oldNRCGI.pLMN_Identity.buf,\
1925                               modifyItem->oldNRCGI.pLMN_Identity.size);
1926                      }
1927                   }
1928                   for(i=0; i<cellsToModify->list.count ;i++)
1929                   {
1930                      if(cellsToModify->list.array[i] != NULLP)
1931                      {
1932                         DU_FREE(cellsToModify->list.array[i],\
1933                               sizeof(Served_Cells_To_Modify_ItemIEs_t));
1934                      }
1935                   }
1936                   DU_FREE(cellsToModify->list.array,cellsToModify->list.size);
1937                }
1938             }
1939             for(i=0;i<duCfgUpdate->protocolIEs.list.count;i++)
1940             {
1941                if(duCfgUpdate->protocolIEs.list.array[i] !=NULLP)
1942                {
1943                   DU_FREE(duCfgUpdate->protocolIEs.list.array[i],\
1944                         sizeof(GNBDUConfigurationUpdateIEs_t));
1945                }
1946             }
1947             DU_FREE(duCfgUpdate->protocolIEs.list.array,duCfgUpdate->protocolIEs.list.size);
1948          }
1949          DU_FREE(f1apDuCfg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
1950       }
1951       DU_FREE(f1apDuCfg, (Size)sizeof(F1AP_PDU_t));
1952    }
1953 }
1954
1955 /*******************************************************************
1956  *
1957  * @brief Fills Served Plmns required in ServCellInfo IE
1958  *
1959  * @details
1960  *
1961  *    Function : fillServedPlmns
1962  *
1963  *    Functionality: Fills Served Plmns required in ServCellInfo IE
1964  *
1965  * @params[in] Pointer to ServedPLMNs_List_t *
1966  *
1967  * @return ROK     - success
1968  *         RFAILED - failure
1969  *
1970  *****************************************************************/
1971
1972 uint8_t fillServedPlmns(ServedPLMNs_List_t *servedPlmn)
1973 {
1974    uint8_t ieIdx, ieListCnt;
1975
1976    servedPlmn->list.array[0]->pLMN_Identity.size = 3*sizeof(uint8_t);
1977    DU_ALLOC(servedPlmn->list.array[0]->pLMN_Identity.buf, servedPlmn->list.\
1978          array[0]->pLMN_Identity.size);
1979    if(servedPlmn->list.array[0]->pLMN_Identity.buf == NULLP)
1980    {
1981       return RFAILED;
1982    }
1983    buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.plmn[0],\
1984          servedPlmn->list.array[0]->pLMN_Identity.buf);
1985    DU_ALLOC(servedPlmn->list.array[0]->iE_Extensions,sizeof(ProtocolExtensionContainer_4624P3_t));
1986    if(servedPlmn->list.array[0]->iE_Extensions == NULLP)
1987    {
1988       return RFAILED;
1989    }
1990
1991    ieListCnt=1;
1992    servedPlmn->list.array[0]->iE_Extensions->list.count = ieListCnt;
1993    servedPlmn->list.array[0]->iE_Extensions->list.size = ieListCnt *sizeof(ServedPLMNs_ItemExtIEs_t *);
1994    DU_ALLOC(servedPlmn->list.array[0]->iE_Extensions->list.array,servedPlmn->list.array[0]->\
1995          iE_Extensions->list.size);
1996    if(servedPlmn->list.array[0]->iE_Extensions->list.array == NULLP)
1997    {
1998       return RFAILED;
1999    }
2000    for(ieIdx=0;ieIdx<ieListCnt;ieIdx++)
2001    {
2002       DU_ALLOC(servedPlmn->list.array[0]->iE_Extensions->list.array[ieIdx],\
2003             sizeof(ServedPLMNs_ItemExtIEs_t));
2004       if(servedPlmn->list.array[0]->iE_Extensions->list.array[ieIdx] == NULLP)
2005       {
2006          return RFAILED;
2007       }
2008    }
2009    //plmnIeExt = servedPlmn->list.array[0]->iE_Extensions;
2010    servedPlmn->list.array[0]->iE_Extensions->list.array[0]->id =ProtocolIE_ID_id_TAISliceSupportList;
2011    servedPlmn->list.array[0]->iE_Extensions->list.array[0]->criticality = Criticality_ignore;
2012    servedPlmn->list.array[0]->iE_Extensions->list.array[0]->extensionValue.present = \
2013       ServedPLMNs_ItemExtIEs__extensionValue_PR_SliceSupportList;
2014    servedPlmn->list.array[0]->iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2015       list.count = 1;
2016    servedPlmn->list.array[0]->\
2017       iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2018       list.size = sizeof(SliceSupportItem_t *);
2019    DU_ALLOC(servedPlmn->list.array[0]->\
2020          iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2021          list.array,servedPlmn->list.array[0]->\
2022          iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.list.size);
2023    if(servedPlmn->list.array[0]->\
2024          iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2025          list.array == NULLP)
2026    {
2027       return RFAILED;
2028    }
2029
2030    DU_ALLOC(servedPlmn->list.array[0]->\
2031          iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2032          list.array[0],sizeof( SliceSupportItem_t));
2033    if(servedPlmn->list.array[0]->\
2034          iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2035          list.array[0] == NULLP)
2036    {
2037       return RFAILED;
2038    }
2039    servedPlmn->list.array[0]->\
2040       iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2041       list.array[0]->sNSSAI.sST.size = sizeof(uint8_t);
2042    DU_ALLOC(servedPlmn->list.array[0]->\
2043          iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2044          list.array[0]->sNSSAI.sST.buf,servedPlmn->list.array[0]->\
2045          iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.list.array[0]->sNSSAI.sST.size);
2046    if(servedPlmn->list.array[0]->\
2047          iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2048          list.array[0]->sNSSAI.sST.buf == NULLP)
2049    {
2050       return RFAILED;
2051    }
2052    servedPlmn->list.array[0]->\
2053       iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2054       list.array[0]->sNSSAI.sST.buf[0] = 3;
2055    DU_ALLOC(servedPlmn->list.array[0]->\
2056          iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2057          list.array[0]->sNSSAI.sD,sizeof(OCTET_STRING_t));
2058    if(servedPlmn->list.array[0]->\
2059          iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2060          list.array[0]->sNSSAI.sD == NULLP)
2061    {
2062       return RFAILED;
2063    }
2064    servedPlmn->list.array[0]->\
2065       iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2066       list.array[0]->sNSSAI.sD->size = 3*sizeof(uint8_t);
2067    DU_ALLOC(servedPlmn->list.array[0]->\
2068          iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2069          list.array[0]->sNSSAI.sD->buf,servedPlmn->list.array[0]->\
2070          iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2071          list.array[0]->sNSSAI.sD->size);
2072    if(servedPlmn->list.array[0]->\
2073          iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2074          list.array[0]->sNSSAI.sD->buf == NULLP)
2075    {
2076       return RFAILED;
2077    }
2078    servedPlmn->list.array[0]->\
2079       iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2080       list.array[0]->sNSSAI.sD->buf[0] = 3;
2081    servedPlmn->list.array[0]->\
2082       iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2083       list.array[0]->sNSSAI.sD->buf[1] = 6;
2084    servedPlmn->list.array[0]->\
2085       iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2086       list.array[0]->sNSSAI.sD->buf[2] = 9;
2087    return ROK;
2088 }
2089
2090 /*******************************************************************
2091  *
2092  * @brief Fills Nr Fdd Info required in ServCellInfo IE
2093  *
2094  * @details
2095  *
2096  *    Function : fillNrFddInfo
2097  *
2098  *    Functionality: Fills Nr Fdd Info required in ServCellInfo IE
2099  *
2100  * @params[in] Pointer to NR_Mode_Info_t *
2101  *
2102  * @return ROK     - success
2103  *         RFAILED - failure
2104  *
2105  *****************************************************************/
2106
2107 uint8_t fillNrFddInfo(NR_Mode_Info_t *nrFdd)
2108 {
2109    nrFdd->choice.fDD->uL_NRFreqInfo.nRARFCN = duCfgParam.srvdCellLst[0].duCellInfo.\
2110       f1Mode.mode.fdd.ulNrFreqInfo.nrArfcn;
2111    nrFdd->choice.fDD->uL_NRFreqInfo.freqBandListNr.list.count = 1;
2112    nrFdd->choice.fDD->uL_NRFreqInfo.freqBandListNr.list.size = sizeof(FreqBandNrItem_t*);
2113    DU_ALLOC(nrFdd->choice.fDD->uL_NRFreqInfo.freqBandListNr.list.\
2114          array, nrFdd->choice.fDD->uL_NRFreqInfo.freqBandListNr.list.size);
2115    if(nrFdd->choice.fDD->uL_NRFreqInfo.freqBandListNr.list.array == NULLP)
2116    {
2117       return RFAILED;
2118    }
2119    DU_ALLOC(nrFdd->choice.fDD->uL_NRFreqInfo.freqBandListNr.list.array[0], \
2120       sizeof(FreqBandNrItem_t));
2121    if(nrFdd->choice.fDD->uL_NRFreqInfo.freqBandListNr.list.array[0] == NULLP)
2122    {
2123       return RFAILED;
2124    }
2125    nrFdd->choice.fDD->uL_NRFreqInfo.freqBandListNr.list.array[0]->freqBandIndicatorNr = \
2126       duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.fdd.ulNrFreqInfo.\
2127       freqBand[0].nrFreqBand;
2128    nrFdd->choice.fDD->uL_NRFreqInfo.freqBandListNr.list.array[0]->supportedSULBandList.list.count=0;
2129    nrFdd->choice.fDD->dL_NRFreqInfo.nRARFCN = duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.fdd.\
2130       dlNrFreqInfo.nrArfcn;
2131    nrFdd->choice.fDD->dL_NRFreqInfo.freqBandListNr.list.count = 1;
2132    nrFdd->choice.fDD->dL_NRFreqInfo.freqBandListNr.list.size = sizeof(FreqBandNrItem_t *);
2133    DU_ALLOC(nrFdd->choice.fDD->dL_NRFreqInfo.freqBandListNr.list.array,nrFdd->\
2134          choice.fDD->dL_NRFreqInfo.freqBandListNr.list.size);
2135    if(nrFdd->choice.fDD->dL_NRFreqInfo.freqBandListNr.list.array == NULLP)
2136    {
2137       return RFAILED;
2138    }
2139    DU_ALLOC(nrFdd->choice.fDD->dL_NRFreqInfo.freqBandListNr.list.array[0],\
2140          sizeof(FreqBandNrItem_t));
2141    if(nrFdd->choice.fDD->dL_NRFreqInfo.freqBandListNr.list.array[0] == NULLP)
2142    {
2143       return RFAILED;
2144    }
2145    nrFdd->choice.fDD->dL_NRFreqInfo.freqBandListNr.list.array[0]->freqBandIndicatorNr = \
2146       duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.fdd.dlNrFreqInfo.\
2147       freqBand[0].nrFreqBand;
2148    nrFdd->choice.fDD->dL_NRFreqInfo.freqBandListNr.list.array[0]->supportedSULBandList.list.count=0;
2149
2150    /*Transmission Bandwidth*/
2151    nrFdd->choice.fDD->uL_Transmission_Bandwidth.nRSCS = duCfgParam.srvdCellLst[0].duCellInfo.\
2152       f1Mode.mode.fdd.ulTxBw.nrScs;
2153    nrFdd->choice.fDD->uL_Transmission_Bandwidth.nRNRB = duCfgParam.srvdCellLst[0].duCellInfo.\
2154       f1Mode.mode.fdd.ulTxBw.nrb;
2155    nrFdd->choice.fDD->dL_Transmission_Bandwidth.nRSCS = duCfgParam.srvdCellLst[0].duCellInfo.\
2156       f1Mode.mode.fdd.dlTxBw.nrScs;
2157    nrFdd->choice.fDD->dL_Transmission_Bandwidth.nRNRB = duCfgParam.srvdCellLst[0].duCellInfo.\
2158       f1Mode.mode.fdd.dlTxBw.nrb;
2159
2160    return ROK;
2161 }
2162
2163 /*******************************************************************
2164  *
2165  * @brief Fills ServCellInfo IE
2166  *
2167  * @details
2168  *
2169  *    Function : fillServedCellInfo
2170  *
2171  *    Functionality: Fills ServCellInfo
2172  *
2173  * @params[in] Pointer to Served_Cell_Information_t *
2174  *
2175  * @return ROK     - success
2176  *         RFAILED - failure
2177  *
2178  *****************************************************************/
2179
2180 uint8_t fillServedCellInfo(Served_Cell_Information_t *srvCellInfo)
2181 {
2182    uint8_t tmp, ieIdx, ieListCnt;
2183
2184    /*nRCGI*/
2185    srvCellInfo->nRCGI.pLMN_Identity.size =3*sizeof(uint8_t);
2186    DU_ALLOC(srvCellInfo->nRCGI.pLMN_Identity.buf,\
2187          srvCellInfo->nRCGI.pLMN_Identity.size);
2188    if(srvCellInfo->nRCGI.pLMN_Identity.buf == NULLP)
2189    {
2190       return RFAILED;
2191    }
2192    buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrCgi.plmn,\
2193          srvCellInfo->nRCGI.pLMN_Identity.buf);
2194    srvCellInfo->nRCGI.nRCellIdentity.size =5*sizeof(uint8_t);
2195    DU_ALLOC(srvCellInfo->nRCGI.nRCellIdentity.buf,\
2196          srvCellInfo->nRCGI.nRCellIdentity.size);
2197    if(srvCellInfo->nRCGI.nRCellIdentity.buf == NULLP)
2198    {
2199       return RFAILED;
2200    }
2201    for (tmp = 0 ; tmp < srvCellInfo->\
2202          nRCGI.nRCellIdentity.size-1 ; tmp++)
2203    {
2204       srvCellInfo->nRCGI.nRCellIdentity.buf[tmp] = 0;
2205    }
2206    srvCellInfo->nRCGI.nRCellIdentity.buf[4] = 16;
2207    srvCellInfo->nRCGI.nRCellIdentity.bits_unused =4;
2208
2209    /*nRPCI*/
2210    srvCellInfo->nRPCI = duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrPci;
2211
2212    /*servedPLMNs*/
2213    ieListCnt = 1;
2214    srvCellInfo->servedPLMNs.list.count = ieListCnt;
2215    srvCellInfo->servedPLMNs.list.size = ieListCnt*sizeof(ServedPLMNs_Item_t *);
2216    DU_ALLOC(srvCellInfo->servedPLMNs.list.array,\
2217          srvCellInfo->servedPLMNs.list.size);
2218    if(srvCellInfo->servedPLMNs.list.array == NULLP)
2219    {
2220       return RFAILED;
2221    }
2222    for(ieIdx=0; ieIdx < ieListCnt; ieIdx++)
2223    {
2224       DU_ALLOC(srvCellInfo->servedPLMNs.list.array[ieIdx],\
2225             sizeof(ServedPLMNs_Item_t));
2226       if(srvCellInfo->servedPLMNs.list.array[ieIdx]== NULLP)
2227       {
2228          return RFAILED;
2229       }
2230    }
2231    if(fillServedPlmns(&srvCellInfo->servedPLMNs))
2232    {
2233       return RFAILED;
2234    }
2235
2236    /*nR Mode Info with FDD*/
2237    srvCellInfo->nR_Mode_Info.present = NR_Mode_Info_PR_fDD;
2238    DU_ALLOC(srvCellInfo->nR_Mode_Info.choice.fDD,\
2239          sizeof(FDD_Info_t));
2240    if(srvCellInfo->nR_Mode_Info.choice.fDD == NULLP)
2241    {
2242       return RFAILED;
2243    }
2244    if(fillNrFddInfo(&srvCellInfo->nR_Mode_Info))
2245       return RFAILED;
2246
2247    /*Measurement timing Config*/
2248    srvCellInfo->measurementTimingConfiguration.size = sizeof(uint8_t);
2249    DU_ALLOC(srvCellInfo->measurementTimingConfiguration.\
2250          buf,srvCellInfo->measurementTimingConfiguration.size);
2251    if(srvCellInfo->measurementTimingConfiguration.buf == NULLP)
2252    {
2253       return RFAILED;
2254    }
2255    srvCellInfo->measurementTimingConfiguration.\
2256          buf[0] = duCfgParam.srvdCellLst[0].duCellInfo.measTimeCfg;
2257
2258    return ROK;
2259 }
2260
2261 /*******************************************************************
2262  *
2263  * @brief Fills ServCellToModItem IE
2264  *
2265  * @details
2266  *
2267  *    Function : fillServCellToModItem
2268  *
2269  *    Functionality: Fills ServCellToModItem IE
2270  *
2271  * @params[in] Pointer to Served_Cells_To_Modify_Item_t *
2272  *
2273  * @return ROK     - success
2274  *         RFAILED - failure
2275  *
2276  *****************************************************************/
2277
2278 uint8_t fillServCellToModItem(Served_Cells_To_Modify_Item_t *modifyItem)
2279 {
2280    uint8_t ieIdx;
2281
2282    /*pLMN_Identity*/
2283    modifyItem->oldNRCGI.pLMN_Identity.size = 3*sizeof(uint8_t);
2284    DU_ALLOC(modifyItem->oldNRCGI.pLMN_Identity.buf,modifyItem->oldNRCGI.pLMN_Identity.size);
2285    if(modifyItem->oldNRCGI.pLMN_Identity.buf == NULLP)
2286    {
2287       return RFAILED;
2288    }
2289    buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrCgi.plmn,\
2290          modifyItem->oldNRCGI.pLMN_Identity.buf);
2291
2292    /*nRCellIdentity*/
2293    modifyItem->oldNRCGI.nRCellIdentity.size = 5*sizeof(uint8_t);
2294    DU_ALLOC(modifyItem->oldNRCGI.nRCellIdentity.buf,\
2295          modifyItem->oldNRCGI.nRCellIdentity.size);
2296    if(modifyItem->oldNRCGI.nRCellIdentity.buf == NULLP)
2297    {
2298       return RFAILED;
2299    }
2300    for(ieIdx = 0; ieIdx < modifyItem->oldNRCGI.nRCellIdentity.size-1; ieIdx++)
2301    {
2302       modifyItem->oldNRCGI.nRCellIdentity.buf[ieIdx] = 0;
2303    }
2304    modifyItem->oldNRCGI.nRCellIdentity.buf[4] = 16;
2305    modifyItem->oldNRCGI.nRCellIdentity.bits_unused = 4;
2306
2307    if(fillServedCellInfo(&modifyItem->served_Cell_Information))
2308       return RFAILED;
2309    else
2310       return ROK;
2311 }
2312
2313 /*******************************************************************
2314  *
2315  * @brief Builds ServCellToModList
2316  *
2317  * @details
2318  *
2319  *    Function : buildServCellToModList
2320  *
2321  *    Functionality: Builds the serv cell to Mod List
2322  *
2323  * @params[in] Pointer to Served_Cells_To_Modify_List_t *
2324  *
2325  * @return ROK     - success
2326  *         RFAILED - failure
2327  *
2328  *****************************************************************/
2329
2330 uint8_t buildServCellToModList(Served_Cells_To_Modify_List_t *cellsToModify)
2331 {
2332    uint8_t ieListCnt, ieIdx;
2333    Served_Cells_To_Modify_Item_t *modifyItem = NULLP;
2334
2335    ieListCnt = 1;
2336    cellsToModify->list.count = ieListCnt;
2337    cellsToModify->list.size = ieListCnt*sizeof(Served_Cells_To_Modify_ItemIEs_t *);
2338    DU_ALLOC(cellsToModify->list.array,cellsToModify->list.size);
2339    if(cellsToModify->list.array == NULLP)
2340    {
2341       return RFAILED;
2342    }
2343    for(ieIdx=0; ieIdx< ieListCnt; ieIdx++)
2344    {
2345       DU_ALLOC(cellsToModify->list.array[ieIdx],sizeof(Served_Cells_To_Modify_ItemIEs_t));
2346       if(cellsToModify->list.array[ieIdx] == NULLP)
2347       {
2348          return RFAILED;
2349       }
2350    }
2351    cellsToModify->list.array[0]->id = ProtocolIE_ID_id_Served_Cells_To_Modify_Item;
2352    cellsToModify->list.array[0]->criticality = Criticality_reject;
2353    cellsToModify->list.array[0]->value.present =\
2354       Served_Cells_To_Modify_ItemIEs__value_PR_Served_Cells_To_Modify_Item;
2355    modifyItem=&cellsToModify->list.array[0]->value.choice.Served_Cells_To_Modify_Item;
2356
2357    if(fillServCellToModItem(modifyItem))
2358       return RFAILED;
2359    else
2360       return ROK;
2361 }
2362
2363 /*******************************************************************
2364  *
2365  * @brief Builds and sends the DUConfigUpdate
2366  *
2367  * @details
2368  *
2369  *    Function : BuildAndSendDUConfigUpdate
2370  *
2371  *    Functionality: Constructs the DU Update message and sends
2372  *                   it to the CU through SCTP.
2373  *
2374  * @params[in] void **buf,Buffer to which encoded pattern is written into
2375  * @params[in] int *size,size of buffer
2376  *
2377  * @return ROK     - success
2378  *         RFAILED - failure
2379  *
2380  * ****************************************************************/
2381 uint8_t BuildAndSendDUConfigUpdate()
2382 {
2383    uint8_t ret, ieIdx, elementCnt;
2384    F1AP_PDU_t                 *f1apDuCfg = NULLP;
2385    GNBDUConfigurationUpdate_t *duCfgUpdate = NULLP;
2386    asn_enc_rval_t encRetVal;     /* Encoder return value */
2387    memset(&encRetVal, 0, sizeof(asn_enc_rval_t));
2388    ret= RFAILED;
2389
2390    while(true)
2391    {
2392       DU_LOG("\nINFO   -->  F1AP : Building DU config update\n");
2393       /* Allocate the memory for F1DuCfg */
2394       DU_ALLOC(f1apDuCfg, sizeof(F1AP_PDU_t));
2395       if(f1apDuCfg == NULLP)
2396       {
2397          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
2398          break;
2399       }
2400
2401       f1apDuCfg->present = F1AP_PDU_PR_initiatingMessage;
2402       DU_ALLOC(f1apDuCfg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
2403       if(f1apDuCfg->choice.initiatingMessage == NULLP)
2404       {
2405          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
2406          break;
2407       }
2408
2409       f1apDuCfg->choice.initiatingMessage->procedureCode = \
2410                                                            ProcedureCode_id_gNBDUConfigurationUpdate;
2411       f1apDuCfg->choice.initiatingMessage->criticality = Criticality_reject;
2412       f1apDuCfg->choice.initiatingMessage->value.present = \
2413                                                            InitiatingMessage__value_PR_GNBDUConfigurationUpdate;
2414       duCfgUpdate = &f1apDuCfg->choice.initiatingMessage->value.\
2415                     choice.GNBDUConfigurationUpdate;
2416       elementCnt = 3;
2417       duCfgUpdate->protocolIEs.list.count = elementCnt;
2418       duCfgUpdate->protocolIEs.list.size = \
2419                                            elementCnt * sizeof(GNBDUConfigurationUpdateIEs_t*);
2420
2421       /* Initialize the F1Setup members */
2422       DU_ALLOC(duCfgUpdate->protocolIEs.list.array,duCfgUpdate->protocolIEs.list.size);
2423       if(duCfgUpdate->protocolIEs.list.array == NULLP)
2424       {
2425          DU_LOG("ERROR  -->  F1AP : Memory allocation for F1RequestIEs failed");
2426          break;
2427       }
2428       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
2429       {
2430          DU_ALLOC(duCfgUpdate->protocolIEs.list.array[ieIdx],sizeof(GNBDUConfigurationUpdateIEs_t));
2431          if(duCfgUpdate->protocolIEs.list.array[ieIdx] == NULLP)
2432          {
2433             break;
2434          }
2435       }
2436
2437       /*TransactionID*/
2438       ieIdx = 0;
2439       duCfgUpdate->protocolIEs.list.array[ieIdx]->id=ProtocolIE_ID_id_TransactionID;
2440       duCfgUpdate->protocolIEs.list.array[ieIdx]->criticality= Criticality_reject;
2441       duCfgUpdate->protocolIEs.list.array[ieIdx]->value.present = \
2442          GNBDUConfigurationUpdateIEs__value_PR_TransactionID;
2443       duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.TransactionID = TRANS_ID;
2444
2445       /*Served Cell to Modify */
2446       ieIdx++;
2447       duCfgUpdate->protocolIEs.list.array[ieIdx]->id = \
2448                                                       ProtocolIE_ID_id_Served_Cells_To_Modify_List;
2449       duCfgUpdate->protocolIEs.list.array[ieIdx]->criticality =Criticality_reject;
2450       duCfgUpdate->protocolIEs.list.array[ieIdx]->value.present = \
2451          GNBDUConfigurationUpdateIEs__value_PR_Served_Cells_To_Modify_List;
2452       if(buildServCellToModList(&duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.\
2453          Served_Cells_To_Modify_List))
2454          break;
2455
2456       // NOTE :GNB DU SYS INFO:MIB AND SIB1 INFORMATION TO BE BUILT AND FILLED HERE
2457       /*GNB DU ID */
2458       ieIdx++;
2459       duCfgUpdate->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_ID;
2460       duCfgUpdate->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
2461       duCfgUpdate->protocolIEs.list.array[ieIdx]->value.present = \
2462         GNBDUConfigurationUpdateIEs__value_PR_GNB_DU_ID;
2463       duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.size = sizeof(uint8_t);
2464       DU_ALLOC(duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf,\
2465             duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.size);
2466       if(duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf == NULLP)
2467       {
2468          break;
2469       }
2470       duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf[0] = duCfgParam.duId;
2471
2472       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apDuCfg);
2473
2474       /* Encode the DU Config Update type as APER */
2475       memset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
2476       encBufSize = 0;
2477       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apDuCfg, PrepFinalEncBuf, encBuf);
2478
2479       /* Checking encode results */
2480       if(encRetVal.encoded == ENCODE_FAIL)
2481       {
2482          DU_LOG("ERROR  -->  F1AP : Could not encode DUConfigUpdate structure (at %s)\n",\
2483          encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
2484          break;
2485       }
2486       else
2487       {
2488          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for DUConfigUpdate\n");
2489          for(ieIdx =0; ieIdx < encBufSize; ieIdx++)
2490          {
2491             printf("%x",encBuf[ieIdx]);
2492          }
2493       }
2494       /* Sending msg */
2495       if(SendF1APMsg(DU_APP_MEM_REGION, DU_POOL) != ROK)
2496       {
2497          DU_LOG("\nERROR  -->  F1AP : Sending GNB-DU Config Update failed");
2498          break;
2499       }
2500
2501       ret = ROK;
2502       break;
2503    }
2504    FreeDUConfigUpdate(f1apDuCfg);
2505
2506    return ret;
2507 }
2508
2509
2510 /*******************************************************************
2511  *
2512  * @brief free the ULRRCMessageTransfer
2513  *
2514  * @details
2515  *
2516  *    Function : FreeULRRCMessageTransfer
2517  *
2518  *    Functionality: Deallocating the memory of variable allocated in
2519  *                      FreeULRRCMessageTransfer
2520  *
2521  * @params[in]
2522  *
2523  * @return ROK     - void
2524  *
2525  ******************************************************************/
2526 void FreeULRRCMessageTransfer( F1AP_PDU_t *f1apMsg)
2527 {
2528    uint8_t idx1;
2529    ULRRCMessageTransfer_t  *ulRRCMsg;
2530
2531    if(f1apMsg != NULLP)
2532    {
2533       if(f1apMsg->choice.initiatingMessage != NULLP)
2534       {
2535          ulRRCMsg = &f1apMsg->choice.initiatingMessage->value.choice.ULRRCMessageTransfer;
2536          if(ulRRCMsg->protocolIEs.list.array != NULLP)
2537          {
2538             for(idx1=0;idx1<ulRRCMsg->protocolIEs.list.count;idx1++)
2539             {
2540                if(ulRRCMsg->protocolIEs.list.array[idx1] != NULLP)
2541                {
2542                   if(ulRRCMsg->protocolIEs.list.array[idx1]->value.present ==
2543                         ULRRCMessageTransferIEs__value_PR_RRCContainer)
2544                   {
2545                      DU_FREE(ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.buf,
2546                            ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.size);
2547                   }
2548                   DU_FREE(ulRRCMsg->protocolIEs.list.array[idx1],sizeof(ULRRCMessageTransferIEs_t));
2549                }
2550             }
2551             DU_FREE(ulRRCMsg->protocolIEs.list.array,ulRRCMsg->protocolIEs.list.size );
2552          }
2553          DU_FREE(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
2554       }
2555       DU_FREE(f1apMsg,sizeof(F1AP_PDU_t));
2556    }
2557 }
2558 /*******************************************************************
2559  *
2560  * @brief Builds and sends the ULRRCMessageTransfer
2561  *
2562  * @details
2563  *
2564  *    Function : BuildAndSendULRRCMessageTransfer
2565  *
2566  *    Functionality: Constructs the UL RRC Message Transfer and sends
2567  *                   it to the CU through SCTP.
2568  *
2569  * @params[in]
2570  *
2571  * @return ROK     - success
2572  *         RFAILED - failure
2573  *
2574  * ****************************************************************/
2575 uint8_t BuildAndSendULRRCMessageTransfer(DuUeCb  ueCb, uint8_t lcId, \
2576       uint16_t msgLen, uint8_t *rrcMsg)
2577 {
2578    uint8_t   elementCnt =0;
2579    uint8_t   idx1 =0;
2580    uint8_t   idx =0;
2581    F1AP_PDU_t                   *f1apMsg = NULLP;
2582    ULRRCMessageTransfer_t       *ulRRCMsg = NULLP;
2583    asn_enc_rval_t               encRetVal;        /* Encoder return value */
2584    uint8_t ret =RFAILED;
2585
2586    memset(&encRetVal, 0, sizeof(asn_enc_rval_t));
2587
2588    while(true)
2589    {
2590       DU_LOG("\n INFO   -->  F1AP : Building UL RRC Message Transfer Message\n");
2591
2592       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
2593       if(f1apMsg == NULLP)
2594       {
2595          DU_LOG(" ERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
2596          break;
2597       }
2598       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
2599       DU_ALLOC(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
2600       if(f1apMsg->choice.initiatingMessage == NULLP)
2601       {
2602          DU_LOG(" ERROR  -->  F1AP : Memory allocation for      F1AP-PDU failed");
2603          break;
2604       }
2605       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_ULRRCMessageTransfer;
2606       f1apMsg->choice.initiatingMessage->criticality = Criticality_ignore;
2607       f1apMsg->choice.initiatingMessage->value.present = \
2608                                                          InitiatingMessage__value_PR_ULRRCMessageTransfer;
2609       ulRRCMsg =
2610          &f1apMsg->choice.initiatingMessage->value.choice.ULRRCMessageTransfer;
2611       elementCnt = 4;
2612       ulRRCMsg->protocolIEs.list.count = elementCnt;
2613       ulRRCMsg->protocolIEs.list.size = \
2614                                         elementCnt * sizeof(ULRRCMessageTransferIEs_t *);
2615
2616       /* Initialize the F1Setup members */
2617       DU_ALLOC(ulRRCMsg->protocolIEs.list.array, ulRRCMsg->protocolIEs.list.size);
2618       if(ulRRCMsg->protocolIEs.list.array == NULLP)
2619       {
2620          DU_LOG(" ERROR  -->  F1AP : Memory allocation for UL RRC MessageTransferIEs failed");
2621          break;
2622       }
2623       for(idx=0; idx<elementCnt; idx++)
2624       {
2625          DU_ALLOC(ulRRCMsg->protocolIEs.list.array[idx],sizeof(ULRRCMessageTransferIEs_t));
2626          if(ulRRCMsg->protocolIEs.list.array[idx] == NULLP)
2627          {
2628             break;
2629          }
2630       }
2631
2632       idx1 = 0;
2633
2634       /*GNB CU UE F1AP ID*/
2635       ulRRCMsg->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
2636       ulRRCMsg->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
2637       ulRRCMsg->protocolIEs.list.array[idx1]->value.present = \
2638                                                               ULRRCMessageTransferIEs__value_PR_GNB_CU_UE_F1AP_ID;
2639       ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.GNB_CU_UE_F1AP_ID = ueCb.gnbCuUeF1apId;
2640
2641       /*GNB DU UE F1AP ID*/
2642       idx1++;
2643       ulRRCMsg->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
2644       ulRRCMsg->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
2645       ulRRCMsg->protocolIEs.list.array[idx1]->value.present = \
2646                                                               ULRRCMessageTransferIEs__value_PR_GNB_DU_UE_F1AP_ID;
2647       ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.GNB_DU_UE_F1AP_ID = ueCb.gnbDuUeF1apId;
2648
2649       /*SRBID*/
2650       idx1++;
2651       ulRRCMsg->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_SRBID;
2652       ulRRCMsg->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
2653       ulRRCMsg->protocolIEs.list.array[idx1]->value.present = \
2654                                                               ULRRCMessageTransferIEs__value_PR_SRBID;
2655       ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.SRBID = lcId;
2656
2657       /*RRCContainer*/
2658       idx1++;
2659       ulRRCMsg->protocolIEs.list.array[idx1]->id  = ProtocolIE_ID_id_RRCContainer;
2660       ulRRCMsg->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
2661       ulRRCMsg->protocolIEs.list.array[idx1]->value.present = \
2662                                                               ULRRCMessageTransferIEs__value_PR_RRCContainer;
2663       ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.size = msgLen;
2664       DU_ALLOC(ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.buf,
2665             ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.size)
2666       if(!ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.buf)
2667       {
2668          DU_LOG(" ERROR  -->  F1AP : Memory allocation for BuildAndSendULRRCMessageTransfer failed");
2669          break;
2670       }
2671       memset(ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.buf, 0, msgLen);
2672       memcpy(ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.buf, \
2673             rrcMsg, ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.size);
2674
2675       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
2676
2677       /* Encode the F1SetupRequest type as APER */
2678       memset(encBuf, 0, ENC_BUF_MAX_LEN);
2679       encBufSize = 0;
2680       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
2681             encBuf);
2682       /* Encode results */
2683       if(encRetVal.encoded == ENCODE_FAIL)
2684       {
2685          DU_LOG( "\nERROR  -->  F1AP : Could not encode ULRRCMessageTransfer structure (at %s)\n",\
2686                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
2687          break;
2688       }
2689       else
2690       {
2691          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for ULRRCMessageTransfer\n");
2692          for(int i=0; i< encBufSize; i++)
2693          {
2694             printf("%x",encBuf[i]);
2695          }
2696       }
2697
2698       /* Sending  msg  */
2699       if(SendF1APMsg(DU_APP_MEM_REGION,DU_POOL) !=      ROK)
2700       {
2701          DU_LOG("\nERROR  -->   F1AP : Sending  UL RRC Message Transfer Failed");
2702          break;
2703       }
2704       ret = ROK;
2705       break;
2706    }
2707    FreeULRRCMessageTransfer(f1apMsg);
2708
2709    return ret;
2710 }/* End of BuildAndSendULRRCMessageTransfer*/
2711
2712 /*******************************************************************
2713  *
2714  * @brief Builds tag config
2715  *
2716  * @details
2717  *
2718  *    Function : BuildTagConfig
2719  *
2720  *    Functionality: Builds tag config in MacCellGroupConfig
2721  *
2722  * @params[in] TAG_Config *tag_Config
2723  *
2724  * @return ROK     - success
2725  *         RFAILED - failure
2726  *
2727  * ****************************************************************/
2728 uint8_t BuildTagConfig(struct TAG_Config *tagConfig)
2729 {
2730    struct TAG_Config__tag_ToAddModList *tagList;
2731    uint8_t                     idx, elementCnt;
2732
2733    tagConfig->tag_ToReleaseList = NULLP;
2734    tagConfig->tag_ToAddModList = NULLP;
2735    DU_ALLOC(tagConfig->tag_ToAddModList, sizeof(struct TAG_Config__tag_ToAddModList));
2736    if(!tagConfig->tag_ToAddModList)
2737    {
2738       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildTagConfig");
2739       return RFAILED;
2740    }
2741
2742    elementCnt = 1; //ODU_VALUE_ONE;
2743    tagList = tagConfig->tag_ToAddModList;
2744    tagList->list.count = elementCnt;
2745    tagList->list.size  =  elementCnt * sizeof(struct TAG *);
2746
2747    tagList->list.array = NULLP;
2748    DU_ALLOC(tagList->list.array, tagList->list.size);
2749    if(!tagList->list.array)
2750    {
2751       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildTagConfig");
2752       return RFAILED;
2753    }
2754
2755    for(idx=0; idx<tagList->list.count; idx++)
2756    {
2757       tagList->list.array[idx] = NULLP;
2758       DU_ALLOC(tagList->list.array[idx], sizeof(struct TAG));
2759       if(!tagList->list.array[idx])
2760       {
2761          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildTagConfig");
2762          return RFAILED;
2763       }
2764    }
2765
2766    idx = 0;
2767    tagList->list.array[idx]->tag_Id = TAG_ID;
2768    tagList->list.array[idx]->timeAlignmentTimer = TIME_ALIGNMENT_TMR;
2769
2770    return ROK;
2771 }
2772
2773 /*******************************************************************
2774  *
2775  * @brief Builds PHR Config
2776  *
2777  * @details
2778  *
2779  *    Function : BuildPhrConfig
2780  *
2781  *    Functionality: Builds phrConfig in MacCellGroupConfig
2782  *
2783  * @params[in] PHR Config *
2784  *
2785  * @return ROK     - success
2786  *         RFAILED - failure
2787  *
2788  * ****************************************************************/
2789 uint8_t BuildPhrConfig(struct MAC_CellGroupConfig__phr_Config *phrConfig)
2790 {
2791
2792    phrConfig->present = MAC_CellGroupConfig__phr_Config_PR_setup;
2793    phrConfig->choice.setup = NULLP;
2794    DU_ALLOC(phrConfig->choice.setup, sizeof(struct PHR_Config));
2795    if(!phrConfig->choice.setup)
2796    {
2797       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildPhrConfig");
2798       return RFAILED;
2799    }
2800
2801    phrConfig->choice.setup->phr_PeriodicTimer        = PHR_PERIODIC_TMR;
2802    phrConfig->choice.setup->phr_ProhibitTimer        = PHR_PROHIBHIT_TMR;
2803    phrConfig->choice.setup->phr_Tx_PowerFactorChange = PHR_PWR_FACTOR_CHANGE;
2804    phrConfig->choice.setup->multiplePHR              = false;
2805    phrConfig->choice.setup->dummy                    = false;
2806    phrConfig->choice.setup->phr_Type2OtherCell       = false;
2807    phrConfig->choice.setup->phr_ModeOtherCG          = PHR_MODE_OTHER_CG;
2808
2809    return ROK;
2810 }
2811
2812 /*******************************************************************
2813  *
2814  * @brief Builds BSR Config
2815  *
2816  * @details
2817  *
2818  *    Function : BuildBsrConfig
2819  *
2820  *    Functionality: Builds BuildBsrConfig in MacCellGroupConfig
2821  *
2822  * @params[in] BSR_Config *bsrConfig
2823  *
2824  * @return ROK     - success
2825  *         RFAILED - failure
2826  *
2827  * ****************************************************************/
2828 uint8_t BuildBsrConfig(struct BSR_Config *bsrConfig)
2829 {
2830    bsrConfig->periodicBSR_Timer = PERIODIC_BSR_TMR;
2831    bsrConfig->retxBSR_Timer     = RETX_BSR_TMR;
2832    bsrConfig->logicalChannelSR_DelayTimer = NULLP;
2833
2834    return ROK;
2835 }
2836
2837 /*******************************************************************
2838  *
2839  * @brief Builds scheduling request config
2840  *
2841  * @details
2842  *
2843  *    Function : BuildSchedulingReqConfig
2844  *
2845  *    Functionality: Builds BuildSchedulingReqConfig in MacCellGroupConfig
2846  *
2847  * @params[in] SchedulingRequestConfig *schedulingRequestConfig
2848  *
2849  * @return ROK     - success
2850  *         RFAILED - failure
2851  *
2852  * ****************************************************************/
2853 uint8_t BuildSchedulingReqConfig(struct SchedulingRequestConfig *schedulingRequestConfig)
2854 {
2855    struct SchedulingRequestConfig__schedulingRequestToAddModList *schReqList;
2856    uint8_t                     idx, elementCnt;
2857
2858    schedulingRequestConfig->schedulingRequestToAddModList = NULLP;
2859    DU_ALLOC(schedulingRequestConfig->schedulingRequestToAddModList,
2860          sizeof(struct SchedulingRequestConfig__schedulingRequestToAddModList));
2861    if(!schedulingRequestConfig->schedulingRequestToAddModList)
2862    {
2863       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSchedulingReqConfig");
2864       return RFAILED;
2865    }
2866
2867    elementCnt = 1; //ODU_VALUE_ONE;
2868    schReqList = schedulingRequestConfig->schedulingRequestToAddModList;
2869    schReqList->list.count = elementCnt;
2870    schReqList->list.size  = elementCnt * sizeof(struct SchedulingRequestToAddMod *);
2871
2872    schReqList->list.array = NULLP;
2873    DU_ALLOC(schReqList->list.array, schReqList->list.size);
2874    if(!schReqList->list.array)
2875    {
2876       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSchedulingReqConfig");
2877       return RFAILED;
2878    }
2879
2880    for(idx=0;idx<schReqList->list.count; idx++)
2881    {
2882       schReqList->list.array[idx] = NULLP;
2883       DU_ALLOC(schReqList->list.array[idx], sizeof(struct SchedulingRequestToAddMod));
2884       if(!schReqList->list.array[idx])
2885       {
2886          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSchedulingReqConfig");
2887          return RFAILED;
2888       }
2889    }
2890
2891    idx = 0;
2892    schReqList->list.array[idx]->schedulingRequestId = SCH_REQ_ID;
2893
2894    schReqList->list.array[idx]->sr_ProhibitTimer = NULLP;
2895    DU_ALLOC(schReqList->list.array[idx]->sr_ProhibitTimer, sizeof(long));
2896    if(!schReqList->list.array[idx]->sr_ProhibitTimer)
2897    {
2898       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSchedulingReqConfig");
2899       return RFAILED;
2900    }
2901    *(schReqList->list.array[idx]->sr_ProhibitTimer) = SR_PROHIBIT_TMR;
2902    schReqList->list.array[idx]->sr_TransMax = SR_TRANS_MAX;
2903    schedulingRequestConfig->schedulingRequestToReleaseList = NULLP;
2904
2905    return ROK;
2906 }
2907
2908 /*******************************************************************
2909  *
2910  * @brief Builds RLC Config
2911  *
2912  * @details
2913  *
2914  *    Function : BuildRlcConfig
2915  *
2916  *    Functionality: Builds RLC Config in BuildRlcBearerToAddModList
2917  *
2918  * @params[in] RLC_Config *rlcConfig
2919  *
2920  * @return ROK     - success
2921  *         RFAILED - failure
2922  *
2923  * ****************************************************************/
2924 uint8_t BuildRlcConfig(struct RLC_Config *rlcConfig)
2925 {
2926
2927    rlcConfig->present = RLC_Config_PR_am;
2928
2929    rlcConfig->choice.am = NULLP;
2930    DU_ALLOC(rlcConfig->choice.am, sizeof(struct RLC_Config__am));
2931    if(!rlcConfig->choice.am)
2932    {
2933       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfig");
2934       return RFAILED;
2935    }
2936
2937    /* UL */
2938    rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength = NULLP;
2939    DU_ALLOC(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
2940    if(!rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength)
2941    {
2942       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfig");
2943       return RFAILED;
2944    }
2945    *(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength) = SN_FIELD_LEN;
2946    rlcConfig->choice.am->ul_AM_RLC.t_PollRetransmit  = T_POLL_RETRANSMIT;
2947    rlcConfig->choice.am->ul_AM_RLC.pollPDU           = POLL_PDU;
2948    rlcConfig->choice.am->ul_AM_RLC.pollByte          = POLL_BYTE;
2949    rlcConfig->choice.am->ul_AM_RLC.maxRetxThreshold  = MAX_RETX_THRESHOLD;
2950
2951    /* DL */
2952    rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength = NULLP;
2953    DU_ALLOC(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
2954    if(!rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength)
2955    {
2956       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfig");
2957       return RFAILED;
2958    }
2959    *(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength) = SN_FIELD_LEN;
2960    rlcConfig->choice.am->dl_AM_RLC.t_Reassembly      = T_REASSEMBLY;
2961    rlcConfig->choice.am->dl_AM_RLC.t_StatusProhibit  = T_STATUS_PROHIBHIT;
2962
2963    return ROK;
2964 }
2965
2966 /*******************************************************************
2967  *
2968  * @brief Builds MAC LC Config
2969  *
2970  * @details
2971  *
2972  *    Function : BuildMacLCConfig
2973  *
2974  *    Functionality: Builds MAC LC Config in BuildRlcBearerToAddModList
2975  *
2976  * @params[in] struct LogicalChannelConfig macLcConfig
2977  *
2978  * @return ROK     - success
2979  *         RFAILED - failure
2980  *
2981  * ****************************************************************/
2982 uint8_t BuildMacLCConfig(struct LogicalChannelConfig *macLcConfig)
2983 {
2984
2985    macLcConfig->ul_SpecificParameters = NULLP;
2986    DU_ALLOC(macLcConfig->ul_SpecificParameters, sizeof(struct LogicalChannelConfig__ul_SpecificParameters));
2987    if(!macLcConfig->ul_SpecificParameters)
2988    {
2989       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacLCConfig");
2990       return RFAILED;
2991    }
2992
2993    macLcConfig->ul_SpecificParameters->priority = MAC_LC_PRIORITY;
2994    macLcConfig->ul_SpecificParameters->prioritisedBitRate =     PRIORTISIED_BIT_RATE;
2995    macLcConfig->ul_SpecificParameters->bucketSizeDuration =     BUCKET_SIZE_DURATION;
2996    macLcConfig->ul_SpecificParameters->allowedServingCells = NULLP;
2997    macLcConfig->ul_SpecificParameters->allowedSCS_List = NULLP;
2998    macLcConfig->ul_SpecificParameters->maxPUSCH_Duration = NULLP;
2999    macLcConfig->ul_SpecificParameters->configuredGrantType1Allowed = NULLP;
3000
3001    macLcConfig->ul_SpecificParameters->logicalChannelGroup = NULLP;
3002    DU_ALLOC(macLcConfig->ul_SpecificParameters->logicalChannelGroup,    sizeof(long));
3003    if(!macLcConfig->ul_SpecificParameters->logicalChannelGroup)
3004    {
3005       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacLCConfig");
3006       return RFAILED;
3007    }
3008    *(macLcConfig->ul_SpecificParameters->logicalChannelGroup) = LC_GRP;
3009
3010    macLcConfig->ul_SpecificParameters->schedulingRequestID = NULLP;
3011    DU_ALLOC(macLcConfig->ul_SpecificParameters->schedulingRequestID,    sizeof(SchedulingRequestId_t));
3012    if(!macLcConfig->ul_SpecificParameters->schedulingRequestID)
3013    {
3014       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacLCConfig");
3015       return RFAILED;
3016    }
3017    *(macLcConfig->ul_SpecificParameters->schedulingRequestID) = SCH_REQ_ID;
3018
3019    macLcConfig->ul_SpecificParameters->logicalChannelSR_Mask = false;
3020    macLcConfig->ul_SpecificParameters->logicalChannelSR_DelayTimerApplied = false;
3021    macLcConfig->ul_SpecificParameters->bitRateQueryProhibitTimer = NULLP;
3022
3023    return ROK;
3024 }
3025
3026 /*******************************************************************
3027  *
3028  * @brief Builds RLC Bearer to Add/Mod list
3029  *
3030  * @details
3031  *
3032  *    Function :BuildRlcBearerToAddModList
3033  *
3034  *    Functionality: Builds RLC Bearer to Add/Mod list in DuToCuRrcContainer
3035  *
3036  * @params[in] rlc_BearerToAddModList
3037  *
3038  * @return ROK     - success
3039  *         RFAILED - failure
3040  *
3041  * ****************************************************************/
3042 uint8_t BuildRlcBearerToAddModList(struct CellGroupConfigRrc__rlc_BearerToAddModList *rlcBearerList)
3043 {
3044    uint8_t                     idx, elementCnt;
3045
3046    elementCnt = 1;
3047    rlcBearerList->list.count = elementCnt;
3048    rlcBearerList->list.size  = elementCnt * sizeof(struct RLC_BearerConfig *);
3049
3050    rlcBearerList->list.array = NULLP;
3051    DU_ALLOC(rlcBearerList->list.array, rlcBearerList->list.size);
3052    if(!rlcBearerList->list.array)
3053    {
3054       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
3055       return RFAILED;
3056    }
3057
3058    for(idx=0; idx<rlcBearerList->list.count; idx++)
3059    {
3060       rlcBearerList->list.array[idx] = NULLP;
3061       DU_ALLOC(rlcBearerList->list.array[idx], sizeof(struct RLC_BearerConfig));
3062       if(!rlcBearerList->list.array[idx])
3063       {
3064          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
3065          return RFAILED;
3066       }
3067    }
3068
3069    idx = 0;
3070    rlcBearerList->list.array[idx]->logicalChannelIdentity = SRB1_LCID;
3071
3072    DU_ALLOC(rlcBearerList->list.array[idx]->servedRadioBearer, \
3073       sizeof(struct RLC_BearerConfig__servedRadioBearer));
3074    if(!rlcBearerList->list.array[idx]->servedRadioBearer)
3075    {
3076       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
3077       return RFAILED;
3078    }
3079
3080    rlcBearerList->list.array[idx]->servedRadioBearer->present = \
3081       RLC_BearerConfig__servedRadioBearer_PR_srb_Identity;
3082    rlcBearerList->list.array[idx]->servedRadioBearer->choice.srb_Identity = \
3083       SRB1_LCID;
3084
3085    rlcBearerList->list.array[idx]->reestablishRLC = NULLP;
3086    rlcBearerList->list.array[idx]->rlc_Config = NULLP;
3087    DU_ALLOC(rlcBearerList->list.array[idx]->rlc_Config, sizeof(struct RLC_Config));
3088    if(!rlcBearerList->list.array[idx]->rlc_Config)
3089    {
3090       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
3091       return RFAILED;
3092    }
3093
3094    if(BuildRlcConfig(rlcBearerList->list.array[idx]->rlc_Config) != ROK)
3095    {
3096       DU_LOG("\nERROR  -->  F1AP : BuildRlcConfig failed");
3097       return RFAILED;
3098    }
3099
3100    rlcBearerList->list.array[idx]->mac_LogicalChannelConfig = NULLP;
3101    DU_ALLOC(rlcBearerList->list.array[idx]->mac_LogicalChannelConfig, \
3102       sizeof(struct LogicalChannelConfig));
3103    if(!rlcBearerList->list.array[idx]->mac_LogicalChannelConfig)
3104    {
3105       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
3106       return RFAILED;
3107    }
3108
3109    if(BuildMacLCConfig(rlcBearerList->list.array[idx]->mac_LogicalChannelConfig) != ROK)
3110    {
3111       DU_LOG("\nERROR  -->  F1AP : BuildMacLCConfig failed");
3112       return RFAILED;
3113    }
3114
3115    return ROK;
3116 }
3117
3118 /*******************************************************************
3119  *
3120  * @brief Build Control resource set to add/modify list
3121  *
3122  * @details
3123  *
3124  *    Function : BuildControlRSetToAddModList
3125  *
3126  *    Functionality: Build Control resource set to add/modify list
3127  *
3128  * @params[in]
3129  * struct PDCCH_Config__controlResourceSetToAddModList *controlRSetList
3130  *
3131  * @return ROK     - success
3132  *         RFAILED - failure
3133  *
3134  * ****************************************************************/
3135    uint8_t BuildControlRSetToAddModList
3136 (
3137  struct PDCCH_Config__controlResourceSetToAddModList *controlRSetList
3138  )
3139 {
3140    uint8_t idx;
3141    uint8_t elementCnt;
3142    uint8_t numBytes, bitsUnused;
3143    struct ControlResourceSet *controlRSet;
3144    uint8_t freqDomainResource[FREQ_DOM_RSRC_SIZE] = {0};
3145    uint8_t coreset0EndPrb, coreset1StartPrb, coreset1NumPrb;
3146
3147
3148    elementCnt = 1;
3149    controlRSetList->list.count = elementCnt;
3150    controlRSetList->list.size = \
3151                                 elementCnt * sizeof(struct ControlResourceSet *);
3152
3153    controlRSetList->list.array = NULLP;
3154    DU_ALLOC(controlRSetList->list.array, controlRSetList->list.size);
3155    if(!controlRSetList->list.array)
3156    {
3157       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3158       return RFAILED;
3159    }
3160
3161    for(idx = 0; idx < elementCnt; idx++)
3162    {
3163       controlRSetList->list.array[idx] = NULLP;
3164       DU_ALLOC(controlRSetList->list.array[idx], sizeof(struct ControlResourceSet));
3165       if(!controlRSetList->list.array[idx])
3166       {
3167          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3168          return RFAILED;
3169       }
3170    }
3171
3172    idx=0;
3173    controlRSet = controlRSetList->list.array[idx];
3174
3175    controlRSet->controlResourceSetId = PDCCH_CTRL_RSRC_SET_ONE_ID;
3176
3177    /* size 6 bytes
3178     * 3 LSBs unsued
3179     * Bit string stored ff0000000000
3180     */
3181    numBytes = 6;
3182    bitsUnused = 3;
3183    controlRSet->frequencyDomainResources.size = numBytes * sizeof(uint8_t);
3184
3185    controlRSet->frequencyDomainResources.buf = NULLP;
3186    DU_ALLOC(controlRSet->frequencyDomainResources.buf, \
3187          controlRSet->frequencyDomainResources.size);
3188    if(!controlRSet->frequencyDomainResources.buf)
3189    {
3190       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3191       return RFAILED;
3192    }
3193
3194    memset(controlRSet->frequencyDomainResources.buf, 0, FREQ_DOM_RSRC_SIZE);
3195    coreset0EndPrb = CORESET0_END_PRB;
3196    coreset1StartPrb = coreset0EndPrb + 6;
3197    coreset1NumPrb = CORESET1_NUM_PRB;
3198    /* calculate the PRBs */
3199    freqDomRscAllocType0(((coreset1StartPrb)/6), (coreset1NumPrb/6), freqDomainResource);
3200    memcpy(controlRSet->frequencyDomainResources.buf, freqDomainResource, FREQ_DOM_RSRC_SIZE);
3201    controlRSet->frequencyDomainResources.bits_unused = bitsUnused;
3202
3203    controlRSet->duration = PDCCH_CTRL_RSRC_SET_ONE_DURATION;
3204    controlRSet->cce_REG_MappingType.present = \
3205                                               ControlResourceSet__cce_REG_MappingType_PR_nonInterleaved;
3206
3207    controlRSet->precoderGranularity = PDCCH_CTRL_RSRC_SET_ONE_PRECOD_GRANULARITY;
3208    controlRSet->tci_StatesPDCCH_ToAddList = NULLP;
3209    controlRSet->tci_StatesPDCCH_ToReleaseList = NULLP;
3210    controlRSet->tci_PresentInDCI = NULLP;
3211 #if 0
3212    uint8_t tciStateIdx;
3213
3214    DU_ALLOC(controlRset->tci_StatesPDCCH_ToAddList, \
3215          sizeof(struct ControlResourceSet__tci_StatesPDCCH_ToAddList));
3216    if(!controlRset->tci_StatesPDCCH_ToAddList)
3217    {
3218       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3219       return RFAILED;
3220    }
3221
3222    elementCnt = 1;
3223    controlRset->tci_StatesPDCCH_ToAddList->list.count = elementCnt;
3224    controlRset->tci_StatesPDCCH_ToAddList->list.size = elementCnt * sizeof(TCI_StateId_t *);
3225    DU_ALLOC(controlRset->tci_StatesPDCCH_ToAddList->list.array, \
3226          controlRset->tci_StatesPDCCH_ToAddList->list.size)
3227       if(!controlRset->tci_StatesPDCCH_ToAddList->list.array)
3228       {
3229          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3230          return RFAILED;
3231       }
3232
3233    for(tciStateIdx = 0; tciStateIdx <elementCntl; tciStateIdx++)
3234    {
3235       DU_ALLOC(controlRset->tci_StatesPDCCH_ToAddList->list.array[tciStateIdx], sizeof(TCI_StateId_t));
3236       if(!controlRset->tci_StatesPDCCH_ToAddList->list.array[tciStateIdx])
3237       {
3238          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3239          return RFAILED;
3240       }
3241    }
3242
3243    tciStateIdx = 0;
3244    /* TODO */
3245    *(controlRset->tci_StatesPDCCH_ToAddList->list.array[tciStateIdx]);
3246
3247    DU_ALLOC(controlRset->tci_PresentInDCI, sizeof(long));
3248    if(!controlRset->tci_PresentInDCI)
3249    {
3250       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3251       return RFAILED;
3252    }
3253    /* TODO */
3254    *(controlRset->tci_PresentInDCI);
3255 #endif
3256
3257    controlRSet->pdcch_DMRS_ScramblingID = NULLP;
3258    DU_ALLOC(controlRSet->pdcch_DMRS_ScramblingID, sizeof(long));
3259    if(!controlRSet->pdcch_DMRS_ScramblingID)
3260    {
3261       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3262       return RFAILED;
3263    }
3264    *(controlRSet->pdcch_DMRS_ScramblingID) = SCRAMBLING_ID;
3265
3266    return ROK;
3267 } /* End BuildControlRSetToAddModList */
3268
3269 /*******************************************************************
3270  *
3271  * @brief Build search space to add/modify list
3272  *
3273  * @details
3274  *
3275  *    Function : BuildSearchSpcToAddModList
3276  *
3277  *    Functionality: Build search space to add/modify list
3278  *
3279  * @params[in]
3280  * @return ROK     - success
3281  *         RFAILED - failure
3282  *
3283  * ****************************************************************/
3284    uint8_t BuildSearchSpcToAddModList
3285 (
3286  struct PDCCH_Config__searchSpacesToAddModList *searchSpcList
3287  )
3288 {
3289    uint8_t idx;
3290    uint8_t numBytes;
3291    uint8_t byteIdx;
3292    uint8_t bitsUnused;
3293    uint8_t elementCnt;
3294    struct SearchSpace *searchSpc;
3295
3296    elementCnt = 1;
3297    searchSpcList->list.count = elementCnt;
3298    searchSpcList->list.size = elementCnt * sizeof(struct SearchSpace *);
3299
3300    searchSpcList->list.array = NULLP;
3301    DU_ALLOC(searchSpcList->list.array, searchSpcList->list.size);
3302    if(!searchSpcList->list.array)
3303    {
3304       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3305       return RFAILED;
3306    }
3307
3308    for(idx = 0; idx < elementCnt; idx++)
3309    {
3310       searchSpcList->list.array[idx] = NULLP;
3311       DU_ALLOC(searchSpcList->list.array[idx], sizeof(struct SearchSpace));
3312       if(!searchSpcList->list.array[idx])
3313       {
3314          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3315          return RFAILED;
3316       }
3317    }
3318
3319    idx = 0;
3320    searchSpc = searchSpcList->list.array[idx];
3321
3322    searchSpc->searchSpaceId = PDCCH_SRCH_SPC_TWO_ID;
3323
3324    searchSpc->controlResourceSetId = NULLP;
3325    DU_ALLOC(searchSpc->controlResourceSetId, sizeof(ControlResourceSetId_t));
3326    if(!searchSpc->controlResourceSetId)
3327    {
3328       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3329       return RFAILED;
3330    }
3331    *(searchSpc->controlResourceSetId) = PDCCH_CTRL_RSRC_SET_ONE_ID;
3332
3333    searchSpc->monitoringSlotPeriodicityAndOffset = NULLP;
3334    DU_ALLOC(searchSpc->monitoringSlotPeriodicityAndOffset, \
3335          sizeof(struct SearchSpace__monitoringSlotPeriodicityAndOffset));
3336    if(!searchSpc->monitoringSlotPeriodicityAndOffset)
3337    {
3338       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3339       return RFAILED;
3340    }
3341    searchSpc->monitoringSlotPeriodicityAndOffset->present = \
3342                                                             SearchSpace__monitoringSlotPeriodicityAndOffset_PR_sl1;
3343
3344    searchSpc->duration = NULLP;
3345    searchSpc->monitoringSymbolsWithinSlot = NULLP;
3346    DU_ALLOC(searchSpc->monitoringSymbolsWithinSlot, sizeof(BIT_STRING_t));
3347    if(!searchSpc->monitoringSymbolsWithinSlot)
3348    {
3349       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3350       return RFAILED;
3351    }
3352
3353    /* Values taken from reference logs :
3354     * size 2 bytes
3355     * 2 LSBs unsued
3356     * Bit string stores 8000
3357     */
3358    numBytes = 2;
3359    bitsUnused = 2;
3360
3361    searchSpc->monitoringSymbolsWithinSlot->size = numBytes * sizeof(uint8_t);
3362    searchSpc->monitoringSymbolsWithinSlot->buf = NULLP;
3363    DU_ALLOC(searchSpc->monitoringSymbolsWithinSlot->buf, \
3364          searchSpc->monitoringSymbolsWithinSlot->size);
3365    if(!searchSpc->monitoringSymbolsWithinSlot->buf)
3366    {
3367       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3368       return RFAILED;
3369    }
3370
3371    byteIdx = 0;
3372    searchSpc->monitoringSymbolsWithinSlot->buf[byteIdx++] = \
3373                                                             PDCCH_SYMBOL_WITHIN_SLOT /* setting MSB to 128 i.e. 0x80 */;
3374    searchSpc->monitoringSymbolsWithinSlot->buf[byteIdx++] = 0;
3375    searchSpc->monitoringSymbolsWithinSlot->bits_unused = bitsUnused;
3376
3377    searchSpc->nrofCandidates = NULLP;
3378    DU_ALLOC(searchSpc->nrofCandidates, sizeof(struct SearchSpace__nrofCandidates));
3379    if(!searchSpc->nrofCandidates)
3380    {
3381       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3382       return RFAILED;
3383    }
3384
3385    searchSpc->nrofCandidates->aggregationLevel1 = \
3386                                                   PDCCH_SRCH_SPC_TWO_AGG_LVL1_CANDIDATE;
3387    searchSpc->nrofCandidates->aggregationLevel2 = \
3388                                                   PDCCH_SRCH_SPC_TWO_AGG_LVL2_CANDIDATE;
3389    searchSpc->nrofCandidates->aggregationLevel4 = \
3390                                                   PDCCH_SRCH_SPC_TWO_AGG_LVL4_CANDIDATE;
3391    searchSpc->nrofCandidates->aggregationLevel8 = \
3392                                                   PDCCH_SRCH_SPC_TWO_AGG_LVL8_CANDIDATE;
3393    searchSpc->nrofCandidates->aggregationLevel16 = \
3394                                                    PDCCH_SRCH_SPC_TWO_AGG_LVL16_CANDIDATE;
3395
3396    searchSpc->searchSpaceType = NULLP;
3397    DU_ALLOC(searchSpc->searchSpaceType, sizeof(struct SearchSpace__searchSpaceType));
3398    if(!searchSpc->searchSpaceType)
3399    {
3400       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3401       return RFAILED;
3402    }
3403
3404    searchSpc->searchSpaceType->present = SearchSpace__searchSpaceType_PR_ue_Specific;
3405
3406    searchSpc->searchSpaceType->choice.ue_Specific = NULLP;
3407    DU_ALLOC(searchSpc->searchSpaceType->choice.ue_Specific, \
3408          sizeof(struct SearchSpace__searchSpaceType__ue_Specific));
3409    if(!searchSpc->searchSpaceType->choice.ue_Specific)
3410    {
3411       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3412       return RFAILED;
3413    }
3414    searchSpc->searchSpaceType->choice.ue_Specific->dci_Formats = \
3415                                                                  PDCCH_SRCH_SPC_TWO_UE_SPEC_DCI_FORMAT;
3416
3417    return ROK;
3418 }/* End BuildSearchSpcToAddModList */
3419
3420 /*******************************************************************
3421  *
3422  * @brief Builds BWP DL dedicated PDCCH config
3423  *
3424  * @details
3425  *
3426  *    Function : BuildBWPDlDedPdcchCfg
3427  *
3428  *    Functionality: Builds BWP DL dedicated PDCCH config
3429  *
3430  * @params[in] struct PDCCH_Config *pdcchCfg
3431  *
3432  * @return ROK     - success
3433  *         RFAILED - failure
3434  *
3435  * ****************************************************************/
3436 uint8_t BuildBWPDlDedPdcchCfg(struct PDCCH_Config *pdcchCfg)
3437 {
3438    pdcchCfg->controlResourceSetToAddModList = NULLP;
3439    DU_ALLOC(pdcchCfg->controlResourceSetToAddModList, \
3440          sizeof(struct PDCCH_Config__controlResourceSetToAddModList));
3441    if(!pdcchCfg->controlResourceSetToAddModList)
3442    {
3443       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdcchCfg");
3444       return RFAILED;
3445    }
3446
3447    if(BuildControlRSetToAddModList(pdcchCfg->controlResourceSetToAddModList) != ROK)
3448    {
3449       return RFAILED;
3450    }
3451
3452    pdcchCfg->controlResourceSetToReleaseList = NULLP;
3453
3454    pdcchCfg->searchSpacesToAddModList = NULLP;
3455    DU_ALLOC(pdcchCfg->searchSpacesToAddModList, \
3456          sizeof(struct PDCCH_Config__searchSpacesToAddModList));
3457    if(!pdcchCfg->searchSpacesToAddModList)
3458    {
3459       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdcchCfg");
3460       return RFAILED;
3461    }
3462
3463    if(BuildSearchSpcToAddModList(pdcchCfg->searchSpacesToAddModList) != ROK)
3464    {
3465       return RFAILED;
3466    }
3467
3468    pdcchCfg->searchSpacesToReleaseList = NULLP;
3469    pdcchCfg->downlinkPreemption = NULLP;
3470    pdcchCfg->tpc_PUSCH = NULLP;
3471    pdcchCfg->tpc_PUCCH = NULLP;
3472    pdcchCfg->tpc_SRS = NULLP;
3473
3474    return ROK;
3475 }
3476
3477 /*******************************************************************
3478  *
3479  * @brief Builds DMRS DL PDSCH Mapping type A
3480  *
3481  * @details
3482  *
3483  *    Function : BuildDMRSDLPdschMapTypeA
3484  *
3485  *    Functionality: Builds DMRS DL PDSCH Mapping type A
3486  *
3487  * @params[in]
3488  * struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA *dmrsDlCfg
3489  * @return ROK     - success
3490  *         RFAILED - failure
3491  *
3492  * ****************************************************************/
3493    uint8_t BuildDMRSDLPdschMapTypeA
3494 (
3495  struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA *dmrsDlCfg
3496  )
3497 {
3498    dmrsDlCfg->present = PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA_PR_setup;
3499    dmrsDlCfg->choice.setup = NULLP;
3500    DU_ALLOC(dmrsDlCfg->choice.setup, sizeof(struct DMRS_DownlinkConfig));
3501    if(!dmrsDlCfg->choice.setup)
3502    {
3503       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
3504       return RFAILED;
3505    }
3506
3507    dmrsDlCfg->choice.setup->dmrs_Type = NULLP;
3508    dmrsDlCfg->choice.setup->dmrs_AdditionalPosition = NULLP;
3509    DU_ALLOC(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition, sizeof(long));
3510    if(!dmrsDlCfg->choice.setup->dmrs_AdditionalPosition)
3511    {
3512       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSDLPdschMapTypeA");
3513       return RFAILED;
3514    }
3515    *(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition) = DMRS_ADDITIONAL_POS;
3516
3517    dmrsDlCfg->choice.setup->maxLength = NULLP;
3518    dmrsDlCfg->choice.setup->scramblingID0 = NULLP;
3519    dmrsDlCfg->choice.setup->scramblingID1 = NULLP;
3520    dmrsDlCfg->choice.setup->phaseTrackingRS = NULLP;
3521
3522    return ROK;
3523 }
3524
3525 /*******************************************************************
3526  *
3527  * @brief Builds TCI states to add/modify list
3528  *
3529  * @details
3530  *
3531  *    Function : BuildTCIStatesToAddModList
3532  *
3533  *    Functionality:Builds TCI states to add/modify list
3534  *
3535  * @params[in]
3536  * struct PDSCH_Config__tci_StatesToAddModList *tciStatesList
3537  *
3538  * @return ROK     - success
3539  *         RFAILED - failure
3540  *
3541  * ****************************************************************/
3542 uint8_t BuildTCIStatesToAddModList(struct PDSCH_Config__tci_StatesToAddModList *tciStatesList)
3543 {
3544    return ROK;
3545 }
3546
3547 /*******************************************************************
3548  *
3549  * @brief Builds PDSCH time domain allocation list
3550  *
3551  * @details
3552  *
3553  *    Function : BuildPdschTimeDomAllocList
3554  *
3555  *    Functionality: Builds PDSCH time domain allocation list
3556  *
3557  * @params[in]
3558  * struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList
3559  *
3560  * @return ROK     - success
3561  *         RFAILED - failure
3562  *
3563  * ****************************************************************/
3564    uint8_t BuildPdschTimeDomAllocList
3565 (
3566  struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList
3567  )
3568 {
3569    uint8_t idx;
3570    uint8_t elementCnt;
3571    struct PDSCH_TimeDomainResourceAllocation *timeDomAlloc;
3572
3573    timeDomAllocList->present = \
3574                                PDSCH_Config__pdsch_TimeDomainAllocationList_PR_setup;
3575
3576    timeDomAllocList->choice.setup = NULLP;
3577    DU_ALLOC(timeDomAllocList->choice.setup, \
3578          sizeof(struct PDSCH_TimeDomainResourceAllocationList));
3579    if(!timeDomAllocList->choice.setup)
3580    {
3581       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
3582       return RFAILED;
3583    }
3584
3585    elementCnt = 1;
3586    timeDomAllocList->choice.setup->list.count = elementCnt;
3587    timeDomAllocList->choice.setup->list.size = \
3588                                                elementCnt * sizeof(struct PDSCH_TimeDomainResourceAllocation *);
3589
3590    timeDomAllocList->choice.setup->list.array = NULLP;
3591    DU_ALLOC(timeDomAllocList->choice.setup->list.array, \
3592          timeDomAllocList->choice.setup->list.size);
3593    if(!timeDomAllocList->choice.setup->list.array)
3594    {
3595       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
3596       return RFAILED;
3597    }
3598
3599    for(idx = 0; idx < elementCnt; idx++)
3600    {
3601       timeDomAllocList->choice.setup->list.array[idx] = NULLP;
3602       DU_ALLOC(timeDomAllocList->choice.setup->list.array[idx], \
3603             sizeof(struct PDSCH_TimeDomainResourceAllocation));
3604       if(!timeDomAllocList->choice.setup->list.array[idx])
3605       {
3606          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
3607          return RFAILED;
3608       }
3609    }
3610
3611    idx = 0;
3612    timeDomAlloc = timeDomAllocList->choice.setup->list.array[idx];
3613
3614    timeDomAlloc->k0 = NULLP;
3615    timeDomAlloc->mappingType = PDSCH_MAPPING_TYPE_A;
3616    timeDomAlloc->startSymbolAndLength = \
3617                                         calcSliv(PDSCH_START_SYMBOL, PDSCH_LENGTH_SYMBOL);
3618
3619    return ROK;
3620 }
3621
3622 /*******************************************************************
3623  *
3624  * @brief Builds PDSCH PRB Bundling type
3625  *
3626  * @details
3627  *
3628  *    Function : BuildPdschPrbBundlingType
3629  *
3630  *    Functionality: Builds PDSCH PRB Bundling type
3631  *
3632  * @params[in]
3633  * struct PDSCH_Config__prb_BundlingType *prbBndlType
3634  *
3635  * @return ROK     - success
3636  *         RFAILED - failure
3637  *
3638  * ****************************************************************/
3639    uint8_t BuildPdschPrbBundlingType
3640 (
3641  struct PDSCH_Config__prb_BundlingType *prbBndlType
3642  )
3643 {
3644    prbBndlType->present = PDSCH_Config__prb_BundlingType_PR_staticBundling;
3645
3646    prbBndlType->choice.staticBundling = NULLP;
3647    DU_ALLOC(prbBndlType->choice.staticBundling, \
3648          sizeof(struct PDSCH_Config__prb_BundlingType__staticBundling));
3649    if(!prbBndlType->choice.staticBundling)
3650    {
3651       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschPrbBundlingType");
3652       return RFAILED;
3653    }
3654    prbBndlType->choice.staticBundling->bundleSize = NULLP;
3655
3656    return ROK;
3657 }
3658
3659 /*******************************************************************
3660  *
3661  * @brief Builds BWP DL dedicated PDSCH config
3662  *
3663  * @details
3664  *
3665  *    Function : BuildBWPDlDedPdschCfg
3666  *
3667  *    Functionality: Builds BWP DL dedicated PDSCH config
3668  *
3669  * @params[in] struct PDSCH_Config *pdschCfg
3670  *
3671  * @return ROK     - success
3672  *         RFAILED - failure
3673  *
3674  * ****************************************************************/
3675 uint8_t BuildBWPDlDedPdschCfg(struct PDSCH_Config *pdschCfg)
3676 {
3677    pdschCfg->dataScramblingIdentityPDSCH = NULLP;
3678
3679    pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA = NULLP;
3680    DU_ALLOC(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA, \
3681          sizeof(struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA));
3682    if(!pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA)
3683    {
3684       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
3685       return RFAILED;
3686    }
3687
3688    if(BuildDMRSDLPdschMapTypeA(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA) != ROK)
3689    {
3690       return RFAILED;
3691    }
3692
3693    pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeB = NULLP;
3694    pdschCfg->tci_StatesToAddModList = NULLP;
3695    pdschCfg->tci_StatesToReleaseList = NULLP;
3696    pdschCfg->vrb_ToPRB_Interleaver = NULLP;
3697 #if 0
3698    DU_ALLOC(pdschCfg->tci_StatesToAddModList, sizeof(struct PDSCH_Config__tci_StatesToAddModList));
3699    if(!pdschCfg->tci_StatesToAddModList)
3700    {
3701       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
3702       return RFAILED;
3703    }
3704    if(BuildTCIStatesToAddModList(pdschCfg->tci_StatesToAddModList) != ROK)
3705    {
3706       return RFAILED;
3707    }
3708 #endif
3709
3710    pdschCfg->resourceAllocation = RES_ALLOC_TYPE;
3711
3712    pdschCfg->pdsch_TimeDomainAllocationList = NULLP;
3713    DU_ALLOC(pdschCfg->pdsch_TimeDomainAllocationList, \
3714          sizeof(struct PDSCH_Config__pdsch_TimeDomainAllocationList));
3715    if(!pdschCfg->pdsch_TimeDomainAllocationList)
3716    {
3717       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
3718       return RFAILED;
3719    }
3720
3721    if(BuildPdschTimeDomAllocList(pdschCfg->pdsch_TimeDomainAllocationList) != ROK)
3722    {
3723       return RFAILED;
3724    }
3725
3726    pdschCfg->pdsch_AggregationFactor = NULLP;
3727    pdschCfg->rateMatchPatternToAddModList = NULLP;
3728    pdschCfg->rateMatchPatternToReleaseList = NULLP;
3729    pdschCfg->rateMatchPatternGroup1 = NULLP;
3730    pdschCfg->rateMatchPatternGroup2 = NULLP;
3731    pdschCfg->rbg_Size = PDSCH_RBG_SIZE;
3732    pdschCfg->mcs_Table = NULLP;
3733
3734    pdschCfg->maxNrofCodeWordsScheduledByDCI = NULLP;
3735    DU_ALLOC(pdschCfg->maxNrofCodeWordsScheduledByDCI, sizeof(long));
3736    if(!pdschCfg->maxNrofCodeWordsScheduledByDCI)
3737    {
3738       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
3739       return RFAILED;
3740    }
3741    *(pdschCfg->maxNrofCodeWordsScheduledByDCI) = PDSCH_MAX_CODEWORD_SCH_BY_DCI;
3742
3743    if(BuildPdschPrbBundlingType(&pdschCfg->prb_BundlingType) != ROK)
3744    {
3745       return RFAILED;
3746    }
3747
3748    pdschCfg->zp_CSI_RS_ResourceToAddModList = NULLP;
3749    pdschCfg->zp_CSI_RS_ResourceToReleaseList = NULLP;
3750    pdschCfg->aperiodic_ZP_CSI_RS_ResourceSetsToAddModList = NULLP;
3751    pdschCfg->aperiodic_ZP_CSI_RS_ResourceSetsToReleaseList = NULLP;
3752    pdschCfg->sp_ZP_CSI_RS_ResourceSetsToAddModList = NULLP;
3753    pdschCfg->sp_ZP_CSI_RS_ResourceSetsToReleaseList = NULLP;
3754    pdschCfg->p_ZP_CSI_RS_ResourceSet = NULLP;
3755
3756    return ROK;
3757 }
3758
3759 /*******************************************************************
3760  *
3761  * @brief Builds intitial DL BWP
3762  * @details
3763  *
3764  *    Function : BuildInitialDlBWP
3765  *
3766  *    Functionality: Builds intitial DL BWP in spCellCfgDed
3767  *
3768  * @params[in] BWP_DownlinkDedicated_t *dlBwp
3769  *
3770  * @return ROK     - success
3771  *         RFAILED - failure
3772  *
3773  * ****************************************************************/
3774 uint8_t BuildInitialDlBWP(BWP_DownlinkDedicated_t *dlBwp)
3775 {
3776    dlBwp->pdcch_Config = NULLP;
3777    DU_ALLOC(dlBwp->pdcch_Config, sizeof(struct BWP_DownlinkDedicated__pdcch_Config));
3778    if(!dlBwp->pdcch_Config)
3779    {
3780       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failure in BuildInitialDlBWP");
3781       return RFAILED;
3782    }
3783    dlBwp->pdcch_Config->present = BWP_DownlinkDedicated__pdcch_Config_PR_setup;
3784
3785    dlBwp->pdcch_Config->choice.setup = NULLP;
3786    DU_ALLOC(dlBwp->pdcch_Config->choice.setup, sizeof(struct PDCCH_Config));
3787    if(!dlBwp->pdcch_Config->choice.setup)
3788    {
3789       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failure in BuildInitialDlBWP");
3790       return RFAILED;
3791    }
3792    if(BuildBWPDlDedPdcchCfg(dlBwp->pdcch_Config->choice.setup) != ROK)
3793    {
3794       return RFAILED;
3795    }
3796
3797    dlBwp->pdsch_Config = NULLP;
3798    DU_ALLOC(dlBwp->pdsch_Config, sizeof(struct BWP_DownlinkDedicated__pdsch_Config));
3799    if(!dlBwp->pdsch_Config)
3800    {
3801       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failure in BuildInitialDlBWP");
3802       return RFAILED;
3803    }
3804    dlBwp->pdsch_Config->present = BWP_DownlinkDedicated__pdsch_Config_PR_setup;
3805
3806    dlBwp->pdsch_Config->choice.setup = NULLP;
3807    DU_ALLOC(dlBwp->pdsch_Config->choice.setup, sizeof(struct PDSCH_Config));
3808    if(!dlBwp->pdsch_Config->choice.setup)
3809    {
3810       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failure in BuildInitialDlBWP");
3811       return RFAILED;
3812    }
3813
3814    if(BuildBWPDlDedPdschCfg(dlBwp->pdsch_Config->choice.setup) != ROK)
3815    {
3816       return RFAILED;
3817    }
3818
3819    dlBwp->sps_Config = NULLP;
3820    dlBwp->radioLinkMonitoringConfig = NULLP;
3821    return ROK;
3822 }
3823
3824 /*******************************************************************
3825  *
3826  * @brief Builds DMRS UL Pusch Mapping type A
3827  *
3828  * @details
3829  *
3830  *    Function : BuildDMRSULPuschMapTypeA
3831  *
3832  *    Functionality: Builds DMRS UL Pusch Mapping type A
3833  *
3834  * @params[in]
3835  *    struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA *dmrsUlCfg
3836  * @return ROK     - success
3837  *         RFAILED - failure
3838  *
3839  * ****************************************************************/
3840    uint8_t BuildDMRSULPuschMapTypeA
3841 (
3842  struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA *dmrsUlCfg
3843  )
3844 {
3845    dmrsUlCfg->present = PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA_PR_setup;
3846    dmrsUlCfg->choice.setup= NULLP;
3847    DU_ALLOC(dmrsUlCfg->choice.setup, sizeof(DMRS_UplinkConfig_t));
3848    if(!dmrsUlCfg->choice.setup)
3849    {
3850       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
3851       return RFAILED;
3852    }
3853
3854    dmrsUlCfg->choice.setup->dmrs_Type = NULLP;
3855    dmrsUlCfg->choice.setup->dmrs_AdditionalPosition = NULLP;
3856    DU_ALLOC(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition, sizeof(long));
3857    if(!dmrsUlCfg->choice.setup->dmrs_AdditionalPosition)
3858    {
3859       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
3860       return RFAILED;
3861    }
3862    *(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition) = DMRS_ADDITIONAL_POS;
3863
3864    dmrsUlCfg->choice.setup->phaseTrackingRS = NULLP;
3865    dmrsUlCfg->choice.setup->maxLength = NULLP;
3866    dmrsUlCfg->choice.setup->transformPrecodingDisabled = NULLP;
3867    DU_ALLOC(dmrsUlCfg->choice.setup->transformPrecodingDisabled, \
3868          sizeof(struct DMRS_UplinkConfig__transformPrecodingDisabled));
3869    if(!dmrsUlCfg->choice.setup->transformPrecodingDisabled)
3870    {
3871       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
3872       return RFAILED;
3873    }
3874
3875    dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0 = NULLP;
3876    DU_ALLOC(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0,\
3877          sizeof(long));
3878    if(!dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0)
3879    {
3880       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
3881       return RFAILED;
3882    }
3883    *(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0) = SCRAMBLING_ID;
3884
3885    dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID1 = NULLP;
3886    dmrsUlCfg->choice.setup->transformPrecodingEnabled = NULLP;
3887    return ROK;
3888 }
3889
3890 /*******************************************************************
3891  *
3892  * @brief Build PUSCH time domain allocation list
3893  *
3894  * @details
3895  *
3896  *    Function : BuildPuschTimeDomAllocList
3897  *
3898  *    Functionality: Build PUSCH time domain allocation list
3899  *
3900  * @params[in]
3901  * struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList
3902  *
3903  * @return ROK     - success
3904  *         RFAILED - failure
3905  *
3906  * ****************************************************************/
3907    uint8_t BuildPuschTimeDomAllocList
3908 (
3909  struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList
3910  )
3911 {
3912    uint8_t idx;
3913    uint8_t elementCnt;
3914    PUSCH_TimeDomainResourceAllocation_t  *timeDomAlloc;
3915
3916    timeDomAllocList->present = PUSCH_Config__pusch_TimeDomainAllocationList_PR_setup;
3917    timeDomAllocList->choice.setup = NULLP;
3918    DU_ALLOC(timeDomAllocList->choice.setup, \
3919          sizeof(struct PUSCH_TimeDomainResourceAllocationList));
3920    if(!timeDomAllocList->choice.setup)
3921    {
3922       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
3923       return RFAILED;
3924    }
3925
3926    elementCnt = 1;
3927    timeDomAllocList->choice.setup->list.count = elementCnt;
3928    timeDomAllocList->choice.setup->list.size = \
3929                                                elementCnt * sizeof(PUSCH_TimeDomainResourceAllocation_t *);
3930    timeDomAllocList->choice.setup->list.array = NULLP;
3931    DU_ALLOC(timeDomAllocList->choice.setup->list.array, \
3932          timeDomAllocList->choice.setup->list.size);
3933    if(!timeDomAllocList->choice.setup->list.array)
3934    {
3935       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
3936       return RFAILED;
3937    }
3938
3939    for(idx = 0; idx < elementCnt; idx++)
3940    {
3941       timeDomAllocList->choice.setup->list.array[idx] = NULLP;
3942       DU_ALLOC(timeDomAllocList->choice.setup->list.array[idx],\
3943             sizeof(PUSCH_TimeDomainResourceAllocation_t));
3944       if(!timeDomAllocList->choice.setup->list.array[idx])
3945       {
3946          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
3947          return RFAILED;
3948       }
3949    }
3950
3951    idx = 0;
3952    timeDomAlloc = timeDomAllocList->choice.setup->list.array[idx];
3953    DU_ALLOC(timeDomAlloc->k2, sizeof(long));
3954    if(!timeDomAlloc->k2)
3955    {
3956       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
3957       return RFAILED;
3958    }
3959    *(timeDomAlloc->k2) = PUSCH_K2;
3960    timeDomAlloc->mappingType = PUSCH_MAPPING_TYPE_A;
3961    timeDomAlloc->startSymbolAndLength = calcSliv(PUSCH_START_SYMBOL, PUSCH_LENGTH_SYMBOL);
3962    return ROK;
3963 }
3964
3965 /*******************************************************************
3966  *
3967  * @brief Builds BWP UL dedicated PUSCH Config
3968  *
3969  * @details
3970  *
3971  *    Function : BuildBWPUlDedPuschCfg
3972  *
3973  *    Functionality:
3974  *      Builds BWP UL dedicated PUSCH Config
3975  *
3976  * @params[in] : PUSCH_Config_t *puschCfg
3977  *
3978  * @return ROK     - success
3979  *         RFAILED - failure
3980  *
3981  * ****************************************************************/
3982 uint8_t BuildBWPUlDedPuschCfg(PUSCH_Config_t *puschCfg)
3983 {
3984    puschCfg->dataScramblingIdentityPUSCH = NULLP;
3985    DU_ALLOC(puschCfg->dataScramblingIdentityPUSCH, sizeof(long));
3986    if(!puschCfg->dataScramblingIdentityPUSCH)
3987    {
3988       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
3989       return RFAILED;
3990    }
3991    *(puschCfg->dataScramblingIdentityPUSCH) = SCRAMBLING_ID;
3992
3993    puschCfg->txConfig = NULLP;
3994    puschCfg->dmrs_UplinkForPUSCH_MappingTypeA = NULLP;
3995    DU_ALLOC(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA, \
3996          sizeof(struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA));
3997    if(!puschCfg->dmrs_UplinkForPUSCH_MappingTypeA)
3998    {
3999       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
4000       return RFAILED;
4001    }
4002
4003    if(BuildDMRSULPuschMapTypeA(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA) != ROK)
4004    {
4005       return RFAILED;
4006    }
4007
4008    puschCfg->dmrs_UplinkForPUSCH_MappingTypeB = NULLP;
4009    puschCfg->pusch_PowerControl = NULLP;
4010    puschCfg->frequencyHopping = NULLP;
4011    puschCfg->frequencyHoppingOffsetLists = NULLP;
4012    puschCfg->resourceAllocation = RES_ALLOC_TYPE;
4013
4014    puschCfg->pusch_TimeDomainAllocationList = NULLP;
4015    DU_ALLOC(puschCfg->pusch_TimeDomainAllocationList, \
4016          sizeof(struct PUSCH_Config__pusch_TimeDomainAllocationList));
4017    if(!puschCfg->pusch_TimeDomainAllocationList)
4018    {
4019       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
4020       return RFAILED;
4021    }
4022
4023    if(BuildPuschTimeDomAllocList(puschCfg->pusch_TimeDomainAllocationList) != ROK)
4024    {
4025       return RFAILED;
4026    }
4027
4028    puschCfg->pusch_AggregationFactor = NULLP;
4029    puschCfg->mcs_Table = NULLP;
4030    puschCfg->mcs_TableTransformPrecoder = NULLP;
4031    puschCfg->transformPrecoder = NULLP;
4032    DU_ALLOC(puschCfg->transformPrecoder, sizeof(long));
4033    if(!puschCfg->transformPrecoder)
4034    {
4035       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
4036       return RFAILED;
4037    }
4038    *(puschCfg->transformPrecoder) = PUSCH_TRANSFORM_PRECODER;
4039
4040    puschCfg->codebookSubset = NULLP;
4041    puschCfg->maxRank = NULLP;
4042    puschCfg->rbg_Size = NULLP;
4043    puschCfg->uci_OnPUSCH = NULLP;
4044    puschCfg->tp_pi2BPSK = NULLP;
4045
4046    return ROK;
4047 }
4048
4049 /*******************************************************************
4050  *
4051  * @brief Fills SRS resource to add/modify list
4052  *
4053  * @details
4054  *
4055  *    Function : BuildSrsRsrcAddModList
4056  *
4057  *    Functionality: Fills SRS resource to add/modify list
4058  *
4059  * @params[in]
4060  * @return ROK     - success
4061  *         RFAILED - failure
4062  *
4063  * ****************************************************************/
4064 uint8_t BuildSrsRsrcAddModList(struct SRS_Config__srs_ResourceToAddModList *resourceList)
4065 {
4066    uint8_t   elementCnt;
4067    uint8_t   rsrcIdx;
4068
4069    elementCnt = 1;
4070    resourceList->list.count = elementCnt;
4071    resourceList->list.size = elementCnt * sizeof(SRS_Resource_t *);
4072    resourceList->list.array = NULLP;
4073    DU_ALLOC(resourceList->list.array, resourceList->list.size);
4074    if(!resourceList->list.array)
4075    {
4076       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcAddModList");
4077       return RFAILED;
4078    }
4079
4080    for(rsrcIdx = 0; rsrcIdx < resourceList->list.count; rsrcIdx++)
4081    {
4082       DU_ALLOC(resourceList->list.array[rsrcIdx], sizeof(SRS_Resource_t));
4083       if(!resourceList->list.array[rsrcIdx])
4084       {
4085          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcAddModList");
4086          return RFAILED;
4087       }
4088    }
4089
4090    rsrcIdx = 0;
4091    resourceList->list.array[rsrcIdx]->srs_ResourceId = SRS_RSRC_ID;
4092    resourceList->list.array[rsrcIdx]->nrofSRS_Ports = SRS_Resource__nrofSRS_Ports_port1;
4093    resourceList->list.array[rsrcIdx]->transmissionComb.present = SRS_Resource__transmissionComb_PR_n2;
4094
4095    resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2 = NULLP;
4096    DU_ALLOC(resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2, \
4097          sizeof(struct SRS_Resource__transmissionComb__n2));
4098    if(!resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2)
4099    {
4100       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcAddModList");
4101       return RFAILED;
4102    }
4103    resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2->combOffset_n2\
4104       = SRS_COMB_OFFSET_N2;
4105    resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2->cyclicShift_n2\
4106       = SRS_CYCLIC_SHIFT_N2;
4107
4108    resourceList->list.array[rsrcIdx]->resourceMapping.startPosition = \
4109                                                                       PUSCH_START_SYMBOL;
4110    resourceList->list.array[rsrcIdx]->resourceMapping.nrofSymbols =  \
4111                                                                      SRS_Resource__resourceMapping__nrofSymbols_n1;
4112    resourceList->list.array[rsrcIdx]->resourceMapping.repetitionFactor = \
4113                                                                          SRS_Resource__resourceMapping__repetitionFactor_n1;
4114
4115    resourceList->list.array[rsrcIdx]->freqDomainPosition = SRS_FREQ_DOM_POS;
4116    resourceList->list.array[rsrcIdx]->freqDomainShift = SRS_FREQ_DOM_SHIFT;
4117    resourceList->list.array[rsrcIdx]->freqHopping.c_SRS = C_SRS;
4118    resourceList->list.array[rsrcIdx]->freqHopping.b_SRS = B_SRS;
4119    resourceList->list.array[rsrcIdx]->freqHopping.b_hop = B_HOP;
4120    resourceList->list.array[rsrcIdx]->groupOrSequenceHopping = \
4121                                                                SRS_Resource__groupOrSequenceHopping_neither;
4122
4123    /* Setting resource type to aperiodic for intergration purposes */
4124    resourceList->list.array[rsrcIdx]->resourceType.present = \
4125                                                              SRS_Resource__resourceType_PR_aperiodic;
4126    resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic = NULLP;
4127    DU_ALLOC(resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic,
4128          sizeof(struct SRS_Resource__resourceType__aperiodic));
4129    if(!resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic)
4130    {
4131       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcAddModList");
4132       return RFAILED;
4133    }
4134    resourceList->list.array[rsrcIdx]->sequenceId = SRS_SEQ_ID;
4135
4136    return ROK;
4137 }
4138
4139 /*******************************************************************
4140  *
4141  * @brief Build SRS resource set Add/mod list
4142  *
4143  * @details
4144  *
4145  *    Function : BuildSrsRsrcSetAddModList
4146  *
4147  *    Functionality: Build SRS resource set Add/mod list
4148  *
4149  * @params[in]
4150  * @return ROK     - success
4151  *         RFAILED - failure
4152  *
4153  * ****************************************************************/
4154    uint8_t BuildSrsRsrcSetAddModList
4155 (
4156  struct SRS_Config__srs_ResourceSetToAddModList *rsrcSetList
4157  )
4158 {
4159    uint8_t  elementCnt;
4160    uint8_t  rSetIdx;
4161    uint8_t  rsrcIdx;
4162    struct SRS_ResourceSet__srs_ResourceIdList *rsrcIdList;
4163
4164    elementCnt = 1;
4165    rsrcSetList->list.count = elementCnt;
4166    rsrcSetList->list.size = elementCnt * sizeof(SRS_ResourceSet_t *);
4167    rsrcSetList->list.array = NULLP;
4168    DU_ALLOC(rsrcSetList->list.array, rsrcSetList->list.size);
4169    if(!rsrcSetList->list.array)
4170    {
4171       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
4172       return RFAILED;
4173    }
4174
4175    for(rSetIdx = 0; rSetIdx < rsrcSetList->list.count; rSetIdx++)
4176    {
4177       DU_ALLOC(rsrcSetList->list.array[rSetIdx], sizeof(SRS_ResourceSet_t));
4178       if(!rsrcSetList->list.array[rSetIdx])
4179       {
4180          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
4181          return RFAILED;
4182       }
4183    }
4184
4185    rSetIdx = 0;
4186    rsrcSetList->list.array[rSetIdx]->srs_ResourceSetId = SRS_RSET_ID;
4187
4188    /* Fill Resource Id list in resource set */
4189    rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList = NULLP;
4190    DU_ALLOC(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList,\
4191          sizeof(struct SRS_ResourceSet__srs_ResourceIdList));
4192    if(!rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList)
4193    {
4194       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
4195       return RFAILED;
4196    }
4197
4198    elementCnt = 1;
4199    rsrcIdList = rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList;
4200    rsrcIdList->list.count = elementCnt;
4201    rsrcIdList->list.size = elementCnt * sizeof(SRS_ResourceId_t *);
4202    rsrcIdList->list.array = NULLP;
4203    DU_ALLOC(rsrcIdList->list.array, rsrcIdList->list.size);
4204    if(!rsrcIdList->list.array)
4205    {
4206       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
4207       return RFAILED;
4208    }
4209
4210    for(rsrcIdx = 0; rsrcIdx < rsrcIdList->list.count; rsrcIdx++)
4211    {
4212       DU_ALLOC(rsrcIdList->list.array[rsrcIdx], sizeof(SRS_ResourceId_t));
4213       if(!rsrcIdList->list.array[rsrcIdx])
4214       {
4215          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
4216          return RFAILED;
4217       }
4218    }
4219
4220    rsrcIdx = 0;
4221    *rsrcIdList->list.array[rsrcIdx] = SRS_RSRC_ID;
4222
4223    /* Fill resource type */
4224    rsrcSetList->list.array[rSetIdx]->resourceType.present = \
4225                                                             SRS_ResourceSet__resourceType_PR_aperiodic;
4226
4227    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic = NULLP;
4228    DU_ALLOC(rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic, \
4229          sizeof(struct SRS_ResourceSet__resourceType__aperiodic));
4230    if(!rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic)
4231    {
4232       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
4233       return RFAILED;
4234    }
4235    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic->aperiodicSRS_ResourceTrigger \
4236       = APERIODIC_SRS_RESRC_TRIGGER;
4237
4238    /* TODO : Fill values for below IEs as expected by Viavi */
4239    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic->csi_RS = NULLP;
4240    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic->slotOffset = NULLP;
4241
4242
4243    rsrcSetList->list.array[rSetIdx]->usage = SRS_ResourceSet__usage_codebook;
4244    rsrcSetList->list.array[rSetIdx]->alpha = NULLP;
4245    rsrcSetList->list.array[rSetIdx]->p0 = NULLP;
4246    rsrcSetList->list.array[rSetIdx]->pathlossReferenceRS = NULLP;
4247    rsrcSetList->list.array[rSetIdx]->srs_PowerControlAdjustmentStates = NULLP;
4248
4249    return ROK;
4250 }
4251
4252 /*******************************************************************
4253  *
4254  * @brief Builds BWP UL dedicated SRS Config
4255  *
4256  * @details
4257  *
4258  *    Function : BuildBWPUlDedSrsCfg
4259  *
4260  *    Functionality: Builds BWP UL dedicated SRS Config
4261  *
4262  * @params[in] SRS Config
4263  * @return ROK     - success
4264  *         RFAILED - failure
4265  *
4266  * ****************************************************************/
4267 uint8_t BuildBWPUlDedSrsCfg(SRS_Config_t *srsCfg)
4268 {
4269    srsCfg->srs_ResourceSetToReleaseList = NULLP;
4270    srsCfg->srs_ResourceSetToAddModList = NULLP;
4271    DU_ALLOC(srsCfg->srs_ResourceSetToAddModList, \
4272          sizeof(struct SRS_Config__srs_ResourceSetToAddModList));
4273    if(!srsCfg->srs_ResourceSetToAddModList)
4274    {
4275       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedSrsCfg");
4276       return RFAILED;
4277    }
4278    if(BuildSrsRsrcSetAddModList(srsCfg->srs_ResourceSetToAddModList) != ROK)
4279    {
4280       return RFAILED;
4281    }
4282
4283    srsCfg->srs_ResourceToReleaseList = NULLP;
4284
4285    /* Resource to Add/Modify list */
4286    srsCfg->srs_ResourceToAddModList = NULLP;
4287    DU_ALLOC(srsCfg->srs_ResourceToAddModList, \
4288          sizeof(struct SRS_Config__srs_ResourceToAddModList));
4289    if(!srsCfg->srs_ResourceToAddModList)
4290    {
4291       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedSrsCfg");
4292       return RFAILED;
4293    }
4294
4295    if(BuildSrsRsrcAddModList(srsCfg->srs_ResourceToAddModList) != ROK)
4296    {
4297       return RFAILED;
4298    }
4299
4300    srsCfg->tpc_Accumulation = NULLP;
4301
4302    return ROK;
4303 }
4304
4305
4306
4307 /*******************************************************************
4308  *
4309  * @brief Builds Pusch Serving cell Config
4310  *
4311  * @details
4312  *
4313  *    Function : BuildPuschSrvCellCfg
4314  *
4315  *    Functionality: Builds Pusch Serving cell Config
4316  *
4317  * @params[in] struct UplinkConfig__pusch_ServingCellConfig *puschCfg
4318  *
4319  * @return ROK     - success
4320  *         RFAILED - failure
4321  *
4322  * ****************************************************************/
4323 uint8_t BuildPuschSrvCellCfg(struct UplinkConfig__pusch_ServingCellConfig *puschCfg)
4324 {
4325    puschCfg->present = UplinkConfig__pusch_ServingCellConfig_PR_setup;
4326    puschCfg->choice.setup = NULLP;
4327    DU_ALLOC(puschCfg->choice.setup, sizeof(struct PUSCH_ServingCellConfig));
4328    if(!puschCfg->choice.setup)
4329    {
4330       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
4331       return RFAILED;
4332    }
4333
4334    puschCfg->choice.setup->codeBlockGroupTransmission = NULLP;
4335    puschCfg->choice.setup->rateMatching = NULLP;
4336    puschCfg->choice.setup->xOverhead = NULLP;
4337    puschCfg->choice.setup->ext1 = NULLP;
4338    DU_ALLOC(puschCfg->choice.setup->ext1, sizeof(struct PUSCH_ServingCellConfig__ext1));
4339    if(!puschCfg->choice.setup->ext1)
4340    {
4341       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
4342       return RFAILED;
4343    }
4344
4345    puschCfg->choice.setup->ext1->maxMIMO_Layers = NULLP;
4346    DU_ALLOC(puschCfg->choice.setup->ext1->maxMIMO_Layers, sizeof(long));
4347    if(!puschCfg->choice.setup->ext1->maxMIMO_Layers)
4348    {
4349       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
4350       return RFAILED;
4351    }
4352    *(puschCfg->choice.setup->ext1->maxMIMO_Layers) = PUSCH_MAX_MIMO_LAYERS;
4353
4354    puschCfg->choice.setup->ext1->processingType2Enabled= NULLP;
4355    DU_ALLOC(puschCfg->choice.setup->ext1->processingType2Enabled,sizeof(BOOLEAN_t));
4356    if(!puschCfg->choice.setup->ext1->processingType2Enabled)
4357    {
4358       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
4359       return RFAILED;
4360    }
4361    *(puschCfg->choice.setup->ext1->processingType2Enabled) = PUSCH_PROCESS_TYPE2_ENABLED;
4362    return ROK;
4363 }
4364
4365 /*******************************************************************
4366  *
4367  * @brief Builds inital UL BWP
4368  *
4369  * @details
4370  *
4371  *    Function : BuildInitialUlBWP
4372  *
4373  *    Functionality: Builds initial UL BWP
4374  *
4375  * @params[in] BWP_UplinkDedicated_t *ulBwp
4376  * @return ROK     - success
4377  *         RFAILED - failure
4378  *
4379  * ****************************************************************/
4380 uint8_t BuildInitialUlBWP(BWP_UplinkDedicated_t *ulBwp)
4381 {
4382    ulBwp->pucch_Config = NULLP;
4383
4384    /* Fill BWP UL dedicated PUSCH config */
4385    ulBwp->pusch_Config = NULLP;
4386    DU_ALLOC(ulBwp->pusch_Config, sizeof(struct BWP_UplinkDedicated__pusch_Config));
4387    if(!ulBwp->pusch_Config)
4388    {
4389       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
4390       return RFAILED;
4391    }
4392
4393    ulBwp->pusch_Config->present = BWP_UplinkDedicated__pusch_Config_PR_setup;
4394    ulBwp->pusch_Config->choice.setup = NULLP;
4395    DU_ALLOC(ulBwp->pusch_Config->choice.setup, sizeof(PUSCH_Config_t));
4396    if(!ulBwp->pusch_Config->choice.setup)
4397    {
4398       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
4399       return RFAILED;
4400    }
4401
4402    if(BuildBWPUlDedPuschCfg(ulBwp->pusch_Config->choice.setup) != ROK)
4403    {
4404       return RFAILED;
4405    }
4406
4407    ulBwp->configuredGrantConfig = NULLP;
4408
4409    /* Fill BPW UL dedicated SRS config */
4410    ulBwp->srs_Config = NULLP;
4411    DU_ALLOC(ulBwp->srs_Config, sizeof(struct BWP_UplinkDedicated__srs_Config));
4412    if(!ulBwp->srs_Config)
4413    {
4414       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
4415       return RFAILED;
4416    }
4417
4418    ulBwp->srs_Config->present = BWP_UplinkDedicated__srs_Config_PR_setup;
4419    ulBwp->srs_Config->choice.setup = NULLP;
4420    DU_ALLOC(ulBwp->srs_Config->choice.setup, sizeof(SRS_Config_t));
4421    if(!ulBwp->srs_Config->choice.setup)
4422    {
4423       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
4424       return RFAILED;
4425    }
4426
4427    if(BuildBWPUlDedSrsCfg(ulBwp->srs_Config->choice.setup) != ROK)
4428    {
4429       return RFAILED;
4430    }
4431
4432    ulBwp->beamFailureRecoveryConfig = NULLP;
4433
4434    return ROK;
4435 }
4436
4437 /*******************************************************************
4438  *
4439  * @brief Builds UL config
4440  * @details
4441  *
4442  *    Function : BuildUlCfg
4443  *
4444  *    Functionality: Builds UL config in spCellCfgDed
4445  *
4446  * @params[in] UplinkConfig_t *ulCfg
4447  *
4448  * @return ROK     - success
4449  *         RFAILED - failure
4450  *
4451  * ****************************************************************/
4452 uint8_t BuildUlCfg(UplinkConfig_t *ulCfg)
4453 {
4454    ulCfg->initialUplinkBWP = NULLP;
4455    DU_ALLOC(ulCfg->initialUplinkBWP, sizeof(BWP_UplinkDedicated_t));
4456    if(!ulCfg->initialUplinkBWP)
4457    {
4458       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failed in BuildUlCfg");
4459       return RFAILED;
4460    }
4461
4462    if(BuildInitialUlBWP(ulCfg->initialUplinkBWP) != ROK)
4463    {
4464       return RFAILED;
4465    }
4466
4467    ulCfg->uplinkBWP_ToReleaseList = NULLP;
4468    ulCfg->uplinkBWP_ToAddModList = NULLP;
4469    ulCfg->firstActiveUplinkBWP_Id = NULLP;
4470    DU_ALLOC(ulCfg->firstActiveUplinkBWP_Id, sizeof(BWP_Id_t));
4471    if(!ulCfg->firstActiveUplinkBWP_Id)
4472    {
4473       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failed in BuildUlCfg");
4474       return RFAILED;
4475    }
4476    *(ulCfg->firstActiveUplinkBWP_Id) = ACTIVE_UL_BWP_ID;
4477
4478    ulCfg->pusch_ServingCellConfig = NULLP;
4479    DU_ALLOC(ulCfg->pusch_ServingCellConfig, \
4480          sizeof(struct UplinkConfig__pusch_ServingCellConfig));
4481    if(!ulCfg->pusch_ServingCellConfig)
4482    {
4483       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failed in BuildUlCfg");
4484       return RFAILED;
4485    }
4486
4487    if(BuildPuschSrvCellCfg(ulCfg->pusch_ServingCellConfig) != ROK)
4488    {
4489       return RFAILED;
4490    }
4491
4492    ulCfg->carrierSwitching = NULLP;
4493    ulCfg->ext1 = NULLP;
4494    return ROK;
4495 }
4496
4497 /*******************************************************************
4498  *
4499  * @brief Builds PDSCH serving cell config
4500  * @details
4501  *
4502  *    Function : BuildPdschSrvCellCfg
4503  *
4504  *    Functionality: Builds PDSCH serving cell config in spCellCfgDed
4505  *
4506  * @params[in] struct ServingCellConfig__pdsch_ServingCellConfig *pdschCfg
4507  *
4508  * @return ROK     - success
4509  *         RFAILED - failure
4510  *
4511  * ****************************************************************/
4512 uint8_t BuildPdschSrvCellCfg(struct ServingCellConfig__pdsch_ServingCellConfig *pdschCfg)
4513 {
4514    pdschCfg->present =  ServingCellConfig__pdsch_ServingCellConfig_PR_setup;
4515    pdschCfg->choice.setup = NULLP;
4516    DU_ALLOC(pdschCfg->choice.setup, sizeof( struct PDSCH_ServingCellConfig));
4517    if(!pdschCfg->choice.setup)
4518    {
4519       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschSrvCellCfg");
4520       return RFAILED;
4521    }
4522
4523    pdschCfg->choice.setup->codeBlockGroupTransmission = NULLP;
4524    pdschCfg->choice.setup->xOverhead = NULLP;
4525    pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH = NULLP;
4526    DU_ALLOC(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH, sizeof(long));
4527    if(!pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH)
4528    {
4529       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschSrvCellCfg");
4530       return RFAILED;
4531    }
4532    *(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH)= PDSCH_NUM_HARQ_PROC;
4533    pdschCfg->choice.setup->pucch_Cell = NULLP;
4534    pdschCfg->choice.setup->ext1 = NULLP;
4535
4536    return ROK;
4537 }
4538
4539 /*******************************************************************
4540  *
4541  * @brief Builds CSI Meas config
4542  * @details
4543  *
4544  *    Function : BuildCsiMeasCfg
4545  *
4546  *    Functionality: Builds CSI Meas config in spCellCfgDed
4547  *
4548  * @params[in] struct ServingCellConfig__csi_MeasConfig *csiMeasCfg
4549  *
4550  * @return ROK     - success
4551  *         RFAILED - failure
4552  *
4553  * ****************************************************************/
4554 uint8_t BuildCsiMeasCfg(struct ServingCellConfig__csi_MeasConfig *csiMeasCfg)
4555 {
4556
4557    return ROK;
4558 }
4559
4560 /*******************************************************************
4561  *
4562  * @brief Builds Spcell config dedicated
4563  * @details
4564  *
4565  *    Function : BuildSpCellCfgDed
4566  *
4567  *    Functionality: Builds sp cell config dedicated in spCellCfg
4568  *
4569  * @params[in] ServingCellConfig_t srvCellCfg
4570  *
4571  * @return ROK     - success
4572  *         RFAILED - failure
4573  *
4574  * ****************************************************************/
4575 uint8_t BuildSpCellCfgDed(ServingCellConfig_t *srvCellCfg)
4576 {
4577    srvCellCfg->tdd_UL_DL_ConfigurationDedicated = NULLP;
4578    DU_ALLOC(srvCellCfg->tdd_UL_DL_ConfigurationDedicated, sizeof(TDD_UL_DL_ConfigDedicated_t));
4579    if(!srvCellCfg->tdd_UL_DL_ConfigurationDedicated)
4580    {
4581       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
4582       return RFAILED;
4583    }
4584
4585    srvCellCfg->initialDownlinkBWP = NULLP;
4586    DU_ALLOC(srvCellCfg->initialDownlinkBWP, sizeof(BWP_DownlinkDedicated_t));
4587    if(!srvCellCfg->initialDownlinkBWP)
4588    {
4589       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
4590       return RFAILED;
4591    }
4592
4593    if(BuildInitialDlBWP(srvCellCfg->initialDownlinkBWP) != ROK)
4594    {
4595       DU_LOG("\nERROR  -->  F1AP : BuildInitialDlBWP failed");
4596       return RFAILED;
4597    }
4598    srvCellCfg->downlinkBWP_ToReleaseList = NULLP;
4599    srvCellCfg->downlinkBWP_ToAddModList = NULLP;
4600
4601    srvCellCfg->firstActiveDownlinkBWP_Id = NULLP;
4602    DU_ALLOC(srvCellCfg->firstActiveDownlinkBWP_Id, sizeof(long));
4603    if(!srvCellCfg->firstActiveDownlinkBWP_Id)
4604    {
4605       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
4606       return RFAILED;
4607    }
4608    *(srvCellCfg->firstActiveDownlinkBWP_Id) = ACTIVE_DL_BWP_ID;
4609
4610    srvCellCfg->bwp_InactivityTimer = NULLP;
4611
4612    srvCellCfg->defaultDownlinkBWP_Id = NULLP;
4613    DU_ALLOC(srvCellCfg->defaultDownlinkBWP_Id, sizeof(long));
4614    if(!srvCellCfg->defaultDownlinkBWP_Id)
4615    {
4616       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
4617       return RFAILED;
4618    }
4619    *(srvCellCfg->defaultDownlinkBWP_Id) = ACTIVE_DL_BWP_ID;
4620
4621    srvCellCfg->uplinkConfig = NULLP;
4622    DU_ALLOC(srvCellCfg->uplinkConfig, sizeof(UplinkConfig_t));
4623    if(!srvCellCfg->uplinkConfig)
4624    {
4625       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
4626       return RFAILED;
4627    }
4628
4629    if(BuildUlCfg(srvCellCfg->uplinkConfig) != ROK)
4630    {
4631       DU_LOG("\nERROR  -->  F1AP : BuildUlCfg failed");
4632       return RFAILED;
4633    }
4634    srvCellCfg->supplementaryUplink = NULLP;
4635    srvCellCfg->pdcch_ServingCellConfig = NULLP;
4636
4637    srvCellCfg->pdsch_ServingCellConfig = NULLP;
4638    DU_ALLOC(srvCellCfg->pdsch_ServingCellConfig, sizeof(struct  ServingCellConfig__pdsch_ServingCellConfig));
4639    if(!srvCellCfg->pdsch_ServingCellConfig)
4640    {
4641       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
4642       return RFAILED;
4643    }
4644
4645    if(BuildPdschSrvCellCfg(srvCellCfg->pdsch_ServingCellConfig) != ROK)
4646    {
4647       DU_LOG("\nERROR  -->  F1AP : BuildPdschSrvCellCfg failed");
4648       return RFAILED;
4649    }
4650
4651    srvCellCfg->csi_MeasConfig = NULLP;
4652 #if 0
4653    DU_ALLOC(srvCellCfg->csi_MeasConfig, sizeof(struct   ServingCellConfig__csi_MeasConfig))
4654       if(!srvCellCfg->csi_MeasConfig)
4655       {
4656          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
4657          return RFAILED;
4658       }
4659
4660    if(BuildCsiMeasCfg(srvCellCfg->csi_MeasConfig) != ROK)
4661    {
4662       DU_LOG("\nF1AP : BuildCsiMeasCfg failed");
4663       return RFAILED;
4664    }
4665 #endif
4666    srvCellCfg->sCellDeactivationTimer = NULLP;
4667    srvCellCfg->crossCarrierSchedulingConfig = NULLP;
4668    srvCellCfg->tag_Id = TAG_ID;
4669    srvCellCfg->dummy = NULLP;
4670    srvCellCfg->pathlossReferenceLinking = NULLP;
4671    srvCellCfg->servingCellMO = NULLP;
4672    srvCellCfg->ext1 = NULLP;
4673
4674    return ROK;
4675 }
4676 /*******************************************************************
4677  *
4678  * @brief Builds Spcell config
4679  *
4680  * @details
4681  *
4682  *    Function : BuildSpCellCfg
4683  *
4684  *    Functionality: Builds sp cell config in DuToCuRrcContainer
4685  *
4686  * @params[in] SpCellConfig_t spCellCfg
4687  *
4688  * @return ROK     - success
4689  *         RFAILED - failure
4690  *
4691  * ****************************************************************/
4692 uint8_t BuildSpCellCfg(SpCellConfig_t *spCellCfg)
4693 {
4694
4695    spCellCfg->servCellIndex = NULLP;
4696    DU_ALLOC(spCellCfg->servCellIndex, sizeof(long));
4697    if(!spCellCfg->servCellIndex)
4698    {
4699       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfg");
4700       return RFAILED;
4701    }
4702    *(spCellCfg->servCellIndex) = SERV_CELL_IDX;
4703
4704    spCellCfg->reconfigurationWithSync = NULLP;
4705    spCellCfg->rlf_TimersAndConstants = NULLP;
4706    spCellCfg->rlmInSyncOutOfSyncThreshold = NULLP;
4707    DU_ALLOC(spCellCfg->rlmInSyncOutOfSyncThreshold, sizeof(long));
4708    if(!spCellCfg->rlmInSyncOutOfSyncThreshold)
4709    {
4710       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfg");
4711       return RFAILED;
4712    }
4713    *(spCellCfg->rlmInSyncOutOfSyncThreshold) = RLM_SYNC_OUT_SYNC_THRESHOLD;
4714
4715    spCellCfg->spCellConfigDedicated = NULLP;
4716    DU_ALLOC(spCellCfg->spCellConfigDedicated, sizeof(ServingCellConfig_t));
4717    if(!spCellCfg->spCellConfigDedicated)
4718    {
4719       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfg");
4720       return RFAILED;
4721    }
4722    if(BuildSpCellCfgDed(spCellCfg->spCellConfigDedicated) != ROK)
4723    {
4724       DU_LOG("\nERROR  -->  F1AP : BuildSpCellCfgDed failed");
4725       return RFAILED;
4726    }
4727    return ROK;
4728 }
4729 /*******************************************************************
4730  *
4731  * @brief Builds Phy cell group config
4732  *
4733  * @details
4734  *
4735  *    Function : BuildPhyCellGrpCfg
4736  *
4737  *    Functionality: Builds Phy cell group config in DuToCuRrcContainer
4738  *
4739  * @params[in] PhysicalCellGroupConfig_t *phyCellGrpCfg
4740  *
4741  * @return ROK     - success
4742  *         RFAILED - failure
4743  *
4744  * ****************************************************************/
4745 uint8_t BuildPhyCellGrpCfg(PhysicalCellGroupConfig_t *phyCellGrpCfg)
4746 {
4747    phyCellGrpCfg->harq_ACK_SpatialBundlingPUCCH = NULLP;
4748    phyCellGrpCfg->harq_ACK_SpatialBundlingPUSCH = NULLP;
4749
4750    phyCellGrpCfg->p_NR_FR1 = NULLP;
4751    DU_ALLOC(phyCellGrpCfg->p_NR_FR1, sizeof(long));
4752    if(!phyCellGrpCfg->p_NR_FR1)
4753    {
4754       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildPhyCellGrpCfg");
4755       return RFAILED;
4756    }
4757    *(phyCellGrpCfg->p_NR_FR1)             = P_NR_FR1;
4758    phyCellGrpCfg->pdsch_HARQ_ACK_Codebook = PDSCH_HARQ_ACK_CODEBOOK;
4759    phyCellGrpCfg->tpc_SRS_RNTI = NULLP;
4760    phyCellGrpCfg->tpc_PUCCH_RNTI = NULLP;
4761    phyCellGrpCfg->tpc_PUSCH_RNTI = NULLP;
4762    phyCellGrpCfg->sp_CSI_RNTI = NULLP;
4763    phyCellGrpCfg->cs_RNTI = NULLP;
4764    phyCellGrpCfg->ext1 = NULLP;
4765    phyCellGrpCfg->ext2 = NULLP;
4766
4767    return ROK;
4768 }
4769 /*******************************************************************
4770  *
4771  * @brief Builds Mac cell group config
4772  *
4773  * @details
4774  *
4775  *    Function : BuildMacCellGrpCfg
4776  *
4777  *    Functionality: Builds Mac cell group config in DuToCuRrcContainer
4778  *
4779  * @params[in] MAC_CellGroupConfig_t *macCellGrpCfg
4780  *
4781  * @return ROK     - success
4782  *         RFAILED - failure
4783  *
4784  * ****************************************************************/
4785 uint8_t BuildMacCellGrpCfg(MAC_CellGroupConfig_t *macCellGrpCfg)
4786 {
4787    macCellGrpCfg->drx_Config = NULLP;
4788    macCellGrpCfg->schedulingRequestConfig = NULLP;
4789    DU_ALLOC(macCellGrpCfg->schedulingRequestConfig, sizeof(struct SchedulingRequestConfig));
4790    if(!macCellGrpCfg->schedulingRequestConfig)
4791    {
4792       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacCellGrpCfg");
4793       return RFAILED;
4794    }
4795
4796    if(BuildSchedulingReqConfig(macCellGrpCfg->schedulingRequestConfig) != ROK)
4797    {
4798       DU_LOG("\nERROR  -->  F1AP : BuildSchedulingReqConfig failed");
4799       return RFAILED;
4800    }
4801
4802    macCellGrpCfg->bsr_Config = NULLP;
4803    DU_ALLOC(macCellGrpCfg->bsr_Config, sizeof(struct BSR_Config));
4804    if(!macCellGrpCfg->bsr_Config)
4805    {
4806       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacCellGrpCfg");
4807       return RFAILED;
4808    }
4809
4810    if(BuildBsrConfig(macCellGrpCfg->bsr_Config) != ROK)
4811    {
4812       DU_LOG("\nERROR  -->  F1AP : BuildBsrConfig failed");
4813       return RFAILED;
4814    }
4815
4816    macCellGrpCfg->tag_Config = NULLP;
4817    DU_ALLOC(macCellGrpCfg->tag_Config, sizeof(struct TAG_Config));
4818    if(!macCellGrpCfg->tag_Config)
4819    {
4820       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacCellGrpCfg");
4821       return RFAILED;
4822    }
4823
4824    if(BuildTagConfig(macCellGrpCfg->tag_Config) != ROK)
4825    {
4826       DU_LOG("\nERROR  -->  F1AP : BuildTagConfig failed");
4827       return RFAILED;
4828    }
4829
4830    macCellGrpCfg->phr_Config = NULLP;
4831    DU_ALLOC(macCellGrpCfg->phr_Config, sizeof(struct MAC_CellGroupConfig__phr_Config));
4832    if(!macCellGrpCfg->phr_Config)
4833    {
4834       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacCellGrpCfg");
4835       return RFAILED;
4836    }
4837
4838    if(BuildPhrConfig(macCellGrpCfg->phr_Config) != ROK)
4839    {
4840       DU_LOG("\nERROR  -->  F1AP : BuildPhrConfig failed");
4841       return RFAILED;
4842    }
4843
4844    macCellGrpCfg->skipUplinkTxDynamic = false;
4845    macCellGrpCfg->ext1 = NULLP;
4846
4847    return ROK;
4848 }
4849 /*******************************************************************
4850  *
4851  * @brief Frees memeory allocated for SearchSpcToAddModList
4852  *
4853  * @details
4854  *
4855  *    Function : FreeSearchSpcToAddModList
4856  *
4857  *    Functionality: Deallocating memory of SearchSpcToAddModList
4858  *
4859  * @params[in] struct PDCCH_Config__searchSpacesToAddModList *searchSpcList
4860  *
4861  * @return void
4862  *
4863  4221 * ****************************************************************/
4864 void FreeSearchSpcToAddModList(struct PDCCH_Config__searchSpacesToAddModList *searchSpcList)
4865 {
4866    uint8_t idx1=0;
4867    uint8_t idx2=0;
4868    struct  SearchSpace *searchSpc=NULLP;
4869
4870    if(searchSpcList->list.array)
4871    {
4872       if(searchSpcList->list.array[idx2])
4873       {
4874          searchSpc = searchSpcList->list.array[idx2];
4875          if(searchSpc->controlResourceSetId)
4876          {
4877             if(searchSpc->monitoringSlotPeriodicityAndOffset)
4878             {
4879                if(searchSpc->monitoringSymbolsWithinSlot)
4880                {
4881                   if(searchSpc->monitoringSymbolsWithinSlot->buf)
4882                   {
4883                      if(searchSpc->nrofCandidates)
4884                      {
4885                         if(searchSpc->searchSpaceType)
4886                         {
4887                            DU_FREE(searchSpc->searchSpaceType->choice.ue_Specific,\
4888                                  sizeof(struct SearchSpace__searchSpaceType__ue_Specific));
4889                            DU_FREE(searchSpc->searchSpaceType, sizeof(struct
4890                                     SearchSpace__searchSpaceType));
4891                         }
4892                         DU_FREE(searchSpc->nrofCandidates,
4893                               sizeof(struct SearchSpace__nrofCandidates));
4894                      }
4895                      DU_FREE(searchSpc->monitoringSymbolsWithinSlot->buf, \
4896                            searchSpc->monitoringSymbolsWithinSlot->size);
4897                   }
4898                   DU_FREE(searchSpc->monitoringSymbolsWithinSlot,
4899                         sizeof(BIT_STRING_t));
4900                }
4901                DU_FREE(searchSpc->monitoringSlotPeriodicityAndOffset, \
4902                      sizeof(struct SearchSpace__monitoringSlotPeriodicityAndOffset));
4903             }
4904             DU_FREE(searchSpc->controlResourceSetId,
4905                   sizeof(ControlResourceSetId_t));
4906          }
4907       }
4908       for(idx1 = 0; idx1 < searchSpcList->list.count; idx1++)
4909       {
4910          DU_FREE(searchSpcList->list.array[idx1],
4911                sizeof(struct SearchSpace));
4912       }
4913       DU_FREE(searchSpcList->list.array,searchSpcList->list.size);
4914    }
4915 }
4916 /*******************************************************************
4917  *
4918  * @brief Frees memory allocated for PdschTimeDomAllocList
4919  *
4920  * @details
4921  *
4922  *    Function : FreePdschTimeDomAllocList
4923  *
4924  *    Functionality: Deallocating memory of PdschTimeDomAllocList
4925  *
4926  * @params[in] struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList
4927  *
4928  * @return void
4929  *
4930  4221 * ****************************************************************/
4931 void FreePdschTimeDomAllocList( struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList)
4932 {
4933    uint8_t idx1=0;
4934
4935    if(timeDomAllocList->choice.setup)
4936    {
4937       if(timeDomAllocList->choice.setup->list.array)
4938       {
4939          for(idx1 = 0; idx1 <timeDomAllocList->choice.setup->list.count ; idx1++)
4940          {
4941             DU_FREE(timeDomAllocList->choice.setup->list.array[idx1],
4942                   sizeof(struct PDSCH_TimeDomainResourceAllocation));
4943          }
4944          DU_FREE(timeDomAllocList->choice.setup->list.array, \
4945                timeDomAllocList->choice.setup->list.size);
4946       }
4947       DU_FREE(timeDomAllocList->choice.setup,\
4948             sizeof(struct PDSCH_TimeDomainResourceAllocationList));
4949    }
4950 }
4951 /*******************************************************************
4952  *
4953  * @brief Frees memory allocated for PuschTimeDomAllocList
4954  *
4955  *@details
4956  *
4957  *    Function : FreePuschTimeDomAllocList
4958  *
4959  *    Functionality: Deallocating memory of PuschTimeDomAllocList
4960  *
4961  * @params[in] PUSCH_Config_t *puschCfg
4962  *
4963  * @return void
4964  *
4965  * ****************************************************************/
4966 void FreePuschTimeDomAllocList(PUSCH_Config_t *puschCfg)
4967 {
4968    uint8_t idx1=0;
4969    uint8_t idx2=0;
4970    struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList_t=NULLP;
4971
4972    if(puschCfg->pusch_TimeDomainAllocationList)
4973    {
4974       timeDomAllocList_t=puschCfg->pusch_TimeDomainAllocationList;
4975       if(timeDomAllocList_t->choice.setup)
4976       {
4977          if(timeDomAllocList_t->choice.setup->list.array)
4978          {
4979             DU_FREE(timeDomAllocList_t->choice.setup->list.array[idx2]->k2, sizeof(long));
4980             for(idx1 = 0; idx1<timeDomAllocList_t->choice.setup->list.count; idx1++)
4981             {
4982                DU_FREE(timeDomAllocList_t->choice.setup->list.array[idx1],\
4983                      sizeof(PUSCH_TimeDomainResourceAllocation_t));
4984             }
4985             DU_FREE(timeDomAllocList_t->choice.setup->list.array, \
4986                   timeDomAllocList_t->choice.setup->list.size);
4987          }
4988          DU_FREE(timeDomAllocList_t->choice.setup, \
4989                sizeof(struct PUSCH_TimeDomainResourceAllocationList));
4990       }
4991       DU_FREE(puschCfg->transformPrecoder, sizeof(long));
4992       DU_FREE(puschCfg->pusch_TimeDomainAllocationList, \
4993             sizeof(struct PUSCH_Config__pusch_TimeDomainAllocationList));
4994    }
4995
4996 }
4997 /*******************************************************************
4998  *
4999  * @brief Frees memory allocated for InitialUlBWP
5000  *
5001  * @details
5002  *
5003  *    Function : FreeInitialUlBWP
5004  *
5005  *    Functionality: Deallocating memory of InitialUlBWP
5006  *
5007  * @params[in] BWP_UplinkDedicated_t *ulBwp
5008  *
5009  * @return void
5010  *
5011  * ****************************************************************/
5012 void FreeInitialUlBWP(BWP_UplinkDedicated_t *ulBwp)
5013 {
5014    uint8_t  rSetIdx, rsrcIdx;
5015    SRS_Config_t   *srsCfg = NULLP;
5016    PUSCH_Config_t *puschCfg = NULLP;
5017    struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA *dmrsUlCfg = NULLP;
5018    struct SRS_Config__srs_ResourceSetToAddModList *rsrcSetList = NULLP;
5019    struct SRS_ResourceSet__srs_ResourceIdList *rsrcIdList = NULLP;
5020    struct SRS_Config__srs_ResourceToAddModList *resourceList = NULLP;
5021
5022    if(ulBwp->pusch_Config)
5023    {
5024       if(ulBwp->pusch_Config->choice.setup)
5025       {
5026          puschCfg=ulBwp->pusch_Config->choice.setup;
5027          if(puschCfg->dataScramblingIdentityPUSCH)
5028          {
5029             if(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA)
5030             {
5031                FreePuschTimeDomAllocList(puschCfg);
5032                dmrsUlCfg=puschCfg->dmrs_UplinkForPUSCH_MappingTypeA;
5033                if(dmrsUlCfg->choice.setup)
5034                {
5035                   if(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition)
5036                   {
5037                      if(dmrsUlCfg->choice.setup->transformPrecodingDisabled)
5038                      {
5039                         DU_FREE(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0,\
5040                               sizeof(long));
5041                         DU_FREE(dmrsUlCfg->choice.setup->transformPrecodingDisabled,
5042                               sizeof(struct DMRS_UplinkConfig__transformPrecodingDisabled));
5043                      }
5044                      DU_FREE(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition,
5045                            sizeof(long));
5046                   }
5047                   DU_FREE(dmrsUlCfg->choice.setup,sizeof(DMRS_UplinkConfig_t));
5048                }
5049                DU_FREE(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA, \
5050                      sizeof(struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA));
5051             }
5052             DU_FREE(puschCfg->dataScramblingIdentityPUSCH, sizeof(long));
5053          }
5054          DU_FREE(ulBwp->pusch_Config->choice.setup, sizeof(PUSCH_Config_t));
5055       }
5056       DU_FREE(ulBwp->pusch_Config, sizeof(struct BWP_UplinkDedicated__pusch_Config));
5057
5058       /* Free SRS-Config */
5059       if(ulBwp->srs_Config)
5060       {
5061          if(ulBwp->srs_Config->choice.setup)
5062          {
5063             srsCfg = ulBwp->srs_Config->choice.setup;
5064
5065             /* Free Resource Set to add/mod list */
5066             if(srsCfg->srs_ResourceSetToAddModList)
5067             {
5068                rsrcSetList = srsCfg->srs_ResourceSetToAddModList;
5069                if(rsrcSetList->list.array)
5070                {
5071                   rSetIdx = 0;
5072
5073                   /* Free SRS resource Id list in this SRS resource set */
5074                   if(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList)
5075                   {
5076                      rsrcIdList = rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList;
5077
5078                      if(rsrcIdList->list.array)
5079                      {
5080                         for(rsrcIdx = 0; rsrcIdx < rsrcIdList->list.count; rsrcIdx++)
5081                         {
5082                            DU_FREE(rsrcIdList->list.array[rsrcIdx], sizeof(SRS_ResourceId_t));
5083                         }
5084                         DU_FREE(rsrcIdList->list.array, rsrcIdList->list.size);
5085                      }
5086                      DU_FREE(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList,\
5087                            sizeof(struct SRS_ResourceSet__srs_ResourceIdList));
5088                   }
5089
5090                   /* Free resource type info for this SRS resource set */
5091                   DU_FREE(rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic, \
5092                         sizeof(struct SRS_ResourceSet__resourceType__aperiodic));
5093
5094                   /* Free memory for each resource set */
5095                   for(rSetIdx = 0; rSetIdx < rsrcSetList->list.count; rSetIdx++)
5096                   {
5097                      DU_FREE(rsrcSetList->list.array[rSetIdx], sizeof(SRS_ResourceSet_t));
5098                   }
5099                   DU_FREE(rsrcSetList->list.array, rsrcSetList->list.size);
5100                }
5101                DU_FREE(srsCfg->srs_ResourceSetToAddModList, \
5102                      sizeof(struct SRS_Config__srs_ResourceSetToAddModList));
5103             }
5104
5105             /* Free resource to add/modd list */
5106             if(srsCfg->srs_ResourceToAddModList)
5107             {
5108                resourceList = srsCfg->srs_ResourceToAddModList;
5109                if(resourceList->list.array)
5110                {
5111                   rsrcIdx = 0;
5112                   DU_FREE(resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2,\
5113                         sizeof(struct SRS_Resource__transmissionComb__n2));
5114                   DU_FREE(resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic,\
5115                         sizeof(struct SRS_Resource__resourceType__aperiodic));
5116
5117                   for(rsrcIdx = 0; rsrcIdx < resourceList->list.count; rsrcIdx++)
5118                   {
5119                      DU_FREE(resourceList->list.array[rsrcIdx], sizeof(SRS_Resource_t));
5120                   }
5121                   DU_FREE(resourceList->list.array, resourceList->list.size);
5122                }
5123                DU_FREE(srsCfg->srs_ResourceToAddModList, \
5124                      sizeof(struct SRS_Config__srs_ResourceToAddModList));
5125             }
5126
5127             DU_FREE(ulBwp->srs_Config->choice.setup, sizeof(SRS_Config_t));
5128          }
5129          DU_FREE(ulBwp->srs_Config, sizeof(struct BWP_UplinkDedicated__srs_Config));
5130       }
5131    }
5132 }
5133 /*******************************************************************
5134  *
5135  * @brief Frees memory allocated for initialUplinkBWP
5136  *
5137  * @details
5138  *
5139  *    Function : FreeinitialUplinkBWP
5140  *
5141  *    Functionality: Deallocating memory of initialUplinkBWP
5142  *
5143  * @params[in] UplinkConfig_t *ulCfg
5144  *
5145  * @return void
5146  *
5147  *
5148  * ****************************************************************/
5149 void FreeinitialUplinkBWP(UplinkConfig_t *ulCfg)
5150 {
5151    BWP_UplinkDedicated_t *ulBwp=NULLP;
5152    struct UplinkConfig__pusch_ServingCellConfig *puschCfg=NULLP;
5153
5154    if(ulCfg->initialUplinkBWP)
5155    {
5156       ulBwp=ulCfg->initialUplinkBWP;
5157       if(ulCfg->firstActiveUplinkBWP_Id)
5158       {
5159          if(ulCfg->pusch_ServingCellConfig)
5160          {
5161             puschCfg=ulCfg->pusch_ServingCellConfig;
5162             if(puschCfg->choice.setup)
5163             {
5164                if(puschCfg->choice.setup->ext1)
5165                {
5166                   DU_FREE(puschCfg->choice.setup->ext1->\
5167                         processingType2Enabled,sizeof(BOOLEAN_t));
5168                   DU_FREE(puschCfg->choice.setup->ext1->\
5169                         maxMIMO_Layers,sizeof(long));
5170                   DU_FREE(puschCfg->choice.setup->ext1, \
5171                         sizeof(struct PUSCH_ServingCellConfig__ext1));
5172                }
5173                DU_FREE(puschCfg->choice.setup, sizeof(struct PUSCH_ServingCellConfig));
5174             }
5175             DU_FREE(ulCfg->pusch_ServingCellConfig, sizeof(struct UplinkConfig__pusch_ServingCellConfig));
5176          }
5177          DU_FREE(ulCfg->firstActiveUplinkBWP_Id, sizeof(BWP_Id_t));
5178       }
5179       FreeInitialUlBWP(ulBwp);
5180       DU_FREE(ulCfg->initialUplinkBWP, sizeof(BWP_UplinkDedicated_t));
5181    }
5182 }
5183 /*******************************************************************
5184  *
5185  * @brief Frees emmory allocated for BWPDlDedPdschCfg
5186  *
5187  * @details
5188  *
5189  *    Function : FreeBWPDlDedPdschCfg
5190  *
5191  *    Functionality: Deallocating memory of BWPDlDedPdschCfg
5192  *
5193  * @params[in] BWP_DownlinkDedicated_t *dlBwp
5194  *
5195  * @return void
5196  *
5197  *
5198  * ****************************************************************/
5199 void FreeBWPDlDedPdschCfg(BWP_DownlinkDedicated_t *dlBwp)
5200 {
5201    struct PDSCH_Config *pdschCfg=NULLP;
5202    struct PDSCH_Config__prb_BundlingType *prbBndlType=NULLP;
5203    struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList=NULLP;
5204    struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA *dmrsDlCfg=NULLP;
5205
5206    if(dlBwp->pdsch_Config->choice.setup)
5207    {
5208       pdschCfg=dlBwp->pdsch_Config->choice.setup;
5209       if(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA)
5210       {
5211          if(pdschCfg->pdsch_TimeDomainAllocationList)
5212          {
5213             timeDomAllocList=pdschCfg->pdsch_TimeDomainAllocationList;
5214             if(pdschCfg->maxNrofCodeWordsScheduledByDCI)
5215             {
5216                prbBndlType=&pdschCfg->prb_BundlingType;
5217                DU_FREE(prbBndlType->choice.staticBundling,\
5218                      sizeof(struct PDSCH_Config__prb_BundlingType__staticBundling));
5219                DU_FREE(pdschCfg->maxNrofCodeWordsScheduledByDCI, sizeof(long));
5220             }
5221             FreePdschTimeDomAllocList(timeDomAllocList);
5222             DU_FREE(pdschCfg->pdsch_TimeDomainAllocationList, \
5223                   sizeof(struct PDSCH_Config__pdsch_TimeDomainAllocationList));
5224          }
5225          dmrsDlCfg=pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA;
5226          if(dmrsDlCfg->choice.setup)
5227          {
5228             DU_FREE(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition,
5229                   sizeof(long));
5230             DU_FREE(dmrsDlCfg->choice.setup, sizeof(struct DMRS_DownlinkConfig));
5231          }
5232          DU_FREE(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA, \
5233                sizeof(struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA));
5234       }
5235       DU_FREE(dlBwp->pdsch_Config->choice.setup, sizeof(struct PDSCH_Config));
5236    }
5237 }
5238 /*******************************************************************
5239  *
5240  * @brief Frees emmory allocated for BWPDlDedPdcchCfg
5241  *
5242  * @details
5243  *
5244  *    Function : FreeBWPDlDedPdcchCfg
5245  *
5246  *    Functionality: Deallocating memory of BWPDlDedPdcchCfg
5247  *
5248  * @params[in] BWP_DownlinkDedicated_t *dlBwp
5249  *
5250  * @return void
5251  *
5252  *
5253  * ****************************************************************/
5254 void FreeBWPDlDedPdcchCfg(BWP_DownlinkDedicated_t *dlBwp)
5255 {
5256    uint8_t idx1=0;
5257    uint8_t idx2=0;
5258    struct PDCCH_Config *pdcchCfg=NULLP;
5259    struct ControlResourceSet *controlRSet=NULLP;
5260    struct PDCCH_Config__controlResourceSetToAddModList *controlRSetList=NULLP;
5261
5262    if(dlBwp->pdcch_Config->choice.setup)
5263    {
5264       pdcchCfg=dlBwp->pdcch_Config->choice.setup;
5265       if(pdcchCfg->controlResourceSetToAddModList)
5266       {
5267          controlRSetList = pdcchCfg->controlResourceSetToAddModList;
5268          if(controlRSetList->list.array)
5269          {
5270             controlRSet = controlRSetList->list.array[idx2];
5271             if(controlRSet)
5272             {
5273                if(controlRSet->frequencyDomainResources.buf)
5274                {
5275                   if(controlRSet->pdcch_DMRS_ScramblingID)
5276                   {
5277                      if(pdcchCfg->searchSpacesToAddModList)
5278                      {
5279                         FreeSearchSpcToAddModList(pdcchCfg->searchSpacesToAddModList);
5280                         DU_FREE(pdcchCfg->searchSpacesToAddModList, \
5281                               sizeof(struct PDCCH_Config__searchSpacesToAddModList));
5282                      }
5283                      DU_FREE(controlRSet->pdcch_DMRS_ScramblingID, sizeof(long));
5284                   }
5285                   DU_FREE(controlRSet->frequencyDomainResources.buf, \
5286                         controlRSet->frequencyDomainResources.size);
5287                }
5288             }
5289             for(idx1 = 0; idx1 <controlRSetList->list.count; idx1++)
5290             {
5291                DU_FREE(controlRSetList->list.array[idx1], sizeof(struct ControlResourceSet));
5292             }
5293             DU_FREE(controlRSetList->list.array, controlRSetList->list.size);
5294          }
5295          DU_FREE(pdcchCfg->controlResourceSetToAddModList, \
5296                sizeof(struct PDCCH_Config__controlResourceSetToAddModList));
5297       }
5298       DU_FREE(dlBwp->pdcch_Config->choice.setup, sizeof(struct PDCCH_Config));
5299    }
5300 }
5301
5302 /*******************************************************************
5303  *
5304  * @brief Frees emmory allocated for DUToCURRCContainer
5305  *
5306  * @details
5307  *
5308  *    Function : FreeMemDuToCuRrcCont
5309  *
5310  *    Functionality: Deallocating memory of DuToCuRrcContainer
5311  *
5312  * @params[in] DuToCuRRCContainer, DuToCuRRCContainer
5313  *
5314  * @return ROK     - success
5315  *         RFAILED - failure
5316  *
5317  * ****************************************************************/
5318 uint8_t FreeMemDuToCuRrcCont(CellGroupConfigRrc_t *cellGrpCfg)
5319 {
5320    uint8_t idx=0;
5321    SpCellConfig_t *spCellCfg=NULLP;
5322    ServingCellConfig_t *srvCellCfg=NULLP;
5323    BWP_DownlinkDedicated_t *dlBwp=NULLP;
5324    MAC_CellGroupConfig_t *macCellGrpCfg=NULLP;
5325    PhysicalCellGroupConfig_t *phyCellGrpCfg=NULLP;
5326    struct CellGroupConfigRrc__rlc_BearerToAddModList *rlcBearerList=NULLP;
5327    struct RLC_Config *rlcConfig=NULLP;
5328    struct LogicalChannelConfig *macLcConfig=NULLP;
5329    struct SchedulingRequestConfig *schedulingRequestConfig=NULLP;
5330    struct SchedulingRequestConfig__schedulingRequestToAddModList *schReqList=NULLP;
5331    struct TAG_Config *tagConfig=NULLP;
5332    struct TAG_Config__tag_ToAddModList *tagList=NULLP;
5333    struct MAC_CellGroupConfig__phr_Config *phrConfig=NULLP;
5334    struct ServingCellConfig__pdsch_ServingCellConfig *pdschCfg=NULLP;
5335
5336    rlcBearerList = cellGrpCfg->rlc_BearerToAddModList;
5337    if(rlcBearerList)
5338    {
5339       if(rlcBearerList->list.array)
5340       {
5341          for(idx=0; idx<rlcBearerList->list.count; idx++)
5342          {
5343             if(rlcBearerList->list.array[idx])
5344             {
5345                rlcConfig   = rlcBearerList->list.array[idx]->rlc_Config;
5346                macLcConfig = rlcBearerList->list.array[idx]->mac_LogicalChannelConfig;
5347                if(rlcConfig)
5348                {
5349                   if(rlcConfig->choice.am)
5350                   {
5351                      DU_FREE(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
5352                      DU_FREE(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
5353                      DU_FREE(rlcConfig->choice.am, sizeof(struct RLC_Config__am));
5354                   }
5355                   DU_FREE(rlcConfig, sizeof(struct RLC_Config));
5356                }
5357                DU_FREE(rlcBearerList->list.array[idx]->servedRadioBearer, sizeof(struct RLC_BearerConfig__servedRadioBearer));
5358                if(macLcConfig)
5359                {
5360                   if(macLcConfig->ul_SpecificParameters)
5361                   {
5362                      DU_FREE(macLcConfig->ul_SpecificParameters->schedulingRequestID,   sizeof(SchedulingRequestId_t));
5363                      DU_FREE(macLcConfig->ul_SpecificParameters->logicalChannelGroup,   sizeof(long));
5364                      DU_FREE(macLcConfig->ul_SpecificParameters, sizeof(struct LogicalChannelConfig__ul_SpecificParameters));
5365                   }
5366                   DU_FREE(rlcBearerList->list.array[idx]->mac_LogicalChannelConfig, sizeof(struct LogicalChannelConfig));
5367                }
5368                DU_FREE(rlcBearerList->list.array[idx], sizeof(struct RLC_BearerConfig));
5369             }
5370          }
5371          DU_FREE(rlcBearerList->list.array, rlcBearerList->list.size);
5372       }
5373       DU_FREE(cellGrpCfg->rlc_BearerToAddModList, sizeof(struct CellGroupConfigRrc__rlc_BearerToAddModList));
5374    }
5375
5376    macCellGrpCfg = cellGrpCfg->mac_CellGroupConfig;
5377    if(macCellGrpCfg)
5378    {
5379       schedulingRequestConfig = macCellGrpCfg->schedulingRequestConfig;
5380       if(schedulingRequestConfig)
5381       {
5382          schReqList = schedulingRequestConfig->schedulingRequestToAddModList;
5383          if(schReqList)
5384          {
5385             if(schReqList->list.array)
5386             {
5387                for(idx=0;idx<schReqList->list.count; idx++)
5388                {
5389                   if(schReqList->list.array[idx])
5390                   {
5391                      DU_FREE(schReqList->list.array[idx]->sr_ProhibitTimer, sizeof(long));
5392                      DU_FREE(schReqList->list.array[idx], sizeof(struct SchedulingRequestToAddMod));
5393                   }
5394                }
5395                DU_FREE(schReqList->list.array, schReqList->list.size);
5396             }
5397             DU_FREE(schedulingRequestConfig->schedulingRequestToAddModList,\
5398                   sizeof(struct SchedulingRequestConfig__schedulingRequestToAddModList));    }
5399             DU_FREE(macCellGrpCfg->schedulingRequestConfig, sizeof(struct SchedulingRequestConfig));
5400       }
5401       if(macCellGrpCfg->bsr_Config)
5402       {
5403          DU_FREE(macCellGrpCfg->bsr_Config, sizeof(struct BSR_Config));
5404       }
5405       tagConfig = macCellGrpCfg->tag_Config;
5406       if(tagConfig)
5407       {
5408          tagList = tagConfig->tag_ToAddModList;
5409          if(tagList)
5410          {
5411             if(tagList->list.array)
5412             {
5413                for(idx=0; idx<tagList->list.count; idx++)
5414                {
5415                   DU_FREE(tagList->list.array[idx], sizeof(struct TAG));
5416                }
5417                DU_FREE(tagList->list.array, tagList->list.size);
5418             }
5419             DU_FREE(tagConfig->tag_ToAddModList, sizeof(struct TAG_Config__tag_ToAddModList));
5420          }
5421          DU_FREE(tagConfig, sizeof(struct TAG_Config));
5422       }
5423
5424       phrConfig = macCellGrpCfg->phr_Config;
5425       if(phrConfig)
5426       {
5427          DU_FREE(phrConfig->choice.setup, sizeof(struct PHR_Config));
5428          DU_FREE(phrConfig, sizeof(struct MAC_CellGroupConfig__phr_Config));
5429       }
5430
5431       DU_FREE(macCellGrpCfg, sizeof(MAC_CellGroupConfig_t));
5432    }
5433
5434    phyCellGrpCfg = cellGrpCfg->physicalCellGroupConfig;
5435    if(phyCellGrpCfg)
5436    {
5437       DU_FREE(phyCellGrpCfg->p_NR_FR1, sizeof(long));
5438       DU_FREE(phyCellGrpCfg, sizeof(PhysicalCellGroupConfig_t));
5439    }
5440
5441    spCellCfg = cellGrpCfg->spCellConfig;
5442    if(spCellCfg)
5443    {
5444       if(spCellCfg->servCellIndex)
5445       {
5446          if(spCellCfg->rlmInSyncOutOfSyncThreshold)
5447          {
5448             if(spCellCfg->spCellConfigDedicated)
5449             {
5450                srvCellCfg = spCellCfg->spCellConfigDedicated;
5451                if(srvCellCfg->tdd_UL_DL_ConfigurationDedicated)
5452                {
5453                   if(srvCellCfg->initialDownlinkBWP)
5454                   {
5455                      dlBwp = srvCellCfg->initialDownlinkBWP;
5456                      if(srvCellCfg->firstActiveDownlinkBWP_Id)
5457                      {
5458                         if(srvCellCfg->defaultDownlinkBWP_Id)
5459                         {
5460                            if(srvCellCfg->uplinkConfig)
5461                            {
5462                               if(srvCellCfg->pdsch_ServingCellConfig)
5463                               {
5464                                  pdschCfg= srvCellCfg->pdsch_ServingCellConfig;
5465                                  if(pdschCfg->choice.setup)
5466                                  {
5467                                     DU_FREE(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH,sizeof(long));
5468                                     DU_FREE(pdschCfg->choice.setup, sizeof( struct PDSCH_ServingCellConfig));
5469                                  }
5470                                  DU_FREE(srvCellCfg->pdsch_ServingCellConfig, sizeof(struct
5471                                        ServingCellConfig__pdsch_ServingCellConfig));
5472                               }
5473                               FreeinitialUplinkBWP(srvCellCfg->uplinkConfig);
5474                               DU_FREE(srvCellCfg->uplinkConfig, sizeof(UplinkConfig_t));
5475                            }
5476                            DU_FREE(srvCellCfg->defaultDownlinkBWP_Id, sizeof(long));
5477                         }
5478                         DU_FREE(srvCellCfg->firstActiveDownlinkBWP_Id, sizeof(long));
5479                      }
5480                      if(dlBwp->pdcch_Config)
5481                      {
5482                         if(dlBwp->pdsch_Config)
5483                         {
5484                            FreeBWPDlDedPdschCfg(dlBwp);
5485                            DU_FREE(dlBwp->pdsch_Config, sizeof(struct BWP_DownlinkDedicated__pdsch_Config));
5486                         }
5487                         FreeBWPDlDedPdcchCfg(dlBwp);
5488                         DU_FREE(dlBwp->pdcch_Config, sizeof(struct BWP_DownlinkDedicated__pdcch_Config));
5489                     }
5490                     DU_FREE(srvCellCfg->initialDownlinkBWP, sizeof(BWP_DownlinkDedicated_t));
5491                   }
5492                   DU_FREE(srvCellCfg->tdd_UL_DL_ConfigurationDedicated, sizeof(TDD_UL_DL_ConfigDedicated_t));
5493                }
5494                DU_FREE(spCellCfg->spCellConfigDedicated, sizeof(ServingCellConfig_t));
5495             }
5496             DU_FREE(spCellCfg->rlmInSyncOutOfSyncThreshold, sizeof(long));
5497          }
5498          DU_FREE(spCellCfg->servCellIndex, sizeof(long));
5499       }
5500       DU_FREE(spCellCfg,sizeof(SpCellConfig_t));
5501    }
5502    return ROK;
5503 }
5504 /*******************************************************************
5505  *
5506  * @brief Builds DU To CU RRC Container
5507  *
5508  * @details
5509  *
5510  *    Function : BuildDuToCuRrcContainer
5511  *
5512  *    Functionality: Builds DuToCuRrcContainer
5513  *
5514  * @params[in] idx, index in F1AP msg
5515  *             DuToCuRRCContainer, DuToCuRRCContainer
5516  *
5517  * @return ROK     - success
5518  *         RFAILED - failure
5519  *
5520  * ****************************************************************/
5521 uint8_t BuildDuToCuRrcContainer(DUtoCURRCContainer_t *duToCuRrcContainer)
5522 {
5523    uint8_t  ret = ROK;
5524    CellGroupConfigRrc_t  cellGrpCfg;
5525    asn_enc_rval_t        encRetVal;
5526    memset(&cellGrpCfg, 0, sizeof(CellGroupConfigRrc_t));
5527    memset(&encRetVal, 0, sizeof(asn_enc_rval_t));
5528
5529    while(true)
5530    {
5531       cellGrpCfg.cellGroupId = CELL_GRP_ID;
5532
5533       cellGrpCfg.rlc_BearerToAddModList = NULLP;
5534       DU_ALLOC(cellGrpCfg.rlc_BearerToAddModList, sizeof(struct CellGroupConfigRrc__rlc_BearerToAddModList));
5535       if(!cellGrpCfg.rlc_BearerToAddModList)
5536       {
5537          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildDuToCuRrcContainer");
5538          ret = RFAILED;
5539          break;
5540       }
5541       if(BuildRlcBearerToAddModList(cellGrpCfg.rlc_BearerToAddModList) != ROK)
5542       {
5543          DU_LOG("\nERROR  -->  F1AP : BuildRlcBearerToAddModList failed");
5544          ret = RFAILED;
5545          break;
5546       }
5547
5548       cellGrpCfg.rlc_BearerToReleaseList = NULLP;
5549       cellGrpCfg.mac_CellGroupConfig = NULLP;
5550       DU_ALLOC(cellGrpCfg.mac_CellGroupConfig, sizeof(MAC_CellGroupConfig_t));
5551       if(!cellGrpCfg.mac_CellGroupConfig)
5552       {
5553          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildDuToCuRrcContainer");
5554          ret = RFAILED;
5555          break;
5556       }
5557       if(BuildMacCellGrpCfg(cellGrpCfg.mac_CellGroupConfig) != ROK)
5558       {
5559          DU_LOG("\nERROR  -->  F1AP : BuildMacCellGrpCfg failed");
5560          ret = RFAILED;
5561          break;
5562       }
5563
5564       cellGrpCfg.physicalCellGroupConfig = NULLP;
5565       DU_ALLOC(cellGrpCfg.physicalCellGroupConfig, sizeof(PhysicalCellGroupConfig_t));
5566       if(!cellGrpCfg.physicalCellGroupConfig)
5567       {
5568          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildDuToCuRrcContainer");
5569          ret = RFAILED;
5570          break;
5571       }
5572       if(BuildPhyCellGrpCfg(cellGrpCfg.physicalCellGroupConfig) != ROK)
5573       {
5574          DU_LOG("\nERROR  -->  F1AP : BuildPhyCellGrpCfg failed");
5575          ret = RFAILED;
5576          break;
5577       }
5578
5579       cellGrpCfg.spCellConfig = NULLP;
5580       DU_ALLOC(cellGrpCfg.spCellConfig, sizeof(SpCellConfig_t));
5581       if(!cellGrpCfg.spCellConfig)
5582       {
5583          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildDuToCuRrcContainer");
5584          ret = RFAILED;
5585          break;
5586       }
5587       if(BuildSpCellCfg(cellGrpCfg.spCellConfig) != ROK)
5588       {
5589          DU_LOG("\nERROR  -->  F1AP : BuildSpCellCfg failed");
5590          ret = RFAILED;
5591          break;
5592       }
5593
5594       cellGrpCfg.sCellToAddModList = NULLP;
5595       cellGrpCfg.sCellToReleaseList = NULLP;
5596       cellGrpCfg.ext1 = NULLP;
5597
5598       /* encode cellGrpCfg into duToCuRrcContainer */
5599       xer_fprint(stdout, &asn_DEF_CellGroupConfigRrc, &cellGrpCfg);
5600       memset(encBuf, 0, ENC_BUF_MAX_LEN);
5601       encBufSize = 0;
5602       encRetVal = aper_encode(&asn_DEF_CellGroupConfigRrc, 0, &cellGrpCfg, PrepFinalEncBuf, encBuf);
5603       /* Encode results */
5604       if(encRetVal.encoded == ENCODE_FAIL)
5605       {
5606          DU_LOG( "\nERROR  --> F1AP : Could not encode DuToCuRrcContainer (at %s)\n",\
5607                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
5608          ret = RFAILED;
5609          break;
5610       }
5611       else
5612       {
5613          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for DuToCuRrcContainer\n");
5614          for(int i=0; i< encBufSize; i++)
5615          {
5616             printf("%x",encBuf[i]);
5617          }
5618       }
5619
5620       duToCuRrcContainer->size = encBufSize;
5621       DU_ALLOC(duToCuRrcContainer->buf, duToCuRrcContainer->size);
5622       if(!duToCuRrcContainer->buf)
5623       {
5624          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDuToCuRrcContainer");
5625          ret = RFAILED;
5626          break;
5627       }
5628       if(ret == ROK)
5629       {
5630          memcpy(duToCuRrcContainer->buf, encBuf, duToCuRrcContainer->size);
5631       }
5632       break;
5633    }
5634    FreeMemDuToCuRrcCont(&cellGrpCfg);
5635    return ret;
5636 }
5637
5638 /*******************************************************************
5639  *
5640  * @brief Free memory allocated in InitialULRRCMessage
5641  *
5642  * @details
5643  *
5644  *    Function : freeInitUlRrcMsgTransfer
5645  *
5646  *    Functionality: Free memory allocated in InitialULRRCMessage
5647  *
5648  * @params[in]F1AP_PDU_t  *f1apMsg)
5649  *
5650  * @return ROK     - success
5651  *         RFAILED - failure
5652  *
5653  * ****************************************************************/
5654
5655 uint8_t freeInitUlRrcMsgTransfer(F1AP_PDU_t  *f1apMsg)
5656 {
5657    uint8_t ieIdx, arrIdx;
5658    InitialULRRCMessageTransfer_t *initULRRCMsg=NULLP;
5659
5660    if(f1apMsg)
5661    {
5662       if(f1apMsg->choice.initiatingMessage)
5663       {
5664          initULRRCMsg = &f1apMsg->choice.initiatingMessage->value.\
5665             choice.InitialULRRCMessageTransfer;
5666          if(initULRRCMsg->protocolIEs.list.array)
5667          {
5668             for(ieIdx = 0; ieIdx < initULRRCMsg->protocolIEs.list.count; ieIdx++)
5669             {
5670                switch(initULRRCMsg->protocolIEs.list.array[ieIdx]->id)
5671                {
5672                   case ProtocolIE_ID_id_NRCGI:
5673                   {
5674                      if(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.pLMN_Identity.buf)
5675                      {
5676                         if(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.nRCellIdentity.buf)
5677                         {
5678                            DU_FREE(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.nRCellIdentity.buf,\
5679                            initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.nRCellIdentity.size);
5680                         }
5681                         DU_FREE(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.pLMN_Identity.buf,\
5682                         initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.pLMN_Identity.size);
5683                      }
5684                      break;
5685                   }
5686                   case ProtocolIE_ID_id_RRCContainer:
5687                   {
5688                      if(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf)
5689                      {
5690                         DU_FREE(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf,\
5691                         initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.size);
5692                      }
5693                      break;
5694                   }
5695                   case ProtocolIE_ID_id_DUtoCURRCContainer:
5696                   {
5697                      if(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.DUtoCURRCContainer.buf)
5698                      {
5699                         DU_FREE(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.DUtoCURRCContainer.buf,
5700                         initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.DUtoCURRCContainer.size);
5701                      }
5702                      break;
5703                   }
5704                   default:
5705                      break;
5706                }
5707              }
5708              for(arrIdx = 0; arrIdx < ieIdx; arrIdx++)
5709              {
5710                 if(initULRRCMsg->protocolIEs.list.array[arrIdx])
5711                 {
5712                    DU_FREE(initULRRCMsg->protocolIEs.list.array[arrIdx],\
5713                       sizeof(InitialULRRCMessageTransferIEs_t));
5714                 }
5715              }
5716              DU_FREE(initULRRCMsg->protocolIEs.list.array, initULRRCMsg->protocolIEs.list.size);
5717           }
5718          DU_FREE(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
5719       }
5720       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
5721    }
5722    else
5723    {
5724       DU_LOG("\nERROR  -->  DU_APP : Recevied F1ap Pdu is null at freeInitUlRrcMsgTransfer()");
5725       return RFAILED;
5726    }
5727    return ROK;
5728 }
5729
5730 /*******************************************************************
5731  *
5732  * @brief Builds and sends the InitialULRRCMessage
5733  *
5734  * @details
5735  *
5736  *    Function : BuildAndSendInitialRrcMsgTransfer
5737  *
5738  *    Functionality: Constructs the Initial UL RRC Message Transfer and sends
5739  *                   it to the CU through SCTP.
5740  *
5741  * @params[in]
5742  *
5743  * @return ROK     - success
5744  *         RFAILED - failure
5745  *
5746  * ****************************************************************/
5747 uint8_t BuildAndSendInitialRrcMsgTransfer(uint32_t gnbDuUeF1apId, uint16_t crnti,
5748       uint16_t rrcContSize, uint8_t *rrcContainer)
5749 {
5750    uint8_t   ret;
5751    uint8_t   elementCnt;
5752    uint8_t   ieIdx;
5753    asn_enc_rval_t  encRetVal;
5754    F1AP_PDU_t  *f1apMsg = NULLP;
5755    InitialULRRCMessageTransfer_t *initULRRCMsg = NULLP;
5756    memset(&encRetVal, 0, sizeof(asn_enc_rval_t));
5757
5758    while(true)
5759    {
5760       DU_LOG("\n INFO   -->  F1AP : Building RRC Setup Request\n");
5761       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
5762       if(f1apMsg == NULLP)
5763       {
5764          DU_LOG(" ERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
5765          break;
5766       }
5767       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
5768       DU_ALLOC(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
5769       if(f1apMsg->choice.initiatingMessage == NULLP)
5770       {
5771          DU_LOG(" ERROR  -->  F1AP : Memory allocation for  F1AP-PDU failed");
5772          break;
5773       }
5774       f1apMsg->choice.initiatingMessage->procedureCode =\
5775                                                         ProcedureCode_id_InitialULRRCMessageTransfer;
5776       f1apMsg->choice.initiatingMessage->criticality = Criticality_ignore;
5777       f1apMsg->choice.initiatingMessage->value.present = \
5778                                                          InitiatingMessage__value_PR_InitialULRRCMessageTransfer;
5779       initULRRCMsg =\
5780                     &f1apMsg->choice.initiatingMessage->value.choice.InitialULRRCMessageTransfer;
5781       elementCnt = 5;
5782       initULRRCMsg->protocolIEs.list.count = elementCnt;
5783       initULRRCMsg->protocolIEs.list.size = \
5784                                             elementCnt * sizeof(InitialULRRCMessageTransferIEs_t *);
5785       /* Initialize the F1Setup members */
5786       DU_ALLOC(initULRRCMsg->protocolIEs.list.array,initULRRCMsg->protocolIEs.list.size);
5787       if(initULRRCMsg->protocolIEs.list.array == NULLP)
5788       {
5789          DU_LOG(" ERROR  -->  F1AP : Memory allocation for\
5790                RRCSetupRequestMessageTransferIEs failed");
5791          break;
5792       }
5793       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
5794       {
5795          DU_ALLOC(initULRRCMsg->protocolIEs.list.array[ieIdx],\
5796                sizeof(InitialULRRCMessageTransferIEs_t));
5797          if(initULRRCMsg->protocolIEs.list.array[ieIdx] == NULLP)
5798          {
5799             break;
5800          }
5801       }
5802       ieIdx = 0;
5803       /*GNB DU UE F1AP ID*/
5804       initULRRCMsg->protocolIEs.list.array[ieIdx]->id  = \
5805                                                         ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
5806       initULRRCMsg->protocolIEs.list.array[ieIdx]->criticality  = Criticality_reject;
5807       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.present = \
5808                                                                   InitialULRRCMessageTransferIEs__value_PR_GNB_DU_UE_F1AP_ID;
5809       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID = gnbDuUeF1apId;
5810
5811
5812       /*NRCGI*/
5813       ieIdx++;
5814       initULRRCMsg->protocolIEs.list.array[ieIdx]->id  = \
5815                                                         ProtocolIE_ID_id_NRCGI;
5816       initULRRCMsg->protocolIEs.list.array[ieIdx]->criticality  =Criticality_reject;
5817       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.present = \
5818                                                                   InitialULRRCMessageTransferIEs__value_PR_NRCGI;
5819
5820       ret =\
5821            BuildNrcgi(&initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI);
5822       if(ret!=ROK)
5823       {
5824          break;
5825       }
5826
5827       /*CRNTI*/
5828       ieIdx++;
5829       initULRRCMsg->protocolIEs.list.array[ieIdx]->id  = \
5830                                                         ProtocolIE_ID_id_C_RNTI;
5831       initULRRCMsg->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
5832       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.present =\
5833                                                                  InitialULRRCMessageTransferIEs__value_PR_C_RNTI;
5834       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.C_RNTI = crnti;
5835
5836       /*RRCContainer*/
5837       ieIdx++;
5838       initULRRCMsg->protocolIEs.list.array[ieIdx]->id  = \
5839                                                         ProtocolIE_ID_id_RRCContainer;
5840       initULRRCMsg->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
5841       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.present =\
5842                                                                  InitialULRRCMessageTransferIEs__value_PR_RRCContainer;
5843
5844       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.size = rrcContSize;
5845       DU_ALLOC(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf,
5846             initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.size)
5847       if(!initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf)
5848       {
5849          DU_LOG(" ERROR  -->  F1AP : Memory allocation for RRCSetupRequestMessageTransferIEs failed");
5850          break;
5851
5852       }
5853       memcpy(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf, rrcContainer,
5854             initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.size);
5855
5856
5857       /*DUtoCURRCContainer*/
5858       ieIdx++;
5859       initULRRCMsg->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_DUtoCURRCContainer;
5860       initULRRCMsg->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
5861       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.present =\
5862                                                                  InitialULRRCMessageTransferIEs__value_PR_DUtoCURRCContainer;
5863
5864       ret = BuildDuToCuRrcContainer(&initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.DUtoCURRCContainer);
5865       if(ret != ROK)
5866       {
5867          break;
5868       }
5869
5870       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
5871
5872       /* Encode the F1SetupRequest type as APER */
5873       memset(encBuf, 0, ENC_BUF_MAX_LEN);
5874       encBufSize = 0;
5875       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
5876       /* Encode results */
5877       if(encRetVal.encoded == ENCODE_FAIL)
5878       {
5879          DU_LOG( "\nERROR  --> F1AP : Could not encode Initial UL RRC Message Transfer\
5880                structure (at %s)\n",encRetVal.failed_type ? \
5881                encRetVal.failed_type->name : "unknown");
5882          ret = RFAILED;
5883          break;
5884       }
5885       else
5886       {
5887
5888          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for Initial UL RRC\
5889                Message transfer\n");
5890          for(int i=0; i< encBufSize; i++)
5891          {
5892             printf("%x",encBuf[i]);
5893          }
5894       }
5895       /* Sending  msg  */
5896       if(SendF1APMsg(DU_APP_MEM_REGION,DU_POOL) != ROK)
5897       {
5898          DU_LOG("\nERROR  -->  F1AP : Sending Initial UL RRC Message Transfer Failed");
5899          ret = RFAILED;
5900          break;
5901       }
5902       break;
5903    }
5904    freeInitUlRrcMsgTransfer(f1apMsg);
5905    return ret;
5906 }/* End of BuildAndSendInitialRrcMsgTransfer*/
5907
5908 /*****  UE SETUP REQUEST *****/
5909
5910 /*******************************************************************
5911  *
5912  * @brief Free Qos And Snssai Drb Info
5913  *
5914  * @details
5915  *
5916  *    Function : freeDrbQosAndSnssaiInfo
5917  *
5918  *    Functionality: Free Qos And Snssai Drb Info
5919  *
5920  * @params[in] LcCfg *lcCfg,
5921  * @return void
5922  *
5923  * ****************************************************************/
5924 void freeDrbQosAndSnssaiInfo(LcCfg *lcCfg)
5925 {
5926    if(lcCfg->snssai)
5927    {
5928       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->snssai, sizeof(Snssai));
5929    }
5930    if(lcCfg->drbQos)
5931    {
5932       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->drbQos, sizeof(DrbQosInfo));
5933    }
5934 }
5935
5936 /******************************************************************
5937 *
5938 * @brief Function to delete the RLC Lc cfg from UE APP DB
5939 *
5940 * @details
5941 *
5942 *  Function : freeRlcLcCfg
5943 *
5944 *  Functionality: Function to delete the RLC Lc cfg from UE APP DB
5945 *
5946 *
5947  *****************************************************************/
5948
5949 void freeRlcLcCfg(RlcBearerCfg *lcCfg)
5950 {
5951    switch(lcCfg->rlcMode)
5952    {
5953       case RLC_AM :
5954       {
5955          if(lcCfg->u.amCfg)
5956          {
5957             DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->u.amCfg, sizeof(AmBearerCfg));
5958             lcCfg->u.amCfg = NULLP;
5959          }
5960          break;
5961       }
5962       case RLC_UM_BI_DIRECTIONAL :
5963       {
5964          if(lcCfg->u.umBiDirCfg)
5965          {
5966             DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->u.umBiDirCfg, sizeof(UmBiDirBearerCfg));
5967             lcCfg->u.umBiDirCfg = NULLP;
5968          }
5969          break;
5970       }
5971       case RLC_UM_UNI_DIRECTIONAL_UL :
5972       {
5973          if(lcCfg->u.umUniDirUlCfg)
5974          {
5975             DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->u.umUniDirUlCfg, sizeof(UmUniDirUlBearerCfg));
5976             lcCfg->u.umUniDirUlCfg = NULLP;
5977          }
5978          break;
5979
5980       }
5981       case RLC_UM_UNI_DIRECTIONAL_DL :
5982       {
5983          if(lcCfg->u.umUniDirDlCfg)
5984          {
5985             DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->u.umUniDirDlCfg, sizeof(UmUniDirDlBearerCfg));
5986             lcCfg->u.umUniDirDlCfg = NULLP;
5987          }
5988          break;
5989       }
5990       default:
5991          DU_LOG("\nERROR  -->  DU_APP: Invalid Rlc Mode %d at freeRlcLcCfg()", lcCfg->rlcMode);
5992          break;
5993    }
5994    memset(lcCfg, 0, sizeof(LcCfg));
5995 }
5996 /*******************************************************************
5997  *
5998  * @brief Function to free MacLcCfg
5999  *
6000  * @details
6001  *
6002  *    Function : freeMacLcCfg
6003  *
6004  *    Functionality: Function to free MacLcCfg
6005  *
6006  * @params[in] LcCfg *lcCfg,
6007  * @return void
6008  *
6009  * ****************************************************************/
6010
6011 void  freeMacLcCfg(LcCfg *lcCfg)
6012 {
6013     /* Deleting DRBQOS */
6014    if(lcCfg->drbQos)
6015    {
6016       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->drbQos, sizeof(DrbQosInfo));
6017       lcCfg->drbQos = NULLP;
6018    }
6019    /* Deleting SNSSAI */
6020    if(lcCfg->snssai)
6021    {
6022       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->snssai, sizeof(Snssai));
6023       lcCfg->snssai = NULLP;
6024    }
6025    memset(lcCfg, 0, sizeof(LcCfg));
6026 }
6027 /*******************************************************************
6028  *
6029  * @brief Free UE NR Capability received in UE Context setup request
6030  *
6031  * @details
6032  *
6033  *    Function : freeAperDecodeUeNrCapability
6034  *
6035  *    Functionality:
6036  *       Free UE NR Capability received in UE Context setup request
6037  *
6038  * @params[in]
6039  * @return ROK     - success
6040  *         RFAILED - failure
6041  *
6042  * ****************************************************************/
6043 void freeAperDecodeUeNrCapability(void *ueNrCapability)
6044 {
6045    uint8_t arrIdx =0;
6046    FeatureSets_t *featureSets =NULLP;
6047    UE_NR_Capability_t *ueNrCap = (UE_NR_Capability_t *)ueNrCapability;
6048
6049    if(ueNrCap->rf_Parameters.supportedBandListNR.list.array)
6050    {
6051       for(arrIdx = 0; arrIdx < ueNrCap->rf_Parameters.supportedBandListNR.list.count; arrIdx++)
6052       {
6053          if(ueNrCap->rf_Parameters.supportedBandListNR.list.array[arrIdx])
6054             free(ueNrCap->rf_Parameters.supportedBandListNR.list.array[arrIdx]);
6055       }
6056       free(ueNrCap->rf_Parameters.supportedBandListNR.list.array);
6057    }
6058
6059    if(ueNrCap->featureSets)
6060    {
6061       featureSets = ueNrCap->featureSets;
6062       if(featureSets->featureSetsDownlinkPerCC)
6063       {
6064          if(featureSets->featureSetsDownlinkPerCC->list.array)
6065          {
6066             for(arrIdx = 0; arrIdx < featureSets->featureSetsDownlinkPerCC->list.count; arrIdx++)
6067             {
6068                if(featureSets->featureSetsDownlinkPerCC->list.array[arrIdx])
6069                {
6070                   if(featureSets->featureSetsDownlinkPerCC->list.array[arrIdx]->supportedModulationOrderDL)
6071                      free(featureSets->featureSetsDownlinkPerCC->list.array[arrIdx]->supportedModulationOrderDL);
6072                   free(featureSets->featureSetsDownlinkPerCC->list.array[arrIdx]);
6073                }
6074             }
6075             free(featureSets->featureSetsDownlinkPerCC->list.array);
6076          }
6077          free(featureSets->featureSetsDownlinkPerCC);
6078       }
6079       if(featureSets->featureSetsUplinkPerCC)
6080       {
6081          if(featureSets->featureSetsUplinkPerCC->list.array)
6082          {
6083             for(arrIdx = 0; arrIdx < featureSets->featureSetsUplinkPerCC->list.count; arrIdx++)
6084             {
6085                if(featureSets->featureSetsUplinkPerCC->list.array[arrIdx])
6086                {
6087                   if(featureSets->featureSetsUplinkPerCC->list.array[arrIdx]->supportedModulationOrderUL)
6088                      free(featureSets->featureSetsUplinkPerCC->list.array[arrIdx]->supportedModulationOrderUL);
6089                   free(featureSets->featureSetsUplinkPerCC->list.array[arrIdx]);
6090                }
6091             }
6092             free(featureSets->featureSetsUplinkPerCC->list.array);
6093          }
6094          free(featureSets->featureSetsUplinkPerCC);
6095       }
6096       free(ueNrCap->featureSets);
6097    }
6098 }
6099
6100 /*******************************************************************
6101 *
6102 * @brief Function to free PdcchSearchSpcToAddModList
6103          where memory allocated by aper_decoder
6104 *
6105 * @details
6106 *
6107 *    Function : freeAperDecodePdcchSearchSpcToAddModList
6108 *
6109 *    Functionality: Function to free PdcchSearchSpcToAddModList
6110 *
6111 * @params[in] struct PDCCH_Config__searchSpacesToAddModList *searchSpcList
6112 * @return void
6113 *
6114 * ****************************************************************/
6115
6116 void freeAperDecodePdcchSearchSpcToAddModList(struct PDCCH_Config__searchSpacesToAddModList *searchSpcList)
6117 {
6118    uint8_t searchSpcArrIdx=0;
6119    uint8_t searchSpcArrIdx1=0;
6120    struct  SearchSpace *searchSpc=NULLP;
6121
6122
6123    if(searchSpcList->list.array)
6124    {
6125       if(searchSpcList->list.array[searchSpcArrIdx1])
6126       {
6127          searchSpc = searchSpcList->list.array[searchSpcArrIdx1];
6128          if(searchSpc->controlResourceSetId)
6129          {
6130             if(searchSpc->monitoringSlotPeriodicityAndOffset)
6131             {
6132                if(searchSpc->monitoringSymbolsWithinSlot)
6133                {
6134                   if(searchSpc->monitoringSymbolsWithinSlot->buf)
6135                   {
6136                      if(searchSpc->nrofCandidates)
6137                      {
6138                         if(searchSpc->searchSpaceType)
6139                         {
6140                            free(searchSpc->searchSpaceType->choice.ue_Specific);
6141                            free(searchSpc->searchSpaceType);
6142                         }
6143                         free(searchSpc->nrofCandidates);
6144                      }
6145                      free(searchSpc->monitoringSymbolsWithinSlot->buf);
6146                   }
6147                   free(searchSpc->monitoringSymbolsWithinSlot);
6148                }
6149                free(searchSpc->monitoringSlotPeriodicityAndOffset);
6150             }
6151             free(searchSpc->controlResourceSetId);
6152          }
6153       }
6154       for(searchSpcArrIdx = 0; searchSpcArrIdx < searchSpcList->list.count; searchSpcArrIdx++)
6155       {
6156          free(searchSpcList->list.array[searchSpcArrIdx]);
6157       }
6158       free(searchSpcList->list.array);
6159    }
6160 }
6161 /*******************************************************************
6162 *
6163 * @brief Function for free part for the memory allocated by aper_decoder
6164 *
6165 * @details
6166 *
6167 *    Function : freeAperDecodeBWPDlDedPdcchConfig
6168 *
6169 *    Functionality: Function to free BWPDlDedPdcchConfig
6170 *
6171 * @params[in]
6172 * @return void
6173 *
6174 * ****************************************************************/
6175
6176
6177 void freeAperDecodeBWPDlDedPdcchConfig(BWP_DownlinkDedicated_t *dlBwp)
6178 {
6179    uint8_t arrIdx1=0;
6180    uint8_t arrIdx2=0;
6181    struct PDCCH_Config *pdcchCfg=NULLP;
6182    struct ControlResourceSet *controlRSet=NULLP;
6183    struct PDCCH_Config__controlResourceSetToAddModList *controlRSetList=NULLP;
6184
6185    if(dlBwp->pdcch_Config->choice.setup)
6186    {
6187       pdcchCfg=dlBwp->pdcch_Config->choice.setup;
6188       if(pdcchCfg->controlResourceSetToAddModList)
6189       {
6190          controlRSetList = pdcchCfg->controlResourceSetToAddModList;
6191          if(controlRSetList->list.array)
6192          {
6193             controlRSet = controlRSetList->list.array[arrIdx2];
6194             if(controlRSet)
6195             {
6196                if(controlRSet->frequencyDomainResources.buf)
6197                {
6198                   if(controlRSet->pdcch_DMRS_ScramblingID)
6199                   {
6200                      if(pdcchCfg->searchSpacesToAddModList)
6201                      {
6202                         freeAperDecodePdcchSearchSpcToAddModList(pdcchCfg->searchSpacesToAddModList);
6203                         free(pdcchCfg->searchSpacesToAddModList);
6204                      }
6205                      free(controlRSet->pdcch_DMRS_ScramblingID);
6206                   }
6207                   free(controlRSet->frequencyDomainResources.buf);
6208                }
6209             }
6210             for(arrIdx1 = 0; arrIdx1 <controlRSetList->list.count; arrIdx1++)
6211             {
6212                free(controlRSetList->list.array[arrIdx1]);
6213             }
6214             free(controlRSetList->list.array);
6215          }
6216          free(pdcchCfg->controlResourceSetToAddModList);
6217       }
6218       free(dlBwp->pdcch_Config->choice.setup);
6219    }
6220 }
6221 /*******************************************************************
6222 *
6223 * @brief Function to free PdschTimeDomAllocationList
6224 *     where the memory allocated by aper_decoder
6225 *
6226 * @details
6227 *
6228 *    Function : freeAperDecodePdschTimeDomAllocationList
6229 *
6230 *    Functionality: Function to free PdschTimeDomAllocationList
6231 *
6232 * @params[in] struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList
6233 * @return void
6234 *
6235 * ****************************************************************/
6236
6237
6238 void freeAperDecodePdschTimeDomAllocationList( struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList)
6239 {
6240    uint8_t arrIdx=0;
6241
6242    if(timeDomAllocList->choice.setup)
6243    {
6244       if(timeDomAllocList->choice.setup->list.array)
6245       {
6246          for(arrIdx = 0; arrIdx <timeDomAllocList->choice.setup->list.count ; arrIdx++)
6247          {
6248             free(timeDomAllocList->choice.setup->list.array[arrIdx]);
6249          }
6250          free(timeDomAllocList->choice.setup->list.array);
6251       }
6252       free(timeDomAllocList->choice.setup);
6253    }
6254 }
6255
6256 /*******************************************************************
6257 *
6258 * @brief Function to free BWPDlDedPdschConfig
6259 *        where the memory allocated by aper_decoder
6260 *
6261 * @details
6262 *
6263 *    Function : freeAperDecodeBWPDlDedPdschConfig
6264 *
6265 *    Functionality: Function to free BWPDlDedPdschConfig
6266 *
6267 * @params[in] BWP_DownlinkDedicated_t *dlBwp
6268 * @return void
6269 *
6270 * ****************************************************************/
6271
6272
6273 void freeAperDecodeBWPDlDedPdschConfig(BWP_DownlinkDedicated_t *dlBwp)
6274 {
6275    struct PDSCH_Config *pdschCfg=NULLP;
6276    struct PDSCH_Config__prb_BundlingType *prbBndlType=NULLP;
6277    struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList=NULLP;
6278    struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA *dmrsDlCfg=NULLP;
6279
6280    if(dlBwp->pdsch_Config->choice.setup)
6281    {
6282       pdschCfg=dlBwp->pdsch_Config->choice.setup;
6283       if(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA)
6284       {
6285          if(pdschCfg->pdsch_TimeDomainAllocationList)
6286          {
6287             timeDomAllocList=pdschCfg->pdsch_TimeDomainAllocationList;
6288             if(pdschCfg->maxNrofCodeWordsScheduledByDCI)
6289             {
6290                prbBndlType=&pdschCfg->prb_BundlingType;
6291                free(prbBndlType->choice.staticBundling);
6292                free(pdschCfg->maxNrofCodeWordsScheduledByDCI);
6293             }
6294             freeAperDecodePdschTimeDomAllocationList(timeDomAllocList);
6295             free(pdschCfg->pdsch_TimeDomainAllocationList);
6296          }
6297          dmrsDlCfg=pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA;
6298          if(dmrsDlCfg->choice.setup)
6299          {
6300             free(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition);
6301             free(dmrsDlCfg->choice.setup);
6302          }
6303          free(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA);
6304       }
6305       free(dlBwp->pdsch_Config->choice.setup);
6306    }
6307 }
6308 /*******************************************************************
6309 *
6310 * @brief Function to free PuschTimeDomAllocListCfg
6311                  where the memory allocated by aper_decoder
6312 *
6313 * @details
6314 *
6315 *    Function : freeAperDecodePuschTimeDomAllocListCfg
6316 *
6317 *    Functionality: Function to free PuschTimeDomAllocListCfg
6318 *
6319 * @params[in] PUSCH_Config_t *puschCfg
6320 * @return void
6321 *
6322 * ****************************************************************/
6323
6324
6325 void freeAperDecodePuschTimeDomAllocListCfg(PUSCH_Config_t *puschCfg)
6326 {
6327    uint8_t arrIdx=0;
6328    uint8_t arrIdx1=0;
6329    struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList_t=NULLP;
6330
6331    if(puschCfg->pusch_TimeDomainAllocationList)
6332    {
6333       timeDomAllocList_t=puschCfg->pusch_TimeDomainAllocationList;
6334       if(timeDomAllocList_t->choice.setup)
6335       {
6336          if(timeDomAllocList_t->choice.setup->list.array)
6337          {
6338             free(timeDomAllocList_t->choice.setup->list.array[arrIdx1]->k2);
6339             for(arrIdx = 0; arrIdx<timeDomAllocList_t->choice.setup->list.count; arrIdx++)
6340             {
6341                free(timeDomAllocList_t->choice.setup->list.array[arrIdx]);
6342             }
6343             free(timeDomAllocList_t->choice.setup->list.array);
6344          }
6345          free(timeDomAllocList_t->choice.setup);
6346       }
6347       free(puschCfg->transformPrecoder);
6348       free(puschCfg->pusch_TimeDomainAllocationList);
6349    }
6350 }
6351 /*******************************************************************
6352 *
6353 * @brief Function to free InitialUlBWPConfig where memory allocated by aper_decoder
6354 *
6355 * @details
6356 *
6357 *    Function : freeAperDecodeInitialUlBWPConfig
6358 *
6359 *    Functionality: Function to free InitialUlBWPConfig
6360 *
6361 * @params[in]  BWP_UplinkDedicated_t *ulBwp
6362 * @return void
6363 *
6364 * ****************************************************************/
6365
6366
6367 void freeAperDecodeInitialUlBWPConfig(BWP_UplinkDedicated_t *ulBwp)
6368 {
6369    uint8_t  rSetIdx =0;
6370    uint8_t  rsrcIdx =0;
6371    SRS_Config_t   *srsCfg = NULLP;
6372    PUSCH_Config_t *puschCfg = NULLP;
6373    struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA *dmrsUlCfg = NULLP;
6374    struct SRS_Config__srs_ResourceSetToAddModList *rsrcSetList = NULLP;
6375    struct SRS_ResourceSet__srs_ResourceIdList *rsrcIdList = NULLP;
6376    struct SRS_Config__srs_ResourceToAddModList *resourceList = NULLP;
6377
6378    if(ulBwp->pusch_Config)
6379    {
6380       if(ulBwp->pusch_Config->choice.setup)
6381       {
6382          puschCfg=ulBwp->pusch_Config->choice.setup;
6383          if(puschCfg->dataScramblingIdentityPUSCH)
6384          {
6385             if(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA)
6386             {
6387                freeAperDecodePuschTimeDomAllocListCfg(puschCfg);
6388                dmrsUlCfg=puschCfg->dmrs_UplinkForPUSCH_MappingTypeA;
6389                if(dmrsUlCfg->choice.setup)
6390                {
6391                   if(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition)
6392                   {
6393                      if(dmrsUlCfg->choice.setup->transformPrecodingDisabled)
6394                      {
6395                         free(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0);
6396                         free(dmrsUlCfg->choice.setup->transformPrecodingDisabled);
6397                      }
6398                      free(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition);
6399                   }
6400                   free(dmrsUlCfg->choice.setup);
6401                }
6402                free(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA);
6403             }
6404             free(puschCfg->dataScramblingIdentityPUSCH);
6405          }
6406          free(ulBwp->pusch_Config->choice.setup);
6407       }
6408       free(ulBwp->pusch_Config);
6409
6410       /* Free SRS-Config */
6411       if(ulBwp->srs_Config)
6412       {
6413          if(ulBwp->srs_Config->choice.setup)
6414          {
6415             srsCfg = ulBwp->srs_Config->choice.setup;
6416
6417             /* Free Resource Set to add/mod list */
6418             if(srsCfg->srs_ResourceSetToAddModList)
6419             {
6420                rsrcSetList = srsCfg->srs_ResourceSetToAddModList;
6421                if(rsrcSetList->list.array)
6422                {
6423                   rSetIdx = 0;
6424
6425                   /* Free SRS resource Id list in this SRS resource set */
6426                   if(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList)
6427                   {
6428                      rsrcIdList =
6429                         rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList;
6430
6431                      if(rsrcIdList->list.array)
6432                      {
6433                         for(rsrcIdx = 0; rsrcIdx < rsrcIdList->list.count;
6434                               rsrcIdx++)
6435                         {
6436                            free(rsrcIdList->list.array[rsrcIdx]);
6437                         }
6438                         free(rsrcIdList->list.array);
6439                      }
6440                      free(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList);
6441                   }
6442
6443                   /* Free resource type info for this SRS resource set */
6444
6445                   free(rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic);
6446
6447                   /* Free memory for each resource set */
6448                   for(rSetIdx = 0; rSetIdx < rsrcSetList->list.count; rSetIdx++)
6449                   {
6450                      free(rsrcSetList->list.array[rSetIdx]);
6451                   }
6452                   free(rsrcSetList->list.array);
6453                }
6454                free(srsCfg->srs_ResourceSetToAddModList);
6455             }
6456
6457             /* Free resource to add/modd list */
6458             if(srsCfg->srs_ResourceToAddModList)
6459             {
6460                resourceList = srsCfg->srs_ResourceToAddModList;
6461                if(resourceList->list.array)
6462                {
6463                   rsrcIdx = 0;
6464
6465                   free(resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2);
6466                   free(resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic);
6467
6468                   for(rsrcIdx = 0; rsrcIdx < resourceList->list.count; rsrcIdx++)
6469                   {
6470                      free(resourceList->list.array[rsrcIdx]);
6471                   }
6472                   free(resourceList->list.array);
6473                }
6474                free(srsCfg->srs_ResourceToAddModList);
6475             }
6476
6477             free(ulBwp->srs_Config->choice.setup);
6478          }
6479          free(ulBwp->srs_Config);
6480       }
6481    }
6482 }
6483 /*******************************************************************
6484 *
6485 * @brief Function to free initialUplinkBWPConfig where memory allocated by aper_decoder
6486 *
6487 * @details
6488 *
6489 *    Function : freeAperDecodeinitialUplinkBWPConfig
6490 *
6491 *    Functionality: Function to free initialUplinkBWPConfig
6492 *
6493 * @params[in] UplinkConfig_t *ulCfg
6494 * @return void
6495 *
6496 * ****************************************************************/
6497
6498
6499 void freeAperDecodeinitialUplinkBWPConfig(UplinkConfig_t *ulCfg)
6500 {
6501    BWP_UplinkDedicated_t *ulBwp=NULLP;
6502    struct UplinkConfig__pusch_ServingCellConfig *puschCfg=NULLP;
6503
6504    if(ulCfg->initialUplinkBWP)
6505    {
6506       ulBwp=ulCfg->initialUplinkBWP;
6507       if(ulCfg->firstActiveUplinkBWP_Id)
6508       {
6509          if(ulCfg->pusch_ServingCellConfig)
6510          {
6511             puschCfg=ulCfg->pusch_ServingCellConfig;
6512             if(puschCfg->choice.setup)
6513             {
6514                if(puschCfg->choice.setup->ext1)
6515                {
6516                   free(puschCfg->choice.setup->ext1->processingType2Enabled);
6517                   free(puschCfg->choice.setup->ext1->maxMIMO_Layers);
6518                   free(puschCfg->choice.setup->ext1);
6519                }
6520                free(puschCfg->choice.setup);
6521             }
6522             free(ulCfg->pusch_ServingCellConfig);
6523          }
6524          free(ulCfg->firstActiveUplinkBWP_Id);
6525       }
6526       freeAperDecodeInitialUlBWPConfig(ulBwp);
6527       free(ulCfg->initialUplinkBWP);
6528    }
6529 }
6530
6531 /*******************************************************************
6532  *
6533  * @brief Function to free DuUeCfg
6534  *
6535  * @details
6536  *
6537  *    Function : freeDuUeCfg
6538  *
6539  *    Functionality: Function to free DuUeCfg
6540  *
6541  * @params[in] DuUeCfg *ueCfg
6542  * @return void
6543  *
6544  * ****************************************************************/
6545 void freeDuUeCfg(DuUeCfg *ueCfg)
6546 {
6547    uint8_t lcIdx = 0;
6548    uint8_t arrIdx = 0;
6549    SpCellConfig_t *spCellCfg = NULLP;
6550    ServingCellConfig_t *srvCellCfg = NULLP;
6551    BWP_DownlinkDedicated_t *dlBwp = NULLP;
6552    MAC_CellGroupConfig_t *macCellGrpCfg = NULLP;
6553    PhysicalCellGroupConfig_t *phyCellGrpCfg = NULLP;
6554    struct CellGroupConfigRrc__rlc_BearerToAddModList *rlcBearerList = NULLP;
6555    struct RLC_Config *rlcConfig = NULLP;
6556    struct LogicalChannelConfig *macLcConfig = NULLP;
6557    struct SchedulingRequestConfig *schedulingRequestConfig = NULLP;
6558    struct SchedulingRequestConfig__schedulingRequestToAddModList *schReqList = NULLP;
6559    struct TAG_Config *tagConfig = NULLP;
6560    struct TAG_Config__tag_ToAddModList *tagList = NULLP;
6561    struct MAC_CellGroupConfig__phr_Config *phrConfig = NULLP;
6562    struct ServingCellConfig__pdsch_ServingCellConfig *pdschCfg = NULLP;
6563    CellGroupConfigRrc_t *cellGrpCfg = ueCfg->cellGrpCfg;
6564
6565    if(ueCfg->ueNrCapability)
6566    {
6567       freeAperDecodeUeNrCapability(ueCfg->ueNrCapability);
6568       DU_FREE(ueCfg->ueNrCapability, sizeof(UE_NR_Capability_t));
6569       ueCfg->ueNrCapability = NULLP;
6570    }
6571
6572    if(ueCfg->cellGrpCfg)
6573    {
6574
6575       rlcBearerList = cellGrpCfg->rlc_BearerToAddModList;
6576       if(rlcBearerList)
6577       {
6578          if(rlcBearerList->list.array)
6579          {
6580             for(arrIdx=0; arrIdx<rlcBearerList->list.count; arrIdx++)
6581             {
6582                if(rlcBearerList->list.array[arrIdx])
6583                {
6584                   rlcConfig   = rlcBearerList->list.array[arrIdx]->rlc_Config;
6585                   macLcConfig = rlcBearerList->list.array[arrIdx]->mac_LogicalChannelConfig;
6586
6587                   if(rlcBearerList->list.array[arrIdx]->servedRadioBearer)
6588                   {
6589                      free(rlcBearerList->list.array[arrIdx]->servedRadioBearer);
6590                   }
6591                   if(rlcConfig)
6592                   {
6593                      if(rlcConfig->choice.am)
6594                      {
6595                         free(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength);
6596                         free(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength);
6597                         free(rlcConfig->choice.am);
6598                      }
6599                      free(rlcBearerList->list.array[arrIdx]->rlc_Config);
6600                   }
6601                   if(macLcConfig)
6602                   {
6603                      if(macLcConfig->ul_SpecificParameters)
6604                      {
6605                         free(macLcConfig->ul_SpecificParameters->schedulingRequestID);
6606                         free(macLcConfig->ul_SpecificParameters->logicalChannelGroup);
6607                         free(macLcConfig->ul_SpecificParameters);
6608                      }
6609                      free(rlcBearerList->list.array[arrIdx]->mac_LogicalChannelConfig);
6610                   }
6611                   free(rlcBearerList->list.array[arrIdx]);
6612                }
6613             }
6614             free(rlcBearerList->list.array);
6615          }
6616          free(cellGrpCfg->rlc_BearerToAddModList);
6617       }
6618
6619       macCellGrpCfg = cellGrpCfg->mac_CellGroupConfig;
6620       if(macCellGrpCfg)
6621       {
6622          schedulingRequestConfig = macCellGrpCfg->schedulingRequestConfig;
6623          if(schedulingRequestConfig)
6624          {
6625             schReqList = schedulingRequestConfig->schedulingRequestToAddModList;
6626             if(schReqList)
6627             {
6628                if(schReqList->list.array)
6629                {
6630                   for(arrIdx=0;arrIdx<schReqList->list.count; arrIdx++)
6631                   {
6632                      if(schReqList->list.array[arrIdx])
6633                      {
6634                         free(schReqList->list.array[arrIdx]->sr_ProhibitTimer);
6635                         free(schReqList->list.array[arrIdx]);
6636                      }
6637                   }
6638                   free(schReqList->list.array);
6639                }
6640                free(schedulingRequestConfig->schedulingRequestToAddModList);
6641             }
6642             free(macCellGrpCfg->schedulingRequestConfig);
6643          }
6644          if(macCellGrpCfg->bsr_Config)
6645          {
6646             free(macCellGrpCfg->bsr_Config);
6647          }
6648          tagConfig = macCellGrpCfg->tag_Config;
6649          if(tagConfig)
6650          {
6651             tagList = tagConfig->tag_ToAddModList;
6652             if(tagList)
6653             {
6654                if(tagList->list.array)
6655                {
6656                   for(arrIdx=0; arrIdx<tagList->list.count; arrIdx++)
6657                   {
6658                      free(tagList->list.array[arrIdx]);
6659                   }
6660                   free(tagList->list.array);
6661                }
6662                free(tagConfig->tag_ToAddModList);
6663             }
6664             free(tagConfig);
6665          }
6666
6667          phrConfig = macCellGrpCfg->phr_Config;
6668          if(phrConfig)
6669          {
6670             free(phrConfig->choice.setup);
6671             free(phrConfig);
6672          }
6673
6674          free(macCellGrpCfg);
6675       }
6676
6677       phyCellGrpCfg = cellGrpCfg->physicalCellGroupConfig;
6678       if(phyCellGrpCfg)
6679       {
6680          free(phyCellGrpCfg->p_NR_FR1);
6681          free(phyCellGrpCfg);
6682       }
6683
6684       spCellCfg = cellGrpCfg->spCellConfig;
6685       if(spCellCfg)
6686       {
6687          if(spCellCfg->servCellIndex)
6688          {
6689             if(spCellCfg->rlmInSyncOutOfSyncThreshold)
6690             {
6691                if(spCellCfg->spCellConfigDedicated)
6692                {
6693                   srvCellCfg = spCellCfg->spCellConfigDedicated;
6694                   if(srvCellCfg->initialDownlinkBWP)
6695                   {
6696                      dlBwp = srvCellCfg->initialDownlinkBWP;
6697                      if(srvCellCfg->firstActiveDownlinkBWP_Id)
6698                      {
6699                         if(srvCellCfg->defaultDownlinkBWP_Id)
6700                         {
6701                            if(srvCellCfg->uplinkConfig)
6702                            {
6703
6704                               if(srvCellCfg->pdsch_ServingCellConfig)
6705                               {
6706                                  pdschCfg=
6707                                     srvCellCfg->pdsch_ServingCellConfig;
6708                                  if(pdschCfg->choice.setup)
6709                                  {
6710
6711                                     free(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH);
6712                                     free(pdschCfg->choice.setup);
6713                                  }
6714
6715                                  free(srvCellCfg->pdsch_ServingCellConfig);
6716                               }
6717
6718                               freeAperDecodeinitialUplinkBWPConfig(srvCellCfg->uplinkConfig);
6719                               free(srvCellCfg->uplinkConfig);
6720                            }
6721                            free(srvCellCfg->defaultDownlinkBWP_Id);
6722                         }
6723
6724                         free(srvCellCfg->firstActiveDownlinkBWP_Id);
6725                      }
6726                      if(dlBwp->pdcch_Config)
6727                      {
6728                         if(dlBwp->pdsch_Config)
6729                         {
6730                            freeAperDecodeBWPDlDedPdschConfig(dlBwp);
6731                            free(dlBwp->pdsch_Config);
6732                         }
6733                         freeAperDecodeBWPDlDedPdcchConfig(dlBwp);
6734                         free(dlBwp->pdcch_Config);
6735                      }
6736                      free(srvCellCfg->initialDownlinkBWP);
6737                   }
6738
6739                   free(spCellCfg->spCellConfigDedicated);
6740                }
6741                free(spCellCfg->rlmInSyncOutOfSyncThreshold);
6742             }
6743             free(spCellCfg->servCellIndex);
6744          }
6745          free(spCellCfg);
6746       }
6747       DU_FREE(ueCfg->cellGrpCfg, sizeof(CellGroupConfigRrc_t));
6748       ueCfg->cellGrpCfg = NULLP;
6749    }
6750    if(ueCfg->ambrCfg)
6751    {
6752       memset(ueCfg->ambrCfg, 0, sizeof(AmbrCfg));
6753       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, ueCfg->ambrCfg, sizeof(AmbrCfg));
6754    }
6755    for(lcIdx = 0; lcIdx < ueCfg->numRlcLcs; lcIdx++)
6756    {
6757       freeRlcLcCfg(&ueCfg->rlcLcCfg[lcIdx]);
6758    }
6759    for(lcIdx = 0; lcIdx < ueCfg->numMacLcs; lcIdx++)
6760    {
6761       freeMacLcCfg(&ueCfg->macLcCfg[lcIdx]);
6762    }
6763    for(lcIdx = 0; lcIdx < ueCfg->numDrb; lcIdx++)
6764    {
6765       DU_FREE(ueCfg->upTnlInfo[lcIdx].tnlCfg1, sizeof(GtpTnlCfg));
6766       memset(&ueCfg->upTnlInfo[lcIdx], 0, sizeof(UpTnlCfg));
6767    }
6768 }
6769
6770 /*******************************************************************
6771  *
6772  * @brief Function to free UecontextSetupDb
6773  *
6774  * @details
6775  *
6776  *    Function : freeF1UeDb
6777  *
6778  *    Functionality: Function to free UecontextSetupDb
6779  *
6780  * @params[in] UecontextSetupDb *
6781  * @return void
6782  *
6783  * ****************************************************************/
6784
6785 void freeF1UeDb(F1UeContextSetupDb *f1UeDb)
6786 {
6787
6788    if(f1UeDb->dlRrcMsg)
6789    {
6790       if(f1UeDb->dlRrcMsg->rrcMsgPdu)
6791       {
6792          DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL,\
6793             f1UeDb->dlRrcMsg->rrcMsgPdu, f1UeDb->dlRrcMsg->rrcMsgSize);
6794       }
6795       memset(f1UeDb->dlRrcMsg, 0, sizeof(F1DlRrcMsg));
6796    }
6797    freeDuUeCfg(&f1UeDb->duUeCfg);
6798    memset(f1UeDb, 0, sizeof(F1UeContextSetupDb));
6799    DU_FREE(f1UeDb, sizeof(F1UeContextSetupDb));
6800 }
6801
6802 /*******************************************************************
6803  *
6804  * @brief Function to build Am cfg Info
6805  *
6806  * @details
6807  *
6808  *    Function : extractRlcAmCfg
6809  *
6810  *    Functionality: Function to build Am cfg Info
6811  *
6812  * @params[in] AmBearerCfg *
6813  *             void *
6814  *
6815  * @return ROK/RFAILED
6816  *
6817  * ****************************************************************/
6818
6819 void extractRlcAmCfg(AmBearerCfg *amCfgToSet, struct RLC_Config__am *rlcAmCfg)
6820 {
6821    if(rlcAmCfg)
6822    {
6823       /* UL AM */
6824       if(rlcAmCfg->dl_AM_RLC.sn_FieldLength)
6825       {
6826          amCfgToSet->ulAmCfg.snLenUl = *(rlcAmCfg->dl_AM_RLC.sn_FieldLength);
6827          /*TODO: Check the timer value when sent by real CU */
6828          amCfgToSet->ulAmCfg.reAssemTmr = rlcAmCfg->dl_AM_RLC.t_Reassembly;
6829          amCfgToSet->ulAmCfg.statProhTmr = rlcAmCfg->dl_AM_RLC.t_StatusProhibit;
6830       }
6831
6832       /* DL AM */
6833       if(rlcAmCfg->ul_AM_RLC.sn_FieldLength)
6834       {
6835          amCfgToSet->dlAmCfg.snLenDl = *(rlcAmCfg->ul_AM_RLC.sn_FieldLength);
6836          amCfgToSet->dlAmCfg.pollRetxTmr = rlcAmCfg->ul_AM_RLC.t_PollRetransmit;
6837          amCfgToSet->dlAmCfg.pollPdu   = rlcAmCfg->ul_AM_RLC.pollPDU;
6838          amCfgToSet->dlAmCfg.pollByte  = rlcAmCfg->ul_AM_RLC.pollByte;
6839          amCfgToSet->dlAmCfg.maxRetxTh = rlcAmCfg->ul_AM_RLC.maxRetxThreshold;
6840       }
6841    }
6842 }
6843
6844 /*******************************************************************
6845  *
6846  * @brief Function to build Um Bi Info
6847  *
6848  * @details
6849  *
6850  *    Function : extractRlcUmBiCfg
6851  *
6852  *    Functionality: Function to build Um Bi Info
6853  *
6854  * @params[in] UmBiDirBearerCfg *
6855  *             void *
6856  *
6857  * @return ROK/RFAILED
6858  *
6859  * ****************************************************************/
6860
6861 void extractRlcUmBiCfg(UmBiDirBearerCfg *umBiCfgToSet, struct RLC_Config__um_Bi_Directional *rlcBiCfg)
6862 {
6863    if(rlcBiCfg)
6864    {
6865       /* UL UM BI DIR Cfg */
6866       if(rlcBiCfg->dl_UM_RLC.sn_FieldLength)
6867       {
6868          umBiCfgToSet->ulUmCfg.snLenUlUm  = *(rlcBiCfg->dl_UM_RLC.sn_FieldLength);
6869          umBiCfgToSet->ulUmCfg.reAssemTmr = rlcBiCfg->dl_UM_RLC.t_Reassembly;
6870       }
6871
6872       /* DL UM BI DIR Cfg */
6873       if(rlcBiCfg->ul_UM_RLC.sn_FieldLength)
6874          umBiCfgToSet->dlUmCfg.snLenDlUm  = *(rlcBiCfg->ul_UM_RLC.sn_FieldLength);
6875    }
6876 }
6877
6878 /*******************************************************************
6879  *
6880  * @brief Function to build Um Ul Info
6881  *
6882  * @details
6883  *
6884  *    Function : extractRlcUmUlCfg
6885  *
6886  *    Functionality: Function to build Um Ul Info
6887  *
6888  * @params[in] UmUniDirUlBearerCfg *
6889  *             void *
6890  *
6891  * @return ROK/RFAILED
6892  *
6893  * ****************************************************************/
6894
6895 void extractRlcUmUlCfg(UmUniDirUlBearerCfg *umUlCfgToSet, struct RLC_Config__um_Uni_Directional_DL *umUlCfg)
6896 {
6897    if(umUlCfg)
6898    {
6899       if(umUlCfg->dl_UM_RLC.sn_FieldLength)
6900       {
6901          umUlCfgToSet->ulUmCfg.snLenUlUm  = *(umUlCfg->dl_UM_RLC.sn_FieldLength);
6902          umUlCfgToSet->ulUmCfg.reAssemTmr = umUlCfg->dl_UM_RLC.t_Reassembly;
6903       }
6904    }
6905 }
6906
6907 /*******************************************************************
6908  *
6909  * @brief Function to build Um Uni Dl Info
6910  *
6911  * @details
6912  *
6913  *    Function : extractRlcUmDlCfg
6914  *
6915  *    Functionality: Function to build Um Uni Dl Info
6916  *
6917  * @params[in] UmUniDirDlBearerCfg *
6918  *             void *
6919  *
6920  * @return ROK/RFAILED
6921  *
6922  * ****************************************************************/
6923 void extractRlcUmDlCfg(UmUniDirDlBearerCfg *umDlCfgToSet, struct RLC_Config__um_Uni_Directional_UL *umDlCfg)
6924 {
6925    if(umDlCfg)
6926    {
6927       if(umDlCfg->ul_UM_RLC.sn_FieldLength)
6928          umDlCfgToSet->dlUmCfg.snLenDlUm  = *(umDlCfg->ul_UM_RLC.sn_FieldLength);
6929    }
6930 }
6931
6932 /*******************************************************************
6933  *
6934  * @brief Function to extractRlcModeCfg
6935  *
6936  * @details
6937  *
6938  *    Function : extractRlcModeCfg
6939  *
6940  *    Functionality: Function to extractRlcModeCfg
6941  *
6942  * @params[in] RLC_Config_t *
6943  *             RlcBearerCfg *
6944  *             void  *
6945  * @return ROK/RFAILED
6946  *
6947  * ****************************************************************/
6948 void extractRlcModeCfg(uint8_t rlcMode, RlcBearerCfg *rlcDbCfg, RLC_Config_t *lcCfg)
6949 {
6950    if(lcCfg)
6951    {
6952       switch(rlcMode)
6953       {
6954          case RLC_AM :
6955             {
6956                if(lcCfg->choice.am)
6957                {
6958                   DU_ALLOC_SHRABL_BUF(rlcDbCfg->u.amCfg, sizeof(AmBearerCfg));
6959                   if(rlcDbCfg->u.amCfg)
6960                      extractRlcAmCfg(rlcDbCfg->u.amCfg, lcCfg->choice.am);
6961                }
6962                break;
6963             }
6964          case RLC_UM_BI_DIRECTIONAL :
6965             {
6966                if(lcCfg->choice.um_Bi_Directional)
6967                {
6968                   DU_ALLOC_SHRABL_BUF(rlcDbCfg->u.umBiDirCfg, sizeof(UmBiDirBearerCfg));
6969                   if(rlcDbCfg->u.umBiDirCfg)
6970                      extractRlcUmBiCfg(rlcDbCfg->u.umBiDirCfg, lcCfg->choice.um_Bi_Directional);
6971                }
6972                break;
6973             }
6974          case RLC_UM_UNI_DIRECTIONAL_UL :
6975             {
6976                if(lcCfg->choice.um_Uni_Directional_DL)
6977                {
6978                   DU_ALLOC_SHRABL_BUF(rlcDbCfg->u.umUniDirUlCfg, sizeof(UmUniDirUlBearerCfg));
6979                   if(rlcDbCfg->u.umUniDirUlCfg)
6980                      extractRlcUmUlCfg(rlcDbCfg->u.umUniDirUlCfg, lcCfg->choice.um_Uni_Directional_DL);
6981                }
6982                break;
6983             }
6984          case RLC_UM_UNI_DIRECTIONAL_DL :
6985             {
6986                if(lcCfg->choice.um_Uni_Directional_UL)
6987                {
6988                   DU_ALLOC_SHRABL_BUF(rlcDbCfg->u.umUniDirDlCfg, sizeof(UmUniDirDlBearerCfg));
6989                   if(rlcDbCfg->u.umUniDirDlCfg)
6990                      extractRlcUmDlCfg(rlcDbCfg->u.umUniDirDlCfg, lcCfg->choice.um_Uni_Directional_UL);
6991                }
6992                break;
6993             }
6994          default:
6995             DU_LOG("\nERROR  -->  DUAPP: Invalid rlcMode %d at extractRlcCfgToAddMod()", rlcMode);
6996             break;
6997       }
6998    }
6999 }
7000
7001 /*******************************************************************
7002  *
7003  * @brief Function to extract extractUlLcCfg
7004  *
7005  * @details
7006  *
7007  *    Function : extractUlLcCfg
7008  *
7009  *    Functionality: Function to extract extractUlLcCfg
7010  *
7011  * @params[in] UlLcCfg *f1UlLcCfg, LogicalChannelConfig_t *ulLcCfg
7012  * @return void
7013  *
7014  * ****************************************************************/
7015
7016 void extractUlLcCfg(UlLcCfg *f1UlLcCfg, LogicalChannelConfig_t *ulLcCfg)
7017 {
7018    if(ulLcCfg)
7019    {
7020       if(ulLcCfg->ul_SpecificParameters)
7021       {
7022          f1UlLcCfg->priority = \
7023             ulLcCfg->ul_SpecificParameters->priority;
7024       if(ulLcCfg->ul_SpecificParameters->logicalChannelGroup)
7025       {
7026          f1UlLcCfg->lcGroup = \
7027            *(ulLcCfg->ul_SpecificParameters->logicalChannelGroup);
7028       }
7029       if(ulLcCfg->ul_SpecificParameters->schedulingRequestID)
7030       {
7031          f1UlLcCfg->schReqId = \
7032            *(ulLcCfg->ul_SpecificParameters->schedulingRequestID);
7033       }
7034       f1UlLcCfg->pbr = \
7035          ulLcCfg->ul_SpecificParameters->prioritisedBitRate;
7036       f1UlLcCfg->bsd = \
7037          ulLcCfg->ul_SpecificParameters->bucketSizeDuration;
7038       }
7039    }
7040 }
7041
7042 /*******************************************************************
7043  *
7044  * @brief Function to procRlcLcCfg
7045  *
7046  * @details
7047  *
7048  *    Function : procRlcLcCfg
7049  *
7050  *    Functionality: Function to procRlcLcCfg
7051  *
7052  * @params[in] rbId, lcId, rbType, rlcMod
7053  *             RLC_Config_t *, RlcBearerCfg * ,
7054  * @return void
7055  *
7056  * ****************************************************************/
7057
7058 void procRlcLcCfg(uint8_t rbId, uint8_t lcId, uint8_t rbType, uint8_t rlcMode,\
7059    uint8_t configType, RLC_Config_t *f1RlcCfg, RlcBearerCfg *lcCfg)
7060 {
7061
7062    lcCfg->rbId   = rbId;
7063    lcCfg->configType = configType;
7064
7065    if(rbType == RB_TYPE_SRB)
7066    {
7067       lcCfg->rbType = RB_TYPE_SRB;
7068       lcCfg->lcId   = rbId;
7069       lcCfg->lcType = LCH_DCCH;
7070       lcCfg->rlcMode = RLC_AM;
7071    }
7072    else if(rbType == RB_TYPE_DRB)
7073    {
7074       lcCfg->rbType = RB_TYPE_DRB;
7075       lcCfg->lcId   = lcId;
7076       lcCfg->lcType = LCH_DTCH;
7077       lcCfg->rlcMode = rlcMode;
7078    }
7079    if(f1RlcCfg) /* rlc mode config recived */
7080    {
7081       extractRlcModeCfg(lcCfg->rlcMode, lcCfg, f1RlcCfg);
7082    }
7083 }
7084
7085
7086
7087 /*******************************************************************
7088  *
7089  * @brief Fills DrbQos Info received by CU
7090  *
7091  * @details
7092  *
7093  *    Function : extractQosInfo
7094  *
7095  *    Functionality: Fills DrbQos Info received  by CU
7096  *
7097  * @params[in] DrbQosInfo *qosToAdd,
7098  *             QoSFlowLevelQoSParameters_t *qosFlowCfg
7099  * @return void
7100  *
7101  * ****************************************************************/
7102
7103 void extractQosInfo(DrbQosInfo *qosToAdd, QoSFlowLevelQoSParameters_t *qosFlowCfg)
7104 {
7105    qosToAdd->fiveQiType = qosFlowCfg->qoS_Characteristics.present;
7106    qosToAdd->u.nonDyn5Qi.fiveQi     =\
7107          qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->fiveQI;
7108    if(qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow)
7109    {
7110       qosToAdd->u.nonDyn5Qi.avgWindow = \
7111         *(qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow);
7112    }
7113    qosToAdd->u.nonDyn5Qi.maxDataBurstVol = \
7114       *(qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume);
7115    if(qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->qoSPriorityLevel)
7116    {
7117       qosToAdd->u.nonDyn5Qi.priorLevel = \
7118          *(qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->qoSPriorityLevel);
7119    }
7120    qosToAdd->ngRanRetPri.priorityLevel = \
7121       qosFlowCfg->nGRANallocationRetentionPriority.priorityLevel;
7122    qosToAdd->ngRanRetPri.preEmptionCap = \
7123       qosFlowCfg->nGRANallocationRetentionPriority.pre_emptionCapability;
7124    qosToAdd->ngRanRetPri.preEmptionVul = \
7125       qosFlowCfg->nGRANallocationRetentionPriority.pre_emptionVulnerability;
7126    if(qosFlowCfg->gBR_QoS_Flow_Information)
7127    {
7128       memcpy(&qosToAdd->grbQosInfo.maxFlowBitRateDl, \
7129          qosFlowCfg->gBR_QoS_Flow_Information->maxFlowBitRateDownlink.buf, \
7130          qosFlowCfg->gBR_QoS_Flow_Information->maxFlowBitRateDownlink.size);
7131       memcpy(&qosToAdd->grbQosInfo.maxFlowBitRateUl, \
7132          qosFlowCfg->gBR_QoS_Flow_Information->maxFlowBitRateUplink.buf, \
7133          qosFlowCfg->gBR_QoS_Flow_Information->maxFlowBitRateUplink.size);
7134       memcpy(&qosToAdd->grbQosInfo.guarFlowBitRateDl,\
7135          qosFlowCfg->gBR_QoS_Flow_Information->guaranteedFlowBitRateDownlink.buf, \
7136          qosFlowCfg->gBR_QoS_Flow_Information->guaranteedFlowBitRateDownlink.size);
7137       memcpy(&qosToAdd->grbQosInfo.guarFlowBitRateUl,\
7138          qosFlowCfg->gBR_QoS_Flow_Information->guaranteedFlowBitRateUplink.buf, \
7139          qosFlowCfg->gBR_QoS_Flow_Information->guaranteedFlowBitRateUplink.size);
7140    }
7141    qosToAdd->pduSessionId = 0;
7142    qosToAdd->ulPduSessAggMaxBitRate = 0;
7143 }
7144
7145 /*******************************************************************
7146  *
7147  * @brief Function to extract GTP Tunnel Info from CU
7148  *
7149  * @details
7150  *
7151  *    Function : extractUpTnlInfo
7152  *
7153  *    Functionality: Function to extract GTP Tunnel Info from CU
7154  *
7155  * @params[in] F1AP message
7156  * @return ROK/RFAILED
7157  *
7158  * ****************************************************************/
7159
7160 uint8_t extractUpTnlInfo(uint8_t drbId, uint8_t configType,\
7161    ULUPTNLInformation_ToBeSetup_List_t *tnlInfo, UpTnlCfg *upTnlInfo)
7162 {
7163    uint8_t tnlIdx;
7164    uint32_t ipv4_du = 0;
7165    GTPTunnel_t *gtpTunnel = NULLP;
7166
7167    upTnlInfo->drbId = drbId;
7168    upTnlInfo->configType = configType;
7169    cmInetAddr((char *)DU_IP_V4_ADDR, &ipv4_du);
7170
7171    for(tnlIdx=0; tnlIdx < tnlInfo->list.count; tnlIdx++)
7172    {
7173       if(tnlInfo->list.array[tnlIdx]->uLUPTNLInformation.present == UPTransportLayerInformation_PR_gTPTunnel)
7174       {
7175          if(tnlInfo->list.array[tnlIdx]->uLUPTNLInformation.choice.gTPTunnel)
7176          {
7177             gtpTunnel = tnlInfo->list.array[tnlIdx]->uLUPTNLInformation.choice.gTPTunnel;
7178             DU_ALLOC(upTnlInfo->tnlCfg1, sizeof(GtpTnlCfg));
7179             if(upTnlInfo->tnlCfg1 == NULLP)
7180             {
7181                DU_LOG("\nERROR  -->  F1AP : extractUpTnlInfo: Failed to allocate mmeory for tunnel cfg 1");
7182                return RFAILED;
7183             }
7184             bitStringToInt(&gtpTunnel->transportLayerAddress, &upTnlInfo->tnlCfg1->ulTnlAddress);
7185             upTnlInfo->tnlCfg1->dlTnlAddress = ipv4_du;
7186             if(gtpTunnel->gTP_TEID.size > 0)
7187             {
7188                teIdStringToInt(gtpTunnel->gTP_TEID.buf, &upTnlInfo->tnlCfg1->teId);
7189             }
7190          }
7191          break;
7192       }
7193    }
7194    return ROK;
7195 }
7196 /*******************************************************************
7197 *
7198 * @brief Function to extract Drb Qos Cfg Info from CU
7199 *
7200 * @details
7201 *
7202 *    Function : extractDrbQosCfg
7203 *
7204 *    Functionality: Function to extract Drb Qos Cfg Info from CU
7205 *
7206 * @params[in] DRB_Information_t *drbInfo, LcCfg *macLcToAdd
7207 * @return ROK/RFAILED
7208 *
7209 * ****************************************************************/
7210
7211 uint8_t extractDrbQosCfg(DRB_Information_t *drbInfo, LcCfg *macLcToAdd )
7212 {
7213    if(!macLcToAdd->drbQos)
7214    {
7215       DU_ALLOC_SHRABL_BUF(macLcToAdd->drbQos, sizeof(DrbQosInfo));
7216       if(macLcToAdd->drbQos == NULLP)
7217       {
7218          DU_LOG("\nERROR  -->  DUAPP:Memory failed at allocating DrbQos at extractDrbCfg()");
7219          return RFAILED;
7220       }
7221
7222    }
7223    if(drbInfo->dRB_QoS.qoS_Characteristics.present == QoS_Characteristics_PR_non_Dynamic_5QI)
7224    {
7225       extractQosInfo(macLcToAdd->drbQos, &drbInfo->dRB_QoS);
7226       macLcToAdd->dlLcCfg.lcp = macLcToAdd->drbQos->ngRanRetPri.priorityLevel;
7227    }
7228    if(!macLcToAdd->snssai)
7229    {
7230       DU_ALLOC_SHRABL_BUF(macLcToAdd->snssai, sizeof(Snssai));
7231       if(macLcToAdd->snssai == NULLP)
7232       {
7233          DU_LOG("\nERROR  -->  DUAPP : Memory failed at allocating SNSSAI at extractDrbCfg()");
7234          return RFAILED;
7235       }
7236    }
7237    memcpy(&macLcToAdd->snssai->sst, drbInfo->sNSSAI.sST.buf, \
7238          drbInfo->sNSSAI.sST.size);
7239    if(drbInfo->sNSSAI.sD)
7240    {
7241       memcpy(macLcToAdd->snssai->sd, drbInfo->sNSSAI.sD->buf, \
7242             drbInfo->sNSSAI.sD->size);
7243    }
7244    return ROK;
7245 }
7246 /*******************************************************************
7247  *
7248  * @brief Function to extract DRB info received from CU
7249  *
7250  * @details
7251  *
7252  *    Function : extractDrbCfg
7253  *
7254  *    Functionality: Function to extract DRB info received from CU
7255  *
7256  * @params[in] F1AP message
7257  * @return void
7258  *
7259  * ****************************************************************/
7260 uint8_t extractDrbCfg(DRBs_ToBeSetup_Item_t *drbItem,DRBs_ToBeSetupMod_Item_t *drbSetupModItem,\
7261 LcCfg *macLcToAdd, UpTnlCfg *upTnlInfo)
7262 {
7263    DRB_Information_t *drbInfo = NULLP;
7264
7265    if(drbItem != NULLP)
7266    {
7267       if(extractUpTnlInfo(drbItem->dRBID, CONFIG_ADD, &drbItem->uLUPTNLInformation_ToBeSetup_List, upTnlInfo) != ROK)
7268       {
7269          DU_LOG("\nERROR  -->  DUAPP : Failed to extract tunnel Cfg at extractDrbCfg()");
7270          return RFAILED;
7271       }
7272       if(drbItem->qoSInformation.present == QoSInformation_PR_choice_extension)
7273       {
7274          if(drbItem->qoSInformation.choice.choice_extension->value.present == QoSInformation_ExtIEs__value_PR_DRB_Information)
7275          {
7276             drbInfo = &drbItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information;
7277             if(extractDrbQosCfg(drbInfo , macLcToAdd) != ROK)
7278             {
7279                DU_LOG("\nERROR  -->  DUAPP : Failed to extract qos Cfg at extractDrbCfg()");
7280                return RFAILED;
7281             }
7282          }
7283       }
7284    }
7285    else if(drbSetupModItem != NULLP)
7286    {
7287       if(extractUpTnlInfo(drbSetupModItem->dRBID, CONFIG_ADD, &drbSetupModItem->uLUPTNLInformation_ToBeSetup_List,\
7288       upTnlInfo) != ROK)
7289       {
7290          DU_LOG("\nERROR  -->  DUAPP : Failed to extract tunnel Cfg at extractDrbCfg()");
7291          return RFAILED;
7292       }
7293       if(drbSetupModItem->qoSInformation.present == QoSInformation_PR_choice_extension)
7294       {
7295          if(drbSetupModItem->qoSInformation.choice.choice_extension->value.present ==\
7296          QoSInformation_ExtIEs__value_PR_DRB_Information)
7297          {
7298             drbInfo = &drbSetupModItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information;
7299             if(extractDrbQosCfg(drbInfo , macLcToAdd) != ROK)
7300             {
7301                DU_LOG("\nERROR  -->  DUAPP : Failed to extract qos Cfg at extractDrbCfg()");
7302                return RFAILED;
7303             }
7304
7305          }
7306       }
7307    }
7308
7309    return ROK;
7310 }
7311
7312 /*******************************************************************
7313  *
7314  * @brief Function to extract RB info received from CU
7315  *
7316  * @details
7317  *
7318  *    Function : extractMacRbCfg
7319  *
7320  *    Functionality: Function to extract RB info received from CU
7321  *
7322  * @params[in] F1AP message
7323  * @return ROK/RFAILED
7324  *
7325  * ****************************************************************/
7326
7327 uint8_t extractMacRbCfg(uint8_t lcId, DRBs_ToBeSetup_Item_t *drbCfg,\
7328 DRBs_ToBeSetupMod_Item_t *drbSetupModCfg,  LogicalChannelConfig_t *ulLcCfg, LcCfg *lcCfg, UpTnlCfg *upTnlInfo)
7329 {
7330    if(drbCfg != NULLP)
7331    {
7332       if(extractDrbCfg(drbCfg, NULL, lcCfg, upTnlInfo) != ROK)
7333       {
7334          DU_LOG("ERROR  -->  F1AP : Failed to build Drb Qos at extractMacRbCfg()");
7335          return RFAILED;
7336       }
7337    }
7338    else if(drbSetupModCfg != NULLP)
7339    {
7340       if(extractDrbCfg(NULL, drbSetupModCfg, lcCfg, upTnlInfo) != ROK)
7341       {
7342          DU_LOG("ERROR  -->  F1AP : Failed to build Drb Qos at extractMacRbCfg()");
7343          return RFAILED;
7344       }
7345    }
7346    else
7347    {
7348       lcCfg->drbQos = NULLP;
7349       lcCfg->snssai = NULLP;
7350       if(lcCfg->lcId == SRB2_LCID)
7351          lcCfg->dlLcCfg.lcp = LC_PRIORITY_3;
7352       else
7353          lcCfg->dlLcCfg.lcp = LC_PRIORITY_1;
7354    }
7355    if(ulLcCfg)
7356    {
7357       lcCfg->ulLcCfgPres = true;
7358       extractUlLcCfg(&lcCfg->ulLcCfg, ulLcCfg);
7359    }
7360    else
7361       lcCfg->ulLcCfgPres = false;
7362    return ROK;
7363 }
7364
7365 /*******************************************************************
7366  *
7367  * @brief Function processing LC config info received from CU
7368  *
7369  * @details
7370  *
7371  *    Function : procMacLcCfg
7372  *
7373  *    Functionality: Function processing LC config info received from CU
7374  *
7375  * @params[in] F1AP message
7376  * @return ROK/RFAILED
7377  *
7378  * ****************************************************************/
7379
7380 uint8_t procMacLcCfg(uint8_t lcId, uint8_t rbType, uint8_t configType,\
7381 DRBs_ToBeSetup_Item_t *drbItem, DRBs_ToBeSetupMod_Item_t *drbSetupModItem, LogicalChannelConfig_t *ulLcCfg,\
7382 LcCfg *lcCfg, UpTnlCfg *upTnlInfo)
7383 {
7384    uint8_t ret = ROK;
7385
7386    lcCfg->lcId = lcId;
7387    lcCfg->configType = configType;
7388    if(rbType == RB_TYPE_SRB)
7389    {
7390       ret = extractMacRbCfg(lcId, NULL,NULL, ulLcCfg, lcCfg, NULL);
7391    }
7392    else if(rbType == RB_TYPE_DRB)
7393    {
7394       if(drbItem != NULL)
7395         ret = extractMacRbCfg(lcId, drbItem, NULL, ulLcCfg, lcCfg, upTnlInfo);
7396       else if(drbSetupModItem != NULL)
7397         ret = extractMacRbCfg(lcId, NULL, drbSetupModItem, ulLcCfg, lcCfg, upTnlInfo);
7398    }
7399    return ret;
7400 }
7401
7402 /*******************************************************************
7403  *
7404  * @brief Function to extract Rlc cfg To Add/Mod in CellGrp Info
7405  *
7406  * @details
7407  *
7408  *    Function : extractRlcCfgToAddMod
7409  *
7410  *    Functionality: Function to extract Rlc cfg To Add/Mod in CellGrp Info
7411  *
7412  * @params[in] CellGroupConfigRrc__rlc_BearerTo pointer
7413  *             DuUeCfg Pointer
7414  * @return ROK/RFAILED
7415  *
7416  * ****************************************************************/
7417
7418 uint8_t extractRlcCfgToAddMod(struct CellGroupConfigRrc__rlc_BearerToAddModList *lcCfg, DuUeCfg *ueCfgDb)
7419 {
7420   uint8_t idx, rbId, lcId, rlcMode, rbType;
7421   RLC_Config_t *f1RlcCfg = NULLP;
7422   LogicalChannelConfig_t *macUlLcCfg = NULLP;
7423
7424   for(idx = 0; idx < lcCfg->list.count; idx++)
7425   {
7426      lcId = lcCfg->list.array[idx]->logicalChannelIdentity;
7427      if(lcCfg->list.array[idx]->servedRadioBearer)
7428      {
7429         /* RadioBearer for SRB/DRB */
7430         if(lcCfg->list.array[idx]->servedRadioBearer->present ==\
7431         RLC_BearerConfig__servedRadioBearer_PR_srb_Identity)
7432         {
7433            rbId = lcCfg->list.array[idx]->servedRadioBearer->choice.srb_Identity;
7434            rbType = RB_TYPE_SRB;
7435         }
7436         else if(lcCfg->list.array[idx]->servedRadioBearer->present ==\
7437         RLC_BearerConfig__servedRadioBearer_PR_drb_Identity)
7438         {
7439            rbId = lcCfg->list.array[idx]->servedRadioBearer->choice.drb_Identity;
7440            rbType = RB_TYPE_DRB;
7441         }
7442         else
7443         {
7444            DU_LOG("\nERROR  -->  No components present in Bearer config to ADD/MOD");
7445            return RFAILED;
7446         }
7447         /* MAC UL LC Config */
7448         if(lcCfg->list.array[idx]->mac_LogicalChannelConfig)
7449         {
7450            macUlLcCfg = lcCfg->list.array[idx]->mac_LogicalChannelConfig;
7451         }
7452      }
7453      else
7454      {
7455         DU_LOG("\nERROR  -->  DUAPP: Received RadioBearer config is NULL");
7456         return RFAILED;
7457      }
7458      /* RLC Mode Config */
7459      if(lcCfg->list.array[idx]->rlc_Config)
7460      {
7461         rlcMode  = lcCfg->list.array[idx]->rlc_Config->present;
7462         f1RlcCfg = lcCfg->list.array[idx]->rlc_Config;
7463      }
7464
7465      /* Filling RLC/MAC Config*/
7466      memset(&ueCfgDb->macLcCfg[idx], 0, sizeof(LcCfg));
7467      memset(&ueCfgDb->rlcLcCfg[idx], 0, sizeof(RlcBearerCfg));
7468      procRlcLcCfg(rbId, lcId, rbType, rlcMode, CONFIG_UNKNOWN, f1RlcCfg, &(ueCfgDb->rlcLcCfg[idx]));
7469      if(procMacLcCfg(lcId, rbType, CONFIG_UNKNOWN, NULL, NULL, macUlLcCfg, &ueCfgDb->macLcCfg[idx], NULL) != ROK)
7470      {
7471         DU_LOG("\nERROR  -->  DU APP : Failed while filling MAC LC config at extractRlcCfgToAddMod()");
7472         return RFAILED;
7473      }
7474      (ueCfgDb->numRlcLcs)++;
7475      (ueCfgDb->numMacLcs)++;
7476   }
7477   //TODO: To send the failure cause in UeContextSetupRsp
7478   return ROK;
7479 }
7480
7481 /*******************************************************************
7482  *
7483  * @brief DeAlloc pdsch serv cell config info
7484  *
7485  * @details
7486  *
7487  *    Function : freeMacPdschServCellInfo
7488  *
7489  *    Functionality: DeAlloc pdsch serv cell config info
7490  *
7491  * @params[in] PdschServCellCfg pointer
7492  * @return void
7493  *
7494  * ****************************************************************/
7495
7496 void freeMacPdschServCellInfo(PdschServCellCfg *pdsch)
7497 {
7498    if(pdsch->xOverhead)
7499    {
7500       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, pdsch->xOverhead, sizeof(uint8_t));
7501    }
7502    if(pdsch->codeBlkGrpFlushInd)
7503    {
7504       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, pdsch->codeBlkGrpFlushInd, sizeof(bool));
7505    }
7506    if(pdsch->maxCodeBlkGrpPerTb)
7507    {
7508       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, pdsch->maxCodeBlkGrpPerTb, sizeof(uint8_t));
7509    }
7510    if(pdsch->maxMimoLayers)
7511    {
7512       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, pdsch->maxMimoLayers, sizeof(uint8_t));
7513    }
7514 }
7515
7516 /*******************************************************************
7517  *
7518  * @brief Free Serving cell Info
7519  *
7520  * @details
7521  *
7522  *    Function : freeMacServingCellInfo
7523  *
7524  *    Functionality: Free Serving cell Info
7525  *
7526  * @params[in] ServCellCfgInfo *srvCellCfg
7527  * @return void
7528  *
7529  * ****************************************************************/
7530 void freeMacServingCellInfo(ServCellCfgInfo *srvCellCfg)
7531 {
7532    freeMacPdschServCellInfo(&srvCellCfg->pdschServCellCfg);
7533    if(srvCellCfg->bwpInactivityTmr)
7534    {
7535       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, srvCellCfg->bwpInactivityTmr, sizeof(uint8_t));
7536    }
7537 }
7538
7539 /*******************************************************************
7540  *
7541  * @brief Free cell Grp Cfg Info
7542  *
7543  * @details
7544  *
7545  *    Function : freeUeReCfgCellGrpInfo
7546  *
7547  *    Functionality: Free cell Grp Cfg Info
7548  *
7549  * @params[in] MacUeCfg*  duUeCfg
7550  * @return void
7551  *
7552  * ****************************************************************/
7553
7554 void freeUeReCfgCellGrpInfo(MacUeCfg *macUeCfg)
7555 {
7556    freeMacServingCellInfo(&macUeCfg->spCellCfg.servCellCfg);
7557 }
7558
7559 /*******************************************************************
7560  *
7561  * @brief Fills Reconfig SchReqReConfig
7562  *
7563  * @details
7564  *
7565  *    Function : extractSchReqReConfig
7566  *
7567  *    Functionality: Fills Reconfig SchReqReConfig
7568  *
7569  * @params[in] SchedulingRequestConfig_t *cuSchedReq
7570  *             SchedReqCfg*  macSchedReq
7571  * @return void
7572  *
7573  * ****************************************************************/
7574 void extractSchReqReConfig(SchedulingRequestConfig_t *cuSchedReq, SchedReqCfg *macSchedReq)
7575 {
7576    uint8_t schReqIdx = 0;
7577    struct SchedulingRequestConfig__schedulingRequestToAddModList *schReqListToAdd = NULLP;
7578    struct SchedulingRequestConfig__schedulingRequestToReleaseList *schReqListToRel = NULLP;
7579
7580    if(cuSchedReq->schedulingRequestToAddModList)
7581    {
7582       schReqListToAdd = cuSchedReq->schedulingRequestToAddModList;
7583       if(schReqListToAdd->list.count)
7584       {
7585          macSchedReq->addModListCount = schReqListToAdd->list.count;
7586          for(schReqIdx = 0; schReqIdx < schReqListToAdd->list.count; schReqIdx++)
7587          {
7588             macSchedReq->addModList[schReqIdx].schedReqId = \
7589                schReqListToAdd->list.array[schReqIdx]->schedulingRequestId;
7590             macSchedReq->addModList[schReqIdx].srProhibitTmr = \
7591                *(schReqListToAdd->list.array[schReqIdx]->sr_ProhibitTimer);
7592             macSchedReq->addModList[schReqIdx].srTransMax    =\
7593                schReqListToAdd->list.array[schReqIdx]->sr_TransMax;
7594          }
7595       }
7596    }
7597    /* Scheduling Req To release */
7598    if(cuSchedReq->schedulingRequestToReleaseList)
7599    {
7600       schReqListToRel = cuSchedReq->schedulingRequestToReleaseList;
7601       if(schReqListToRel->list.count)
7602       {
7603          macSchedReq->relListCount = schReqListToRel->list.count;
7604          for(schReqIdx = 0; schReqIdx < schReqListToRel->list.count; schReqIdx++)
7605          {
7606             macSchedReq->relList[schReqIdx] = \
7607                *schReqListToRel->list.array[schReqIdx];
7608          }
7609       }
7610    }
7611 }
7612
7613 /*******************************************************************
7614  *
7615  * @brief Fills TagReconfig
7616  *
7617  * @details
7618  *
7619  *    Function : extractTagReconfig
7620  *
7621  *    Functionality: Fills extractTagReconfig
7622  *
7623  * @params[in] TAG_Config_t *cuTagCfg
7624  *             TagCfg *macTagCfg
7625  * @return void
7626  *
7627  * ****************************************************************/
7628
7629 void extractTagReconfig(TAG_Config_t *cuTagCfg, TagCfg *macTagCfg)
7630 {
7631   uint8_t tagIdx = 0;
7632   struct TAG_Config__tag_ToAddModList  *tagListToAddMod = NULLP;
7633   struct TAG_Config__tag_ToReleaseList *tagListToRel = NULLP;
7634
7635   /* Tag config to AddMod */
7636   if(cuTagCfg->tag_ToAddModList)
7637   {
7638      tagListToAddMod = cuTagCfg->tag_ToAddModList;
7639      if(tagListToAddMod->list.count)
7640      {
7641         macTagCfg->addModListCount = tagListToAddMod->list.count;
7642         for(tagIdx = 0; tagIdx < tagListToAddMod->list.count; tagIdx++)
7643         {
7644            macTagCfg->addModList[tagIdx].tagId =\
7645               tagListToAddMod->list.array[tagIdx]->tag_Id;
7646            macTagCfg->addModList[tagIdx].timeAlignTimer = \
7647
7648               tagListToAddMod->list.array[tagIdx]->timeAlignmentTimer;
7649         }
7650      }
7651   }
7652   /* Tag config to release */
7653   if(cuTagCfg->tag_ToReleaseList)
7654   {
7655      tagListToRel = cuTagCfg->tag_ToReleaseList;
7656      if(tagListToRel->list.count)
7657      {
7658         macTagCfg->relListCount = tagListToRel->list.count;
7659         for(tagIdx = 0; tagIdx < tagListToRel->list.count; tagIdx++)
7660         {
7661            macTagCfg->relList[tagIdx] = *tagListToRel->list.array[tagIdx];
7662         }
7663      }
7664   }
7665 }
7666
7667 /*******************************************************************
7668  *
7669  * @brief Fills PdcchCfg received by CU
7670  *
7671  * @details
7672  *
7673  *    Function : extractPdcchCfg
7674  *
7675  *    Functionality: Fills PdcchCfg received  by CU
7676  *
7677  * @params[in] PDCCH_Config_t *cuPdcchCfg,
7678  *             PdcchConfig *duPdcchCfg
7679  * @return void
7680  *
7681  * ****************************************************************/
7682
7683 void extractPdcchCfg(PDCCH_Config_t *cuPdcchCfg, PdcchConfig *macPdcchCfg)
7684 {
7685    uint8_t cRsetIdx = 0;
7686    uint8_t srchSpcIdx = 0;
7687
7688    struct PDCCH_Config__controlResourceSetToAddModList *cRsetToAddModList = NULLP;
7689    struct PDCCH_Config__controlResourceSetToReleaseList *cRsetToRelList = NULLP;
7690    struct PDCCH_Config__searchSpacesToAddModList *srchSpcToAddModList = NULLP;
7691    struct PDCCH_Config__searchSpacesToReleaseList *srchSpcToRelList = NULLP;
7692
7693
7694    /* Control Resource Set To Add/Mod List */
7695    if(cuPdcchCfg->controlResourceSetToAddModList)
7696    {
7697       cRsetToAddModList = cuPdcchCfg->controlResourceSetToAddModList;
7698       if(cRsetToAddModList->list.count)
7699       {
7700          macPdcchCfg->numCRsetToAddMod = cRsetToAddModList->list.count;
7701          for(cRsetIdx = 0; cRsetIdx < cRsetToAddModList->list.count; cRsetIdx++)
7702          {
7703             macPdcchCfg->cRSetToAddModList[cRsetIdx].cRSetId = \
7704               cRsetToAddModList->list.array[cRsetIdx]->controlResourceSetId;
7705             bitStringToInt(&cRsetToAddModList->list.array[cRsetIdx]->frequencyDomainResources,\
7706                macPdcchCfg->cRSetToAddModList[cRsetIdx].freqDomainRsrc);
7707             macPdcchCfg->cRSetToAddModList[cRsetIdx].duration = \
7708               cRsetToAddModList->list.array[cRsetIdx]->duration;
7709
7710             macPdcchCfg->cRSetToAddModList[cRsetIdx].cceRegMappingType = \
7711               cRsetToAddModList->list.array[cRsetIdx]->cce_REG_MappingType.present;
7712             if(macPdcchCfg->cRSetToAddModList[cRsetIdx].cceRegMappingType == CCE_REG_MAPPINGTYPE_PR_INTERLEAVED)
7713             {
7714                //TODO: handle the case for Interleaved
7715             }
7716             macPdcchCfg->cRSetToAddModList[cRsetIdx].precoderGranularity = \
7717               cRsetToAddModList->list.array[cRsetIdx]->precoderGranularity;
7718             if(cRsetToAddModList->list.array[cRsetIdx]->pdcch_DMRS_ScramblingID)
7719             {
7720                macPdcchCfg->cRSetToAddModList[cRsetIdx].dmrsScramblingId= \
7721                   *(cRsetToAddModList->list.array[cRsetIdx]->pdcch_DMRS_ScramblingID);
7722             }
7723          }
7724       }
7725
7726    }
7727    /* Control Resource Set To Release List */
7728    if(cuPdcchCfg->controlResourceSetToReleaseList)
7729    {
7730       cRsetToRelList = cuPdcchCfg->controlResourceSetToReleaseList;
7731       if(cRsetToRelList->list.count)
7732       {
7733          macPdcchCfg->numCRsetToRel = cRsetToRelList->list.count;
7734          for(cRsetIdx = 0; cRsetIdx < cRsetToRelList->list.count; cRsetIdx++)
7735          {
7736             macPdcchCfg->cRSetToRelList[cRsetIdx] = *(cRsetToRelList->list.array[cRsetIdx]);
7737          }
7738       }
7739    }
7740
7741    /* Search space To Add/Mod List */
7742    if(cuPdcchCfg->searchSpacesToAddModList)
7743    {
7744       srchSpcToAddModList = cuPdcchCfg->searchSpacesToAddModList;
7745       if(srchSpcToAddModList->list.count)
7746       {
7747          macPdcchCfg->numSearchSpcToAddMod = srchSpcToAddModList->list.count;
7748          for(srchSpcIdx = 0; srchSpcIdx < srchSpcToAddModList->list.count; srchSpcIdx++)
7749          {
7750             macPdcchCfg->searchSpcToAddModList[srchSpcIdx].searchSpaceId =\
7751                srchSpcToAddModList->list.array[srchSpcIdx]->searchSpaceId;
7752             macPdcchCfg->searchSpcToAddModList[srchSpcIdx].cRSetId =\
7753                *(srchSpcToAddModList->list.array[srchSpcIdx]->controlResourceSetId);
7754             if(srchSpcToAddModList->list.array[srchSpcIdx]->monitoringSlotPeriodicityAndOffset)
7755             {
7756                macPdcchCfg->searchSpcToAddModList[srchSpcIdx].mSlotPeriodicityAndOffset =\
7757                   srchSpcToAddModList->list.array[srchSpcIdx]->monitoringSlotPeriodicityAndOffset->present;
7758             }
7759             if(srchSpcToAddModList->list.array[srchSpcIdx]->monitoringSymbolsWithinSlot)
7760             {
7761                bitStringToInt(srchSpcToAddModList->list.array[srchSpcIdx]->monitoringSymbolsWithinSlot,\
7762                   macPdcchCfg->searchSpcToAddModList[srchSpcIdx].mSymbolsWithinSlot);
7763             }
7764             if(srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates)
7765             {
7766               macPdcchCfg->searchSpcToAddModList[srchSpcIdx].numCandidatesAggLevel1 = \
7767                   srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates->aggregationLevel1;
7768               macPdcchCfg->searchSpcToAddModList[srchSpcIdx].numCandidatesAggLevel2 = \
7769                   srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates->aggregationLevel2;
7770               macPdcchCfg->searchSpcToAddModList[srchSpcIdx].numCandidatesAggLevel4 = \
7771                   srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates->aggregationLevel4;
7772
7773               macPdcchCfg->searchSpcToAddModList[srchSpcIdx].numCandidatesAggLevel8 = \
7774                   srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates->aggregationLevel8;
7775
7776               macPdcchCfg->searchSpcToAddModList[srchSpcIdx].numCandidatesAggLevel16 = \
7777                   srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates->aggregationLevel16;
7778             }
7779             if(srchSpcToAddModList->list.array[srchSpcIdx]->searchSpaceType)
7780             {
7781                macPdcchCfg->searchSpcToAddModList[srchSpcIdx].searchSpaceType =\
7782                   srchSpcToAddModList->list.array[srchSpcIdx]->searchSpaceType->present;
7783                if(macPdcchCfg->searchSpcToAddModList[srchSpcIdx].searchSpaceType == SEARCHSPACETYPE_PR_UE_SPECIFIC)
7784                {
7785                   macPdcchCfg->searchSpcToAddModList[srchSpcIdx].ueSpecificDciFormat =\
7786                      srchSpcToAddModList->list.array[srchSpcIdx]->searchSpaceType->choice.ue_Specific->dci_Formats;
7787                }
7788
7789             }
7790          }
7791       }
7792    }
7793    /* Search space To Rel List */
7794    if(cuPdcchCfg->searchSpacesToReleaseList)
7795    {
7796       srchSpcToRelList = cuPdcchCfg->searchSpacesToReleaseList;
7797       if(srchSpcToRelList->list.count)
7798       {
7799          macPdcchCfg->numSearchSpcToRel = srchSpcToRelList->list.count;
7800          for(srchSpcIdx = 0; srchSpcIdx < srchSpcToRelList->list.count; srchSpcIdx++)
7801          {
7802             macPdcchCfg->searchSpcToRelList[srchSpcIdx] =\
7803                *(srchSpcToRelList->list.array[srchSpcIdx]);
7804          }
7805       }
7806    }
7807 }
7808
7809 /*******************************************************************
7810  *
7811  * @brief Fills PdschCfg received by CU
7812  *
7813  * @details
7814  *
7815  *    Function : extractPdschCfg
7816  *
7817  *    Functionality: Fills PdschCfg received  by CU
7818  *
7819  * @params[in] PDSCH_Config_t *cuPdschCfg,
7820  *             PdschConfig *macPdschCfg
7821  * @return void
7822  *
7823  * ****************************************************************/
7824
7825 void extractPdschCfg(PDSCH_Config_t *cuPdschCfg, PdschConfig *macPdschCfg)
7826 {
7827    uint8_t timeDomIdx;
7828    struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAlloc = NULLP;
7829
7830    if(cuPdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA)
7831    {
7832       if(cuPdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA->present == \
7833          PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA_PR_setup)
7834       {
7835          if(cuPdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA->choice.setup)
7836          {
7837             macPdschCfg->dmrsDlCfgForPdschMapTypeA.addPos = \
7838                *(cuPdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA->choice.setup->dmrs_AdditionalPosition);
7839          }
7840       }
7841    }
7842    macPdschCfg->resourceAllocType = cuPdschCfg->resourceAllocation;
7843    if(cuPdschCfg->pdsch_TimeDomainAllocationList)
7844    {
7845       timeDomAlloc = cuPdschCfg->pdsch_TimeDomainAllocationList;
7846       if(timeDomAlloc->present ==\
7847          PDSCH_Config__pdsch_TimeDomainAllocationList_PR_setup)
7848       {
7849          if(timeDomAlloc->choice.setup)
7850          {
7851             macPdschCfg->numTimeDomRsrcAlloc  = timeDomAlloc->choice.setup->list.count;
7852             for(timeDomIdx = 0; timeDomIdx < timeDomAlloc->choice.setup->list.count; timeDomIdx++)
7853             {
7854                macPdschCfg->timeDomRsrcAllociList[timeDomIdx].mappingType = \
7855                   timeDomAlloc->choice.setup->list.array[timeDomIdx]->mappingType;
7856                macPdschCfg->timeDomRsrcAllociList[timeDomIdx].startSymbolAndLength = \
7857                   timeDomAlloc->choice.setup->list.array[timeDomIdx]->startSymbolAndLength;
7858             }
7859          }
7860       }
7861    }
7862    macPdschCfg->rbgSize = cuPdschCfg->rbg_Size;
7863    if(cuPdschCfg->maxNrofCodeWordsScheduledByDCI)
7864       macPdschCfg->numCodeWordsSchByDci = *(cuPdschCfg->maxNrofCodeWordsScheduledByDCI);
7865    if(cuPdschCfg->prb_BundlingType.present == PDSCH_Config__prb_BundlingType_PR_staticBundling)
7866    {
7867       macPdschCfg->bundlingType = cuPdschCfg->prb_BundlingType.present;
7868       if(cuPdschCfg->prb_BundlingType.choice.staticBundling)
7869       {
7870          if(cuPdschCfg->prb_BundlingType.choice.staticBundling->bundleSize)
7871          {
7872             macPdschCfg->bundlingInfo.StaticBundling.size = \
7873                *(cuPdschCfg->prb_BundlingType.choice.staticBundling->bundleSize);
7874          }
7875       }
7876    }
7877    else if(cuPdschCfg->prb_BundlingType.present == PDSCH_Config__prb_BundlingType_PR_dynamicBundling)
7878    {
7879       macPdschCfg->bundlingType = cuPdschCfg->prb_BundlingType.present;
7880    }
7881
7882 }
7883
7884 /*******************************************************************
7885  *
7886  * @brief Fills PdschServingCellCfg received by CU
7887  *
7888  * @details
7889  *
7890  *    Function : extractPdschServingCellCfg
7891  *
7892  *    Functionality: Fills PdschCfg received  by CU
7893  *
7894  * @params[in] PDSCH_ServingCellConfig_t *cuPdschSrvCellCfg,
7895  *             PdschServCellCfg *macUePdschSrvCellCfg
7896  * @return ROK/RFAILED
7897  *
7898  * ****************************************************************/
7899
7900 uint8_t extractPdschServingCellCfg(PDSCH_ServingCellConfig_t *cuPdschSrvCellCfg, PdschServCellCfg *macUePdschSrvCellCfg)
7901 {
7902    if(cuPdschSrvCellCfg->codeBlockGroupTransmission)
7903    {
7904       if(cuPdschSrvCellCfg->codeBlockGroupTransmission->choice.setup)
7905       {
7906          if(macUePdschSrvCellCfg->maxCodeBlkGrpPerTb)
7907          {
7908             *(macUePdschSrvCellCfg->maxCodeBlkGrpPerTb)  = \
7909                cuPdschSrvCellCfg->codeBlockGroupTransmission->choice.setup->maxCodeBlockGroupsPerTransportBlock;
7910          }
7911          else
7912          {
7913             DU_ALLOC_SHRABL_BUF(macUePdschSrvCellCfg->maxCodeBlkGrpPerTb, sizeof(uint8_t));
7914             if(macUePdschSrvCellCfg->maxCodeBlkGrpPerTb)
7915             {
7916                *(macUePdschSrvCellCfg->maxCodeBlkGrpPerTb)  = \
7917                   cuPdschSrvCellCfg->codeBlockGroupTransmission->choice.setup->maxCodeBlockGroupsPerTransportBlock;
7918             }
7919             else
7920             {
7921                DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for maxCodeBlkGrpPerTb at extractPdschServingCellCfg()");
7922                return RFAILED;
7923             }
7924          }
7925          if(macUePdschSrvCellCfg->codeBlkGrpFlushInd)
7926          {
7927             *(macUePdschSrvCellCfg->codeBlkGrpFlushInd)  = \
7928                cuPdschSrvCellCfg->codeBlockGroupTransmission->choice.setup->codeBlockGroupFlushIndicator;
7929          }
7930          else
7931          {
7932             DU_ALLOC_SHRABL_BUF(macUePdschSrvCellCfg->maxCodeBlkGrpPerTb, sizeof(bool));
7933             if(macUePdschSrvCellCfg->codeBlkGrpFlushInd)
7934             {
7935                *(macUePdschSrvCellCfg->codeBlkGrpFlushInd)  = \
7936                   cuPdschSrvCellCfg->codeBlockGroupTransmission->choice.setup->codeBlockGroupFlushIndicator;
7937             }
7938             else
7939             {
7940                DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for codeBlkGrpFlushInd at extractPdschServingCellCfg()");
7941                return RFAILED;
7942             }
7943          }
7944       }
7945    }
7946    if(cuPdschSrvCellCfg->nrofHARQ_ProcessesForPDSCH)
7947    {
7948       macUePdschSrvCellCfg->numHarqProcForPdsch = *(cuPdschSrvCellCfg->nrofHARQ_ProcessesForPDSCH);
7949    }
7950    if(cuPdschSrvCellCfg->ext1)
7951    {
7952       if(cuPdschSrvCellCfg->ext1->maxMIMO_Layers)
7953       {
7954         if(macUePdschSrvCellCfg->maxMimoLayers)
7955         {
7956            *(macUePdschSrvCellCfg->maxMimoLayers)  = *(cuPdschSrvCellCfg->ext1->maxMIMO_Layers);
7957         }
7958         else
7959         {
7960            DU_ALLOC_SHRABL_BUF(macUePdschSrvCellCfg->maxMimoLayers, sizeof(uint8_t));
7961            if(macUePdschSrvCellCfg->maxMimoLayers)
7962            {
7963               *(macUePdschSrvCellCfg->maxMimoLayers)  = *(cuPdschSrvCellCfg->ext1->maxMIMO_Layers);
7964            }
7965            else
7966            {
7967               DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for maxMimoLayers at extractPdschServingCellCfg()");
7968               return RFAILED;
7969            }
7970         }
7971       }
7972    }
7973    if(cuPdschSrvCellCfg->xOverhead)
7974    {
7975       if(macUePdschSrvCellCfg->xOverhead)
7976       {
7977          *(macUePdschSrvCellCfg->xOverhead)  = *(cuPdschSrvCellCfg->xOverhead);
7978       }
7979       else
7980       {
7981          DU_ALLOC_SHRABL_BUF(macUePdschSrvCellCfg->xOverhead, sizeof(uint8_t));
7982          if(macUePdschSrvCellCfg->xOverhead)
7983          {
7984             *(macUePdschSrvCellCfg->xOverhead)  = *(cuPdschSrvCellCfg->xOverhead);
7985          }
7986          else
7987          {
7988             DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for xOverhead at extractPdschServingCellCfg()");
7989             return RFAILED;
7990          }
7991       }
7992    }
7993    return ROK;
7994 }
7995
7996 /*******************************************************************
7997  *
7998  * @brief Fills PuschCfg received by CU
7999  *
8000  * @details
8001  *
8002  *    Function : extractPuschCfg
8003  *
8004  *    Functionality: Fills PuschCfg received  by CU
8005  *
8006  * @params[in] BWP_UplinkDedicated__pusch_Config *cuPuschCfg,
8007  *             PuschCfg *macPuschCfg
8008  * @return void
8009  *
8010  * ****************************************************************/
8011
8012 void extractPuschCfg(struct BWP_UplinkDedicated__pusch_Config *cuPuschCfg, PuschCfg *macPuschCfg)
8013 {
8014    uint8_t timeDomIdx = 0;
8015    DMRS_UplinkConfig_t *dmrsUlCfg = NULLP;
8016    struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList = NULLP;
8017
8018    if(cuPuschCfg->present == BWP_UplinkDedicated__pusch_Config_PR_setup)
8019    {
8020       if(cuPuschCfg->choice.setup)
8021       {
8022          if(cuPuschCfg->choice.setup->dataScramblingIdentityPUSCH)
8023          {
8024              macPuschCfg->dataScramblingId = \
8025                 *(cuPuschCfg->choice.setup->dataScramblingIdentityPUSCH);
8026          }
8027          if(cuPuschCfg->choice.setup->dmrs_UplinkForPUSCH_MappingTypeA)
8028          {
8029             if(cuPuschCfg->choice.setup->dmrs_UplinkForPUSCH_MappingTypeA->present == PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA_PR_setup)
8030             {
8031                if(cuPuschCfg->choice.setup->dmrs_UplinkForPUSCH_MappingTypeA->choice.setup)
8032                {
8033                   dmrsUlCfg = (cuPuschCfg->choice.setup->dmrs_UplinkForPUSCH_MappingTypeA->choice.setup);
8034                   if(dmrsUlCfg->dmrs_AdditionalPosition)
8035                   {
8036                      macPuschCfg->dmrsUlCfgForPuschMapTypeA.addPos =\
8037                         *(dmrsUlCfg->dmrs_AdditionalPosition);
8038                   }
8039                   if(dmrsUlCfg->transformPrecodingDisabled)
8040                   {
8041                      if(dmrsUlCfg->transformPrecodingDisabled->scramblingID0)
8042                      {
8043                         macPuschCfg->dmrsUlCfgForPuschMapTypeA.transPrecodDisabled.scramblingId0 = \
8044                            *(dmrsUlCfg->transformPrecodingDisabled->scramblingID0);
8045                      }
8046                   }
8047                }
8048             }
8049          }
8050          /*Res Alloc Type for UL */
8051          if(cuPuschCfg->choice.setup->resourceAllocation)
8052          {
8053             macPuschCfg->resourceAllocType = \
8054                cuPuschCfg->choice.setup->resourceAllocation;
8055          }
8056          if(cuPuschCfg->choice.setup->pusch_TimeDomainAllocationList)
8057          {
8058             timeDomAllocList = cuPuschCfg->choice.setup->pusch_TimeDomainAllocationList;
8059             if(timeDomAllocList->present == PUSCH_Config__pusch_TimeDomainAllocationList_PR_setup)
8060             {
8061                if(timeDomAllocList->choice.setup)
8062                {
8063                   macPuschCfg->numTimeDomRsrcAlloc = timeDomAllocList->choice.setup->list.count;
8064                   for(timeDomIdx = 0; timeDomIdx <timeDomAllocList->choice.setup->list.count; timeDomIdx++)
8065                   {
8066                      macPuschCfg->timeDomRsrcAllocList[timeDomIdx].k2 = \
8067                         *(timeDomAllocList->choice.setup->list.array[timeDomIdx]->k2);
8068                      macPuschCfg->timeDomRsrcAllocList[timeDomIdx].mappingType = \
8069                         timeDomAllocList->choice.setup->list.array[timeDomIdx]->mappingType;
8070                      macPuschCfg->timeDomRsrcAllocList[timeDomIdx].startSymbolAndLength = \
8071                         timeDomAllocList->choice.setup->list.array[timeDomIdx]->startSymbolAndLength;
8072                   }
8073                }
8074             }
8075          }
8076          if(cuPuschCfg->choice.setup->transformPrecoder)
8077             macPuschCfg->transformPrecoder = *(cuPuschCfg->choice.setup->transformPrecoder);
8078       }
8079    }
8080 }
8081
8082 /*******************************************************************
8083  *
8084  * @brief Function to fill pucch Power Control
8085  *
8086  * @details
8087  *
8088  *    Function : extractPucchPowerControl
8089  *
8090  *    Functionality: Function to fill pucch Power Control
8091  *
8092  * @params[in] PucchPowerControl *pwrCtrl,
8093  *             struct PUCCH_PowerControl *cuPwrCtrlCfg
8094  * @return void
8095  *
8096  * ****************************************************************/
8097
8098 void extractPucchPowerControl(PucchPowerControl *pwrCtrl, struct PUCCH_PowerControl *cuPwrCtrlCfg)
8099 {
8100    uint8_t arrIdx;
8101
8102    if(cuPwrCtrlCfg->deltaF_PUCCH_f0)
8103       pwrCtrl->deltaF_Format0 = *cuPwrCtrlCfg->deltaF_PUCCH_f0;
8104    if(cuPwrCtrlCfg->deltaF_PUCCH_f1)
8105       pwrCtrl->deltaF_Format1 = *cuPwrCtrlCfg->deltaF_PUCCH_f1;
8106    if(cuPwrCtrlCfg->deltaF_PUCCH_f2)
8107       pwrCtrl->deltaF_Format2 = *cuPwrCtrlCfg->deltaF_PUCCH_f2;
8108    if(cuPwrCtrlCfg->deltaF_PUCCH_f3)
8109       pwrCtrl->deltaF_Format3 = *cuPwrCtrlCfg->deltaF_PUCCH_f3;
8110    if(cuPwrCtrlCfg->deltaF_PUCCH_f4)
8111       pwrCtrl->deltaF_Format4 = *cuPwrCtrlCfg->deltaF_PUCCH_f4;
8112    if(cuPwrCtrlCfg->p0_Set)
8113    {
8114       pwrCtrl->p0SetCount = cuPwrCtrlCfg->p0_Set->list.count;
8115       for(arrIdx=0; arrIdx < pwrCtrl->p0SetCount; arrIdx++)
8116       {
8117          pwrCtrl->p0Set[arrIdx].p0PucchId =\
8118             cuPwrCtrlCfg->p0_Set->list.array[arrIdx]->p0_PUCCH_Id;
8119          pwrCtrl->p0Set[arrIdx].p0PucchVal =\
8120             cuPwrCtrlCfg->p0_Set->list.array[arrIdx]->p0_PUCCH_Value;
8121       }
8122    }
8123    if(cuPwrCtrlCfg->pathlossReferenceRSs)
8124    {
8125       pwrCtrl->pathLossRefRSListCount = cuPwrCtrlCfg->pathlossReferenceRSs->list.count;
8126       for(arrIdx = 0; arrIdx < pwrCtrl->pathLossRefRSListCount; arrIdx++)
8127       {
8128          pwrCtrl->pathLossRefRSList[arrIdx].pathLossRefRSId =\
8129             cuPwrCtrlCfg->pathlossReferenceRSs->list.array[arrIdx]->pucch_PathlossReferenceRS_Id;
8130       }
8131    }
8132 }
8133
8134  /*******************************************************************
8135  *
8136  * @brief Function to extractResrcSetToAddModList sent by CU
8137  *
8138  * @details
8139  *
8140  *    Function : extractResrcSetToAddModList
8141  *
8142  *    Functionality: Fucntion to extractResrcSetToAddModList
8143  *
8144  * @params[in] PucchResrcSetCfg pointer,
8145  *             struct PUCCH_Config__resourceSetToAddModList pointer
8146  * @return void
8147  *
8148  * ****************************************************************/
8149
8150 void extractResrcSetToAddModList(PucchResrcSetCfg *macRsrcSetList, struct PUCCH_Config__resourceSetToAddModList *cuRsrcSetList)
8151 {
8152    uint8_t arrIdx, rsrcListIdx;
8153
8154    macRsrcSetList->resrcSetToAddModListCount = cuRsrcSetList->list.count;
8155    for(arrIdx = 0; arrIdx < macRsrcSetList->resrcSetToAddModListCount; arrIdx++)
8156    {
8157       macRsrcSetList->resrcSetToAddModList[arrIdx].resrcSetId     =\
8158          cuRsrcSetList->list.array[arrIdx]->pucch_ResourceSetId;
8159       macRsrcSetList->resrcSetToAddModList[arrIdx].resrcListCount =\
8160          cuRsrcSetList->list.array[arrIdx]->resourceList.list.count;
8161       for(rsrcListIdx = 0; rsrcListIdx < macRsrcSetList->resrcSetToAddModList[arrIdx].resrcListCount; rsrcListIdx++)
8162       {
8163          macRsrcSetList->resrcSetToAddModList[arrIdx].resrcList[rsrcListIdx] =\
8164             *cuRsrcSetList->list.array[arrIdx]->resourceList.list.array[rsrcListIdx];
8165       }
8166       macRsrcSetList->resrcSetToAddModList[arrIdx].maxPayLoadSize =\
8167          *cuRsrcSetList->list.array[arrIdx]->maxPayloadMinus1;
8168    }
8169 }/* End of extractResrcSetToAddModList */
8170
8171 /*******************************************************************
8172  *
8173  * @brief Fills extractResrcToAddModList sent by CU
8174  *
8175  * @details
8176  *
8177  *    Function : extractResrcToAddModList
8178  *
8179  *    Functionality: Fills extractResrcToAddModList
8180  *
8181  * @params[in] PucchResrcCfg pointer,
8182  *             struct PUCCH_Config__resourceToAddModList pointer
8183  * @return ROk/RFAILED
8184  *
8185  * ****************************************************************/
8186
8187 uint8_t extractResrcToAddModList(PucchResrcCfg *macResrcList, struct PUCCH_Config__resourceToAddModList *cuResrcList)
8188 {
8189    uint8_t arrIdx;
8190
8191    macResrcList->resrcToAddModListCount = cuResrcList->list.count;
8192    for(arrIdx = 0; arrIdx < macResrcList->resrcToAddModListCount; arrIdx++)
8193    {
8194       macResrcList->resrcToAddModList[arrIdx].resrcId      =\
8195         cuResrcList->list.array[arrIdx]->pucch_ResourceId;
8196       macResrcList->resrcToAddModList[arrIdx].startPrb     =\
8197         cuResrcList->list.array[arrIdx]->startingPRB;
8198       if(cuResrcList->list.array[arrIdx]->intraSlotFrequencyHopping)
8199       {
8200          macResrcList->resrcToAddModList[arrIdx].intraFreqHop =\
8201            *cuResrcList->list.array[arrIdx]->intraSlotFrequencyHopping;
8202       }
8203       if(cuResrcList->list.array[arrIdx]->secondHopPRB)
8204       {
8205          macResrcList->resrcToAddModList[arrIdx].secondPrbHop =\
8206            *cuResrcList->list.array[arrIdx]->secondHopPRB;
8207       }
8208       /* PUCCH RSRC FORMAT */
8209       if(cuResrcList->list.array[arrIdx]->format.present == PUCCH_Resource__format_PR_format0)
8210       {
8211          macResrcList->resrcToAddModList[arrIdx].pucchFormat = PUCCH_FORMAT_0;
8212          if(cuResrcList->list.array[arrIdx]->format.choice.format0)
8213          {
8214             DU_ALLOC_SHRABL_BUF(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format0, sizeof(PucchFormat0));
8215             if(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format0 == NULLP)
8216             {
8217                DU_LOG("\nERROR  --> F1AP : Failed to allocate memory for Format0 in extractResrcToAddModList()");
8218                return RFAILED;
8219             }
8220             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format0->initialCyclicShift =\
8221                cuResrcList->list.array[arrIdx]->format.choice.format0->initialCyclicShift;
8222             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format0->numSymbols =\
8223                cuResrcList->list.array[arrIdx]->format.choice.format0->nrofSymbols;
8224             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format0->startSymbolIdx =\
8225                cuResrcList->list.array[arrIdx]->format.choice.format0->startingSymbolIndex;
8226          }
8227       }
8228       else if(cuResrcList->list.array[arrIdx]->format.present == PUCCH_Resource__format_PR_format1)
8229       {
8230          macResrcList->resrcToAddModList[arrIdx].pucchFormat = PUCCH_FORMAT_1;
8231          if(cuResrcList->list.array[arrIdx]->format.choice.format1)
8232          {
8233             DU_ALLOC_SHRABL_BUF(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1, sizeof(PucchFormat1));
8234             if(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1 == NULLP)
8235             {
8236                DU_LOG("\nERROR  --> F1AP : Failed to allocate memory for Format1 in extractResrcToAddModList()");
8237                return RFAILED;
8238             }
8239             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1->initialCyclicShift =\
8240                 cuResrcList->list.array[arrIdx]->format.choice.format1->initialCyclicShift;
8241             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1->numSymbols =\
8242                 cuResrcList->list.array[arrIdx]->format.choice.format1->nrofSymbols;
8243             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1->startSymbolIdx =\
8244                 cuResrcList->list.array[arrIdx]->format.choice.format1->startingSymbolIndex;
8245             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1->timeDomOCC =\
8246                 cuResrcList->list.array[arrIdx]->format.choice.format1->timeDomainOCC;
8247          }
8248       }
8249       else if(cuResrcList->list.array[arrIdx]->format.present == PUCCH_Resource__format_PR_format2)
8250       {
8251          macResrcList->resrcToAddModList[arrIdx].pucchFormat = PUCCH_FORMAT_2;
8252          if(cuResrcList->list.array[arrIdx]->format.choice.format2)
8253          {
8254             DU_ALLOC_SHRABL_BUF(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format2, sizeof(PucchFormat2_3));
8255             if(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format2 == NULLP)
8256             {
8257                DU_LOG("\nERROR  --> F1AP : Failed to allocate memory for Format2 in extractResrcToAddModList()");
8258                return RFAILED;
8259             }
8260             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format2->numPrbs =\
8261                 cuResrcList->list.array[arrIdx]->format.choice.format2->nrofPRBs;
8262             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format2->numSymbols =\
8263                 cuResrcList->list.array[arrIdx]->format.choice.format2->nrofSymbols;
8264             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format2->startSymbolIdx =\
8265                 cuResrcList->list.array[arrIdx]->format.choice.format2->startingSymbolIndex;
8266          }
8267       }
8268       else if(cuResrcList->list.array[arrIdx]->format.present == PUCCH_Resource__format_PR_format3)
8269       {
8270          macResrcList->resrcToAddModList[arrIdx].pucchFormat = PUCCH_FORMAT_3;
8271          if(cuResrcList->list.array[arrIdx]->format.choice.format3)
8272          {
8273             DU_ALLOC_SHRABL_BUF(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format3, sizeof(PucchFormat2_3));
8274             if(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format3 == NULLP)
8275             {
8276                DU_LOG("\nERROR  --> F1AP : Failed to allocate memory for Format3 in extractResrcToAddModList()");
8277                return RFAILED;
8278             }
8279             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format3->numPrbs =\
8280                 cuResrcList->list.array[arrIdx]->format.choice.format3->nrofPRBs;
8281             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format3->numSymbols =\
8282                 cuResrcList->list.array[arrIdx]->format.choice.format3->nrofSymbols;
8283             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format3->startSymbolIdx =\
8284                 cuResrcList->list.array[arrIdx]->format.choice.format3->startingSymbolIndex;
8285          }
8286       }
8287       else if(cuResrcList->list.array[arrIdx]->format.present == PUCCH_Resource__format_PR_format4)
8288       {
8289          macResrcList->resrcToAddModList[arrIdx].pucchFormat = PUCCH_FORMAT_4;
8290          if(cuResrcList->list.array[arrIdx]->format.choice.format4)
8291          {
8292             DU_ALLOC_SHRABL_BUF(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4, sizeof(PucchFormat4));
8293             if(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4 == NULLP)
8294             {
8295                DU_LOG("\nERROR  --> F1AP : Failed to allocate memory for Format4 in extractResrcToAddModList()");
8296                return RFAILED;
8297             }
8298             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4->numSymbols =\
8299                 cuResrcList->list.array[arrIdx]->format.choice.format4->nrofSymbols;
8300             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4->occLen =\
8301                 cuResrcList->list.array[arrIdx]->format.choice.format4->occ_Length;
8302             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4->occIdx =\
8303                 cuResrcList->list.array[arrIdx]->format.choice.format4->occ_Index;
8304             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4->startSymbolIdx =\
8305                 cuResrcList->list.array[arrIdx]->format.choice.format4->startingSymbolIndex;
8306          }
8307       }
8308    }
8309    return ROK;
8310
8311 }/* End of extractResrcToAddModList */
8312
8313 /*******************************************************************
8314  *
8315  * @brief Fills fillPucchSchedReqPeriodAndOffset sent by CU
8316  *
8317  * @details
8318  *
8319  *    Function : fillPucchSchedReqPeriodAndOffset
8320  *
8321  *    Functionality: To fillPucchSchedReqPeriodAndOffset
8322  *
8323  * @params[in] macPeriodicty,
8324  *     SchedulingRequestResourceConfig__periodicityAndOffset pointer
8325  * @return void
8326  *
8327  * ****************************************************************/
8328
8329 void fillPucchSchedReqPeriodAndOffset(uint8_t macPeriodicty, uint16_t  macOffset,\
8330    struct SchedulingRequestResourceConfig__periodicityAndOffset *cuPeriodicty)
8331 {
8332    macPeriodicty = cuPeriodicty->present;
8333    switch(macPeriodicty)
8334    {
8335       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sym2:
8336          {
8337             macOffset     = cuPeriodicty->choice.sym2;
8338             break;
8339          }
8340       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sym6or7:
8341          {
8342             macOffset     = cuPeriodicty->choice.sym6or7;
8343             break;
8344          }
8345       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl1:
8346          {
8347             macOffset     = cuPeriodicty->choice.sl1;
8348             break;
8349          }
8350       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl2:
8351          {
8352             macOffset = cuPeriodicty->choice.sl2;
8353             break;
8354          }
8355       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl4:
8356          {
8357             macOffset = cuPeriodicty->choice.sl4;
8358             break;
8359          }
8360       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl5:
8361          {
8362             macOffset = cuPeriodicty->choice.sl5;
8363             break;
8364          }
8365       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl8:
8366          {
8367             macOffset = cuPeriodicty->choice.sl8;
8368             break;
8369          }
8370       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl10:
8371          {
8372             macOffset = cuPeriodicty->choice.sl10;
8373             break;
8374          }
8375       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl16:
8376          {
8377             macOffset = cuPeriodicty->choice.sl16;
8378             break;
8379          }
8380       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl20:
8381          {
8382             macOffset = cuPeriodicty->choice.sl20;
8383             break;
8384          }
8385       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl40:
8386          {
8387             macOffset = cuPeriodicty->choice.sl40;
8388             break;
8389          }
8390       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl80:
8391          {
8392             macOffset = cuPeriodicty->choice.sl80;
8393             break;
8394          }
8395       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl160:
8396          {
8397             macOffset = cuPeriodicty->choice.sl160;
8398             break;
8399          }
8400       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl320:
8401          {
8402             macOffset = cuPeriodicty->choice.sl320;
8403             break;
8404          }
8405       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl640:
8406          {
8407             macOffset = cuPeriodicty->choice.sl640;
8408             break;
8409          }
8410       default :
8411          DU_LOG("\nERROR  -->  F1AP : Invalid periodicity %d", macPeriodicty);
8412    }
8413 }
8414
8415 /*******************************************************************
8416  *
8417  * @brief Function to extractPucchFormatCfg sent by CU
8418  *
8419  * @details
8420  *
8421  *    Function : extractPucchFormatCfg
8422  *
8423  *    Functionality: Function to extractPucchFormatCfg
8424  *
8425  * @params[in] PucchFormatCfg pointer,
8426  *             PUCCH_FormatConfig_t pointer
8427  * @return void
8428  *
8429  * ****************************************************************/
8430
8431 void extractPucchFormatCfg(PucchFormatCfg *macFormatCfg, PUCCH_FormatConfig_t *cuFormatCfg)
8432  {
8433     if(cuFormatCfg->interslotFrequencyHopping)
8434        macFormatCfg->interSlotFreqHop = *cuFormatCfg->interslotFrequencyHopping;
8435     if(cuFormatCfg->additionalDMRS)
8436        macFormatCfg->addDmrs = *cuFormatCfg->additionalDMRS;
8437     if(cuFormatCfg->maxCodeRate)
8438        macFormatCfg->maxCodeRate = *cuFormatCfg->maxCodeRate;
8439     if(cuFormatCfg->nrofSlots)
8440        macFormatCfg->numSlots = *cuFormatCfg->nrofSlots;
8441     if(cuFormatCfg->pi2BPSK)
8442        macFormatCfg->pi2BPSK = *cuFormatCfg->pi2BPSK;
8443     if(cuFormatCfg->simultaneousHARQ_ACK_CSI)
8444        macFormatCfg->harqAckCSI = *cuFormatCfg->simultaneousHARQ_ACK_CSI;
8445  }/* End of extractPucchFormatCfg */
8446
8447 /*******************************************************************
8448  *
8449  * @brief Function to extractSchedReqCfgToAddMod sent by CU
8450  *
8451  * @details
8452  *
8453  *    Function : extractSchedReqCfgToAddMod
8454  *
8455  *    Functionality: Function to extractSchedReqCfgToAddMod
8456  *
8457  * @params[in] PucchSchedReqCfg pointer,
8458  *      PUCCH_Config__schedulingRequestResourceToAddModList pointer
8459  * @return void
8460  *
8461  * ****************************************************************/
8462
8463 void extractSchedReqCfgToAddMod(PucchSchedReqCfg *macSchedReqCfg, struct PUCCH_Config__schedulingRequestResourceToAddModList *cuSchedReqList)
8464 {
8465    uint8_t arrIdx;
8466
8467    macSchedReqCfg->schedAddModListCount = cuSchedReqList->list.count;
8468    for(arrIdx = 0; arrIdx <  macSchedReqCfg->schedAddModListCount; arrIdx++)
8469    {
8470       macSchedReqCfg->schedAddModList[arrIdx].resrcId =\
8471          cuSchedReqList->list.array[arrIdx]->schedulingRequestResourceId;
8472       macSchedReqCfg->schedAddModList[arrIdx].requestId =\
8473          cuSchedReqList->list.array[arrIdx]->schedulingRequestID;
8474       if(cuSchedReqList->list.array[arrIdx]->periodicityAndOffset)
8475       {
8476          fillPucchSchedReqPeriodAndOffset(macSchedReqCfg->schedAddModList[arrIdx].periodicity,\
8477             macSchedReqCfg->schedAddModList[arrIdx].offset, cuSchedReqList->list.array[arrIdx]->periodicityAndOffset);
8478       }
8479       if(cuSchedReqList->list.array[arrIdx]->resource)
8480       {
8481          macSchedReqCfg->schedAddModList[arrIdx].resrc =\
8482             *cuSchedReqList->list.array[arrIdx]->resource;
8483       }
8484    }
8485
8486 }/* End of extractSchedReqCfgToAddMod */
8487
8488  /*******************************************************************
8489  *
8490  * @brief Fills PucchCfg received by CU
8491  *
8492  * @details
8493  *
8494  *    Function : extractPucchCfg
8495  *
8496  *    Functionality: Fills PucchCfg received  by CU
8497  *
8498  * @params[in] BWP_UplinkDedicated__pucch_Config *cuPucchCfg,
8499  *             PucchCfg *macPucchCfg
8500  * @return ROK/RFAILED
8501  *
8502  * ****************************************************************/
8503
8504 uint8_t extractPucchCfg(struct BWP_UplinkDedicated__pucch_Config *cuPucchCfg, PucchCfg *macPucchCfg)
8505 {
8506    uint8_t arrIdx;
8507
8508    if(cuPucchCfg->present == BWP_UplinkDedicated__pucch_Config_PR_setup)
8509    {
8510       if(cuPucchCfg->choice.setup)
8511       {
8512          /* Resource Set Cfg */
8513          if(cuPucchCfg->choice.setup->resourceSetToAddModList)
8514          {
8515             DU_ALLOC_SHRABL_BUF(macPucchCfg->resrcSet, sizeof(PucchResrcSetCfg));
8516             if(macPucchCfg->resrcSet == NULLP)
8517             {
8518                DU_LOG("\nERROR --> F1AP : Failed to extract Resrc set List in extractPucchCfg()");
8519                return RFAILED;
8520             }
8521             memset(macPucchCfg->resrcSet, 0, sizeof(PucchResrcSetCfg));
8522             extractResrcSetToAddModList(macPucchCfg->resrcSet, cuPucchCfg->choice.setup->resourceSetToAddModList);
8523          }
8524
8525          /* Resource Cfg */
8526          if(cuPucchCfg->choice.setup->resourceToAddModList)
8527          {
8528             DU_ALLOC_SHRABL_BUF(macPucchCfg->resrc, sizeof(PucchResrcCfg));
8529             if(macPucchCfg->resrc == NULLP)
8530             {
8531                DU_LOG("\nERROR --> F1AP : Failed to extract Resrc List in extractPucchCfg()");
8532                return RFAILED;
8533             }
8534             memset(macPucchCfg->resrc, 0, sizeof(PucchResrcCfg));
8535             extractResrcToAddModList(macPucchCfg->resrc, cuPucchCfg->choice.setup->resourceToAddModList);
8536          }
8537
8538          /* Format 1 Cfg */
8539          if(cuPucchCfg->choice.setup->format1)
8540          {
8541             DU_ALLOC_SHRABL_BUF(macPucchCfg->format1, sizeof(PucchFormatCfg));
8542             if(macPucchCfg->format1 == NULLP)
8543             {
8544                DU_LOG("\nERROR --> F1AP : Failed to extract format 1 Cfg in  extractPucchCfg()");
8545                return RFAILED;
8546             }
8547             memset(macPucchCfg->format1, 0, sizeof(PucchFormatCfg));
8548             extractPucchFormatCfg(macPucchCfg->format1,\
8549                cuPucchCfg->choice.setup->format1->choice.setup);
8550          }
8551
8552          /* Format 2 Cfg */
8553          if(cuPucchCfg->choice.setup->format2)
8554          {
8555             DU_ALLOC_SHRABL_BUF(macPucchCfg->format2, sizeof(PucchFormatCfg));
8556             if(macPucchCfg->format2 == NULLP)
8557             {
8558                DU_LOG("\nERROR --> F1AP : Failed to extract format 2 Cfg in  extractPucchCfg()");
8559                return RFAILED;
8560             }
8561             memset(macPucchCfg->format2, 0, sizeof(PucchFormatCfg));
8562             extractPucchFormatCfg(macPucchCfg->format2,\
8563                cuPucchCfg->choice.setup->format2->choice.setup);
8564          }
8565
8566          /* Format 3 Cfg */
8567          if(cuPucchCfg->choice.setup->format3)
8568          {
8569             DU_ALLOC_SHRABL_BUF(macPucchCfg->format3, sizeof(PucchFormatCfg));
8570             if(macPucchCfg->format3 == NULLP)
8571             {
8572                DU_LOG("\nERROR --> F1AP : Failed to extract format 3 Cfg in  extractPucchCfg()");
8573                return RFAILED;
8574             }
8575             memset(macPucchCfg->format3, 0, sizeof(PucchFormatCfg));
8576             extractPucchFormatCfg(macPucchCfg->format3,\
8577                cuPucchCfg->choice.setup->format3->choice.setup);
8578          }
8579
8580          /* Format 4 Cfg */
8581          if(cuPucchCfg->choice.setup->format4)
8582          {
8583             DU_ALLOC_SHRABL_BUF(macPucchCfg->format4, sizeof(PucchFormatCfg));
8584             if(macPucchCfg->format4 == NULLP)
8585             {
8586                DU_LOG("\nERROR --> F1AP : Failed to extract format 4 Cfg in  extractPucchCfg()");
8587                return RFAILED;
8588             }
8589             memset(macPucchCfg->format4, 0, sizeof(PucchFormatCfg));
8590             extractPucchFormatCfg(macPucchCfg->format4,\
8591                cuPucchCfg->choice.setup->format4->choice.setup);
8592          }
8593
8594          /* Sched Req List */
8595          if(cuPucchCfg->choice.setup->schedulingRequestResourceToAddModList)
8596          {
8597             DU_ALLOC_SHRABL_BUF(macPucchCfg->schedReq, sizeof(PucchSchedReqCfg));
8598             if(macPucchCfg->schedReq == NULLP)
8599             {
8600                DU_LOG("\nERROR --> F1AP : Failed to extract schedReqCfg in  extractPucchCfg()");
8601                return RFAILED;
8602             }
8603             memset(macPucchCfg->schedReq, 0, sizeof(PucchSchedReqCfg));
8604             extractSchedReqCfgToAddMod(macPucchCfg->schedReq,\
8605             cuPucchCfg->choice.setup->schedulingRequestResourceToAddModList);
8606          }
8607
8608          /*TODO: Add support for  Spatial Info */
8609
8610          /* MultiCsiCfg */
8611          if(cuPucchCfg->choice.setup->multi_CSI_PUCCH_ResourceList)
8612          {
8613             DU_ALLOC_SHRABL_BUF(macPucchCfg->multiCsiCfg, sizeof(PucchMultiCsiCfg));
8614             if(macPucchCfg->multiCsiCfg == NULLP)
8615             {
8616                DU_LOG("\nERROR --> F1AP : Failed to extract multiCsiCfg in  extractPucchCfg()");
8617                return RFAILED;
8618             }
8619             memset(macPucchCfg->multiCsiCfg, 0, sizeof(PucchMultiCsiCfg));
8620             macPucchCfg->multiCsiCfg->multiCsiResrcListCount = cuPucchCfg->choice.setup->multi_CSI_PUCCH_ResourceList->list.count;
8621             for(arrIdx =0; arrIdx < macPucchCfg->multiCsiCfg->multiCsiResrcListCount; arrIdx++)
8622             {
8623                macPucchCfg->multiCsiCfg->multiCsiResrcList[arrIdx] =\
8624                  *cuPucchCfg->choice.setup->multi_CSI_PUCCH_ResourceList->list.array[arrIdx];
8625             }
8626          }
8627
8628          /* Dl_DataToUL_ACK */
8629          if(cuPucchCfg->choice.setup->dl_DataToUL_ACK)
8630          {
8631             DU_ALLOC_SHRABL_BUF(macPucchCfg->dlDataToUlAck, sizeof(PucchDlDataToUlAck));
8632             if(macPucchCfg->dlDataToUlAck == NULLP)
8633             {
8634                DU_LOG("\nERROR --> F1AP : Failed to extract Dl_DataToUL_ACK in extractPucchCfg()");
8635                return RFAILED;
8636             }
8637             memset(macPucchCfg->dlDataToUlAck, 0, sizeof(PucchDlDataToUlAck));
8638             macPucchCfg->dlDataToUlAck->dlDataToUlAckListCount = cuPucchCfg->choice.setup->dl_DataToUL_ACK->list.count;
8639             for(arrIdx = 0; arrIdx < macPucchCfg->dlDataToUlAck->dlDataToUlAckListCount; arrIdx++)
8640             {
8641                macPucchCfg->dlDataToUlAck->dlDataToUlAckList[arrIdx] =\
8642                   *cuPucchCfg->choice.setup->dl_DataToUL_ACK->list.array[arrIdx];
8643             }
8644          }
8645
8646          /* Power Control */
8647          if(cuPucchCfg->choice.setup->pucch_PowerControl)
8648          {
8649             DU_ALLOC_SHRABL_BUF(macPucchCfg->powerControl, sizeof(PucchPowerControl));
8650             if(macPucchCfg->powerControl == NULLP)
8651             {
8652                DU_LOG("\nERROR --> F1AP : Failed to extract power control in extractPucchCfg()");
8653                return RFAILED;
8654             }
8655             extractPucchPowerControl(macPucchCfg->powerControl,\
8656                cuPucchCfg->choice.setup->pucch_PowerControl);
8657          }
8658       }
8659    }
8660    return ROK;
8661 }
8662
8663 /*******************************************************************
8664  *
8665  * @brief Fills ServingCellReconfig received by CU
8666  *
8667  * @details
8668  *
8669  *    Function : extractSpCellDedicatedCfg
8670  *
8671  *    Functionality: Fills ServingCellReconfig received  by CU
8672  *
8673  * @params[in] ServingCellConfig_t *cuSrvCellCfg
8674  *             ServCellCfgInfo *macSrvCellCfg
8675  * @return ROK/RFAILD
8676  *
8677  * ****************************************************************/
8678 uint8_t extractSpCellDedicatedCfg(ServingCellConfig_t *cuSrvCellCfg, ServCellCfgInfo *macSrvCellCfg)
8679 {
8680    uint8_t ret = ROK;
8681    BWP_DownlinkDedicated_t *dlBwp = NULLP;
8682    BWP_UplinkDedicated_t   *ulBwp = NULLP;
8683
8684    if(cuSrvCellCfg->initialDownlinkBWP)
8685    {
8686       dlBwp = ((BWP_DownlinkDedicated_t *)(cuSrvCellCfg->initialDownlinkBWP));
8687       if(dlBwp->pdcch_Config)
8688       {
8689          if(dlBwp->pdcch_Config->choice.setup)
8690          {
8691             macSrvCellCfg->initDlBwp.pdcchPresent = true;
8692             extractPdcchCfg(dlBwp->pdcch_Config->choice.setup, &macSrvCellCfg->initDlBwp.pdcchCfg);
8693          }
8694       }
8695       if(dlBwp->pdsch_Config)
8696       {
8697          if(dlBwp->pdsch_Config->choice.setup)
8698          {
8699             macSrvCellCfg->initDlBwp.pdschPresent = true;
8700             extractPdschCfg(dlBwp->pdsch_Config->choice.setup, &macSrvCellCfg->initDlBwp.pdschCfg);
8701          }
8702       }
8703    }
8704    if(cuSrvCellCfg->firstActiveDownlinkBWP_Id)
8705       macSrvCellCfg->firstActvDlBwpId = *(cuSrvCellCfg->firstActiveDownlinkBWP_Id);
8706    if(cuSrvCellCfg->defaultDownlinkBWP_Id)
8707       macSrvCellCfg->defaultDlBwpId = *(cuSrvCellCfg->defaultDownlinkBWP_Id);
8708    if(cuSrvCellCfg->bwp_InactivityTimer)
8709    {
8710       if(macSrvCellCfg->bwpInactivityTmr)
8711       {
8712          memcpy(macSrvCellCfg->bwpInactivityTmr, cuSrvCellCfg->bwp_InactivityTimer, sizeof(uint8_t));
8713       }
8714       else
8715       {
8716          macSrvCellCfg->bwpInactivityTmr = NULLP;
8717          DU_ALLOC_SHRABL_BUF(macSrvCellCfg->bwpInactivityTmr, sizeof(uint8_t));
8718          if(macSrvCellCfg->bwpInactivityTmr)
8719          {
8720             memcpy(macSrvCellCfg->bwpInactivityTmr, cuSrvCellCfg->bwp_InactivityTimer, sizeof(uint8_t));
8721          }
8722          else
8723          {
8724             DU_LOG("\nERROR  --> F1AP : Memory Alloc failed for bwpInactivityTmr at extractSpCellDedicatedCfg()");
8725             return RFAILED;
8726          }
8727       }
8728    }
8729    if(cuSrvCellCfg->pdsch_ServingCellConfig)
8730    {
8731       if(cuSrvCellCfg->pdsch_ServingCellConfig->choice.setup)
8732       {
8733          ret = extractPdschServingCellCfg(cuSrvCellCfg->pdsch_ServingCellConfig->choice.setup, &macSrvCellCfg->pdschServCellCfg);
8734          if(ret == RFAILED)
8735          {
8736             DU_LOG("\nERROR --> F1AP : Failed at extractPdschServingCellCfg()");
8737             return RFAILED;
8738          }
8739       }
8740    }
8741    if(cuSrvCellCfg->uplinkConfig)
8742    {
8743      if(cuSrvCellCfg->uplinkConfig->initialUplinkBWP)
8744      {
8745         ulBwp = ((BWP_UplinkDedicated_t *)(cuSrvCellCfg->uplinkConfig->initialUplinkBWP));
8746         if(ulBwp->pusch_Config)
8747         {
8748            macSrvCellCfg->initUlBwp.puschPresent = true;
8749            extractPuschCfg(ulBwp->pusch_Config, &macSrvCellCfg->initUlBwp.puschCfg);
8750         }
8751         if(ulBwp->pucch_Config)
8752         {
8753            macSrvCellCfg->initUlBwp.pucchPresent = true;
8754            memset(&macSrvCellCfg->initUlBwp.pucchCfg, 0, sizeof(PucchCfg));
8755            extractPucchCfg(ulBwp->pucch_Config, &macSrvCellCfg->initUlBwp.pucchCfg);
8756         }
8757      }
8758      if(cuSrvCellCfg->uplinkConfig->firstActiveUplinkBWP_Id)
8759         macSrvCellCfg->firstActvUlBwpId = *(cuSrvCellCfg->uplinkConfig->firstActiveUplinkBWP_Id);
8760    }
8761    return ret;
8762 }
8763 /*******************************************************************
8764  *
8765  * @brief Fills Reconfig Cell group Info received by CU
8766  *
8767  * @details
8768  *
8769  *    Function : extractUeReCfgCellInfo
8770  *
8771  *    Functionality: Fills Reconfig Cell group Info received by CU
8772  *
8773  * @params[in] CellGroupConfigRrc_t *macCellGrpCfg
8774  *             MacUeCfg*  macUeCfg
8775  * @return ROK/RFAILED
8776  *
8777  * ****************************************************************/
8778 uint8_t extractUeReCfgCellInfo(CellGroupConfigRrc_t *cellGrp, MacUeCfg *macUeCfg)
8779 {
8780    uint8_t ret = ROK;
8781    MAC_CellGroupConfig_t     *macCellGroup = NULLP;
8782    PhysicalCellGroupConfig_t *phyCellGrpCfg = NULLP;
8783    SpCellConfig_t            *spcellCfg = NULLP;
8784    ServingCellConfig_t       *servCellCfg = NULLP;
8785
8786    if(cellGrp)
8787    {
8788       /* Fill MacCell Group Reconfig  */
8789       if(cellGrp->mac_CellGroupConfig)
8790       {
8791          macUeCfg->macCellGrpCfgPres = true;
8792          macCellGroup = ((MAC_CellGroupConfig_t *)(cellGrp->mac_CellGroupConfig));
8793          if(macCellGroup->schedulingRequestConfig)
8794          {
8795             extractSchReqReConfig(macCellGroup->schedulingRequestConfig, &macUeCfg->macCellGrpCfg.schReqCfg);
8796          }
8797          if(macCellGroup->tag_Config)
8798          {
8799             extractTagReconfig(macCellGroup->tag_Config, &macUeCfg->macCellGrpCfg.tagCfg);
8800          }
8801          if(macCellGroup->bsr_Config)
8802          {
8803             macUeCfg->macCellGrpCfg.bsrTmrCfg.periodicTimer = macCellGroup->bsr_Config->periodicBSR_Timer;
8804             macUeCfg->macCellGrpCfg.bsrTmrCfg.retxTimer     = macCellGroup->bsr_Config->retxBSR_Timer;
8805             if(macCellGroup->bsr_Config->logicalChannelSR_DelayTimer)
8806             {
8807                macUeCfg->macCellGrpCfg.bsrTmrCfg.srDelayTimer  =\
8808                *(macCellGroup->bsr_Config->logicalChannelSR_DelayTimer);
8809             }
8810          }
8811          if(macCellGroup->phr_Config)
8812          {
8813             if(macCellGroup->phr_Config->present == MAC_CellGroupConfig__phr_Config_PR_setup)
8814             {
8815                macUeCfg->macCellGrpCfg.phrCfgSetupPres = true;
8816                if(macCellGroup->phr_Config->choice.setup)
8817                {
8818                   macUeCfg->macCellGrpCfg.phrCfg.periodicTimer     = \
8819                   macCellGroup->phr_Config->choice.setup->phr_PeriodicTimer;
8820                   macUeCfg->macCellGrpCfg.phrCfg.prohibitTimer     = \
8821                   macCellGroup->phr_Config->choice.setup->phr_ProhibitTimer;
8822                   macUeCfg->macCellGrpCfg.phrCfg.txPowerFactor     = \
8823                   macCellGroup->phr_Config->choice.setup->phr_Tx_PowerFactorChange;
8824                   macUeCfg->macCellGrpCfg.phrCfg.multiplePHR       = \
8825                   macCellGroup->phr_Config->choice.setup->multiplePHR;
8826                   macUeCfg->macCellGrpCfg.phrCfg.dummy             = \
8827                   macCellGroup->phr_Config->choice.setup->dummy;
8828                   macUeCfg->macCellGrpCfg.phrCfg.phrType2OtherCell = \
8829                   macCellGroup->phr_Config->choice.setup->phr_Type2OtherCell;
8830                   macUeCfg->macCellGrpCfg.phrCfg.phrOtherCG        = \
8831                   macCellGroup->phr_Config->choice.setup->phr_ModeOtherCG;
8832                }
8833             }
8834          }
8835       }
8836       /* Fill Physical Cell Group Reconfig */
8837       if(cellGrp->physicalCellGroupConfig)
8838       {
8839          macUeCfg->phyCellGrpCfgPres = true;
8840          phyCellGrpCfg = ((PhysicalCellGroupConfig_t *)(cellGrp->physicalCellGroupConfig));
8841          if(phyCellGrpCfg->p_NR_FR1)
8842          {
8843             if(*(phyCellGrpCfg->p_NR_FR1) != macUeCfg->phyCellGrpCfg.pNrFr1)
8844                macUeCfg->phyCellGrpCfg.pNrFr1 = *(phyCellGrpCfg->p_NR_FR1);
8845          }
8846          macUeCfg->phyCellGrpCfg.pdschHarqAckCodebook = phyCellGrpCfg->pdsch_HARQ_ACK_Codebook;
8847       }
8848       /* Fill SpCell Reconfig */
8849       if(cellGrp->spCellConfig)
8850       {
8851          macUeCfg->spCellCfgPres = true;
8852          spcellCfg = ((SpCellConfig_t *)(cellGrp->spCellConfig));
8853          if(spcellCfg->servCellIndex)
8854          {
8855             macUeCfg->spCellCfg.servCellIdx = *(spcellCfg->servCellIndex);
8856          }
8857          /* Fill Serving cell Reconfig info */
8858          if(cellGrp->spCellConfig->spCellConfigDedicated)
8859          {
8860             servCellCfg = ((ServingCellConfig_t *)(cellGrp->spCellConfig->spCellConfigDedicated));
8861             ret = extractSpCellDedicatedCfg(servCellCfg, &macUeCfg->spCellCfg.servCellCfg);
8862             if(ret == RFAILED)
8863             {
8864                DU_LOG("\nERROR --> F1AP : Failed at extractSpCellDedicatedCfg()");
8865             }
8866          }
8867       }
8868    }
8869    return ret;
8870 }
8871 /*******************************************************************
8872 *
8873 * @brief free the memory allocated by decoder
8874 *
8875 * @details
8876 *
8877 *    Function : freeAperDecodeNrcgi
8878 *
8879 *    Functionality: Free Nrcgi values
8880 *
8881 * @params[in] NRCGI_t *nrcgi
8882 * @return void
8883 *
8884 * ****************************************************************/
8885
8886
8887 void freeAperDecodeNrcgi(NRCGI_t *nrcgi)
8888 {
8889     if(nrcgi->pLMN_Identity.buf != NULLP)
8890     {
8891        free(nrcgi->pLMN_Identity.buf);
8892     }
8893     if(nrcgi->nRCellIdentity.buf != NULLP)
8894     {
8895        free(nrcgi->nRCellIdentity.buf);
8896     }
8897 }
8898 /*******************************************************************
8899 *
8900 * @brief free the memory allocated by decoder
8901 *
8902 * @details
8903 *
8904 *    Function : freeAperDecodeCuToDuInfo
8905 *
8906 *    Functionality:  Free Cu To Du Information
8907 *
8908 * @params[in] CUtoDURRCInformation_t *rrcMsg
8909 * @return void
8910 *
8911 * ****************************************************************/
8912
8913
8914 void freeAperDecodeCuToDuInfo(CUtoDURRCInformation_t *rrcMsg)
8915 {
8916    uint8_t ieIdx =0;
8917    uint8_t arrIdx =0;
8918
8919    if(rrcMsg->uE_CapabilityRAT_ContainerList)
8920    {
8921       if(rrcMsg->uE_CapabilityRAT_ContainerList->buf)
8922          free(rrcMsg->uE_CapabilityRAT_ContainerList->buf);
8923       free(rrcMsg->uE_CapabilityRAT_ContainerList);
8924    }
8925
8926    if(rrcMsg->iE_Extensions)
8927    {
8928       if(rrcMsg->iE_Extensions->list.array)
8929       {
8930          for(ieIdx= 0; ieIdx < rrcMsg->iE_Extensions->list.count; ieIdx++)
8931          {
8932             if(rrcMsg->iE_Extensions->list.array[ieIdx])
8933             {
8934                switch(rrcMsg->iE_Extensions->list.array[ieIdx]->id)
8935                {
8936                   case ProtocolIE_ID_id_CellGroupConfig:
8937                      if(rrcMsg->iE_Extensions->list.array[ieIdx]->extensionValue.choice.CellGroupConfig.buf != NULLP)
8938                      {
8939                         free(rrcMsg->iE_Extensions->list.array[ieIdx]->extensionValue.choice.CellGroupConfig.buf);
8940                      }
8941                      break;
8942                   default:
8943                      DU_LOG("\nERROR  -->  F1AP : Invalid Event type %ld at FreeCuToDuInfo()", \
8944                            rrcMsg->iE_Extensions->list.array[ieIdx]->id);
8945                      break;
8946                }
8947             }
8948          }
8949          for(arrIdx = 0; arrIdx < ieIdx; arrIdx++)
8950          {
8951             free(rrcMsg->iE_Extensions->list.array[arrIdx]);
8952          }
8953          free(rrcMsg->iE_Extensions->list.array);
8954
8955       }
8956
8957       free(rrcMsg->iE_Extensions);
8958    }
8959 }
8960 /*******************************************************************
8961 *
8962 * @brief free the memory allocated by decoder
8963 *
8964 * @details
8965 *
8966 *    Function : freeAperDecodeSplCellList
8967 *
8968 *    Functionality: Free Spl Cell List
8969                     where memory allocated by aper_decoder
8970 *
8971 * @params[in]  SCell_ToBeSetup_List_t *spCellLst
8972 * @return void
8973 *
8974 * ****************************************************************/
8975
8976
8977 void freeAperDecodeSplCellList(SCell_ToBeSetup_List_t *spCellLst)
8978 {
8979     uint8_t  cellIdx =0;
8980
8981     if(spCellLst->list.array != NULLP)
8982     {
8983        for(cellIdx=0; cellIdx<spCellLst->list.count; cellIdx++)
8984        {
8985           if(cellIdx==0&&spCellLst->list.array[cellIdx]!=NULLP)
8986           {
8987              freeAperDecodeNrcgi(&spCellLst->list.array[cellIdx]->value.choice.SCell_ToBeSetup_Item.sCell_ID);
8988           }
8989           if(spCellLst->list.array[cellIdx]!=NULLP)
8990           {
8991              free(spCellLst->list.array[cellIdx]);
8992           }
8993        }
8994        free(spCellLst->list.array);
8995     }
8996 }
8997 /*******************************************************************
8998 *
8999 * @brief free the memory allocated by decoder
9000 *
9001 * @details
9002 *
9003 *    Function : freeAperDecodeSRBSetup
9004 *
9005 *    Functionality: added free part for the memory allocated by aper_decoder
9006 *
9007 * @params[in] SRBs_ToBeSetup_List_t *srbSet
9008 * @return void
9009 *
9010 ****************************************************************/
9011
9012
9013 void freeAperDecodeSRBSetup(SRBs_ToBeSetup_List_t *srbSet)
9014 {
9015     uint8_t srbIdx =0;
9016     if(srbSet->list.array != NULLP)
9017     {
9018        for(srbIdx=0; srbIdx<srbSet->list.count; srbIdx++)
9019        {
9020           if(srbSet->list.array[srbIdx]!=NULLP)
9021           {
9022              free(srbSet->list.array[srbIdx]);
9023           }
9024        }
9025        free(srbSet->list.array);
9026     }
9027 }
9028
9029 /*******************************************************************
9030 *
9031 * @brief free the memory allocated by decoder
9032 *
9033 * @details
9034 *
9035 *    Function : freeAperDecodeULTnlInfo
9036 *
9037 *    Functionality: added free part for the memory allocated by aper_decoder
9038 *
9039 * @params[in] ULUPTNLInformation_ToBeSetup_List_t *ulInfo
9040 * @return void
9041 *
9042 * ****************************************************************/
9043
9044
9045 void freeAperDecodeULTnlInfo(ULUPTNLInformation_ToBeSetup_List_t *ulInfo)
9046 {
9047    uint8_t ulIdx=0;
9048    if(ulInfo->list.array != NULLP)
9049    {
9050       for(ulIdx=0; ulIdx<ulInfo->list.count; ulIdx++)
9051       {
9052          if(ulIdx==0&&ulInfo->list.array[ulIdx]!=NULLP)
9053          {
9054             if(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel!=NULLP)
9055             {
9056                if(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel->\
9057                      transportLayerAddress.buf != NULLP)
9058                {
9059                   if(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf\
9060                         !=NULLP)
9061                   {
9062                      free(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf);
9063                   }
9064                   free(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel->\
9065                         transportLayerAddress.buf);
9066                }
9067                free(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel);
9068             }
9069          }
9070          if(ulInfo->list.array[ulIdx]!=NULLP)
9071          {
9072             free(ulInfo->list.array[ulIdx]);
9073          }
9074       }
9075       free(ulInfo->list.array);
9076    }
9077 }
9078 /*******************************************************************
9079 *
9080 * @brief free the memory allocated by decoder
9081 *
9082 * @details
9083 *
9084 *    Function : freeAperDecodeDRBSetup
9085 *
9086 *    Functionality: free DRBSetup which is allocated by decoder
9087 *
9088 * @params[in]  DRBs_ToBeSetup_List_t *drbSet
9089 * @return void
9090 *
9091 * ****************************************************************/
9092
9093 void freeAperDecodeDRBSetup(DRBs_ToBeSetup_List_t *drbSet)
9094 {
9095    DRBs_ToBeSetup_Item_t *drbSetItem = NULLP;
9096    uint8_t  flowIdx =0;
9097    uint8_t  drbIdx =0;
9098
9099    if(drbSet->list.array != NULLP)
9100    {
9101       for(drbIdx=0; drbIdx<drbSet->list.count; drbIdx++)
9102       {
9103          if(drbIdx==0&&drbSet->list.array[drbIdx] != NULLP)
9104          {
9105             drbSetItem =&drbSet->list.array[drbIdx]->value.choice.DRBs_ToBeSetup_Item;
9106             if(drbSetItem->qoSInformation.choice.choice_extension != NULLP)
9107             {
9108                if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
9109                      qoS_Characteristics.choice.non_Dynamic_5QI !=NULLP)
9110                {
9111                   if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
9112                         qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow!=NULLP)
9113                   {
9114                      if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
9115                            qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume!=NULLP)
9116                      {
9117
9118                         if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sST.buf!=NULLP)
9119                         {
9120
9121                            if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD!=NULLP)
9122                            {
9123
9124                               if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD->\
9125                                     buf!=NULLP)
9126                               {
9127
9128                                  if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.\
9129                                        flows_Mapped_To_DRB_List.list.array != NULLP)
9130                                  {
9131
9132                                     for(flowIdx=0;flowIdx<drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9133                                           DRB_Information.flows_Mapped_To_DRB_List.list.count; flowIdx++)
9134                                     {
9135
9136                                        if(flowIdx==0&&drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9137                                              DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]!=NULLP)
9138                                        {
9139                                           if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9140                                                 DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
9141                                                 qoSFlowLevelQoSParameters.\
9142                                                 qoS_Characteristics.choice.non_Dynamic_5QI!=NULLP)
9143                                           {
9144                                              if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9145                                                    DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
9146                                                    qoSFlowLevelQoSParameters.\
9147                                                    qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow!=NULLP)
9148                                              {
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->maxDataBurstVolume!=NULLP)
9154                                                 {
9155
9156
9157                                                    free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9158                                                          DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
9159                                                          qoSFlowLevelQoSParameters.\
9160                                                          qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume);
9161                                                 }
9162
9163                                                 free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9164                                                       DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
9165                                                       qoSFlowLevelQoSParameters.\
9166                                                       qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow);
9167                                              }
9168
9169                                              free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9170
9171                                                    DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
9172                                                    qoSFlowLevelQoSParameters.\
9173                                                    qoS_Characteristics.choice.non_Dynamic_5QI);
9174                                           }
9175                                        }
9176                                        if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9177                                              DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]!=NULLP)
9178                                        {
9179
9180                                           free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9181                                                 DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]);
9182                                        }
9183                                     }
9184
9185                                     free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9186                                           DRB_Information.flows_Mapped_To_DRB_List.list.array);
9187                                  }
9188
9189                                  free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9190                                        DRB_Information.sNSSAI.sD->buf);
9191                               }
9192
9193                               free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD);
9194                            }
9195
9196                            free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sST.buf);
9197
9198                         }
9199
9200                         free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
9201
9202                               qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume);
9203                      }
9204
9205                      free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
9206                            qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow);
9207                   }
9208
9209                   free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
9210                         qoS_Characteristics.choice.non_Dynamic_5QI);
9211                }
9212                free(drbSetItem->qoSInformation.choice.choice_extension);
9213             }
9214             freeAperDecodeULTnlInfo(&drbSetItem->uLUPTNLInformation_ToBeSetup_List);
9215             if(drbSetItem->uLConfiguration)
9216             {
9217                free(drbSetItem->uLConfiguration);
9218             }
9219          }
9220          if(drbSet->list.array[drbIdx]!=NULLP)
9221          {
9222             free(drbSet->list.array[drbIdx]);
9223          }
9224       }
9225       free(drbSet->list.array);
9226    }
9227 }
9228
9229
9230 /*******************************************************************
9231  *
9232  * @brief builds Mac Cell Cfg
9233  *
9234  * @details
9235  *
9236  *    Function : procUeReCfgCellInfo
9237  *
9238  *    Functionality: builds Mac Cell Cfg
9239  *
9240  * @params[in] MacUeCfg pointer
9241  *             void pointer
9242  *
9243  * @return void
9244  *
9245  * ****************************************************************/
9246 uint8_t procUeReCfgCellInfo(MacUeCfg *macUeCfg, void *cellInfo)
9247 {
9248    uint8_t ret = ROK;
9249    CellGroupConfigRrc_t *cellGrp = NULLP;
9250
9251    if(cellInfo)
9252    {
9253       cellGrp = (CellGroupConfigRrc_t *)cellInfo;
9254       ret = extractUeReCfgCellInfo(cellGrp, macUeCfg);
9255       if(ret == RFAILED)
9256          DU_LOG("\nERROR  -->  F1AP : Failed at procUeReCfgCellInfo()");
9257    }
9258    if(ret == RFAILED)
9259    {
9260       freeUeReCfgCellGrpInfo(macUeCfg);
9261    }
9262    return ret;
9263 }
9264
9265 /*******************************************************************
9266  *
9267  * @brief Filling modulation info in mac ue cfg
9268  *
9269  * @details
9270  *
9271  *    Function : duFillModulationDetails
9272  *
9273  *    Functionality: Filling modulation info in mac ue cfg
9274  *
9275  * @params[in] MAC UE Config to be updated
9276  *             Current UE configuration
9277  *             UE NR capability from CU
9278  * @return ROK     - success
9279  *         RFAILED - failure
9280  *
9281  * ****************************************************************/
9282 void duFillModulationDetails(MacUeCfg *ueCfg, MacUeCfg *oldUeCfg, void *ueCap)
9283 {
9284    UE_NR_Capability_t *ueNrCap;
9285
9286    if(ueCap)
9287       ueNrCap = (UE_NR_Capability_t *)ueCap;
9288
9289    /* Filling DL modulation info */
9290    if(ueNrCap->featureSets && ueNrCap->featureSets->featureSetsDownlinkPerCC && \
9291          ueNrCap->featureSets->featureSetsDownlinkPerCC->list.array[0] && \
9292          ueNrCap->featureSets->featureSetsDownlinkPerCC->list.array[0]->supportedModulationOrderDL)
9293    {
9294       switch(*(ueNrCap->featureSets->featureSetsDownlinkPerCC->list.array[0]->supportedModulationOrderDL))
9295       {
9296          case ModulationOrder_qpsk:
9297             {
9298                ueCfg->dlModInfo.modOrder = MOD_ORDER_QPSK;
9299                break;
9300             }
9301          case ModulationOrder_qam16:
9302             {
9303                ueCfg->dlModInfo.modOrder = MOD_ORDER_QAM16;
9304                break;
9305             }
9306          case ModulationOrder_qam64:
9307             {
9308                ueCfg->dlModInfo.modOrder = MOD_ORDER_QAM64;
9309                ueCfg->dlModInfo.mcsIndex = PDSCH_MCS_INDEX;
9310                ueCfg->dlModInfo.mcsTable = MCS_TABLE_QAM64;
9311                break;
9312             }
9313          case ModulationOrder_qam256:
9314             {
9315                ueCfg->dlModInfo.modOrder = MOD_ORDER_QAM256;
9316                break;
9317             }
9318          default:
9319             {
9320                DU_LOG("\nERROR  -->  DU APP: Incorrect downlink modulation order received. Reatining old modulation configuration");
9321                memcpy(&ueCfg->dlModInfo, &oldUeCfg->dlModInfo, sizeof(ModulationInfo));
9322                break;
9323             }
9324       }
9325    }
9326    else
9327    {
9328       memcpy(&ueCfg->dlModInfo, &oldUeCfg->dlModInfo, sizeof(ModulationInfo));
9329    }
9330
9331    /* Filling UL modulation info */
9332    if(ueNrCap->featureSets && ueNrCap->featureSets->featureSetsUplinkPerCC && \
9333          ueNrCap->featureSets->featureSetsUplinkPerCC->list.array[0] && \
9334          ueNrCap->featureSets->featureSetsUplinkPerCC->list.array[0]->supportedModulationOrderUL)
9335    {
9336       switch(*(ueNrCap->featureSets->featureSetsUplinkPerCC->list.array[0]->supportedModulationOrderUL))
9337       {
9338          case ModulationOrder_qpsk:
9339             {
9340                ueCfg->ulModInfo.modOrder = MOD_ORDER_QPSK;
9341                break;
9342             }
9343          case ModulationOrder_qam16:
9344             {
9345                ueCfg->ulModInfo.modOrder = MOD_ORDER_QAM16;
9346                ueCfg->ulModInfo.mcsIndex = PUSCH_MCS_INDEX;
9347                ueCfg->ulModInfo.mcsTable = MCS_TABLE_QAM64;
9348                break;
9349             }
9350          case ModulationOrder_qam64:
9351             {
9352                ueCfg->ulModInfo.modOrder = MOD_ORDER_QAM64;
9353                break;
9354             }
9355          case ModulationOrder_qam256:
9356             {
9357                ueCfg->ulModInfo.modOrder = MOD_ORDER_QAM256;
9358                break;
9359             }
9360          default:
9361             {
9362                DU_LOG("\nERROR  -->  DU APP: Incorrect uplink modulation order received. Reatining old modulation configuration");
9363                memcpy(&ueCfg->ulModInfo, &oldUeCfg->ulModInfo, sizeof(ModulationInfo));
9364                break;
9365             }
9366       }
9367    }
9368    else
9369    {
9370       memcpy(&ueCfg->ulModInfo, &oldUeCfg->ulModInfo, sizeof(ModulationInfo));
9371    }
9372 }
9373
9374 /*******************************************************************
9375  *
9376  * @brief Function to extract cellGrp Info present in cutoDu cont
9377  *
9378  * @details
9379  *
9380  *    Function : extractCellGrpInfo
9381  *
9382  *    Functionality: Function to extract cellGrp Info present
9383  *                   in cutoDu cont
9384  *
9385  * @params[in] ProtocolExtensionContainer_4624P16_t pointer
9386  *
9387  * @return CellGroupConfigRrc_t *
9388  *
9389  * ****************************************************************/
9390
9391 CellGroupConfigRrc_t *extractCellGrpInfo(ProtocolExtensionContainer_4624P16_t *protocolIeExtn,\
9392       DuUeCfg *ueCfgDb)
9393 {
9394    uint8_t idx2 =0;
9395    uint16_t id =0;
9396    uint16_t recvBufLen =0;
9397    CellGroupConfigRrc_t *cellGrpCfg = NULLP;
9398    CUtoDURRCInformation_ExtIEs_t *extIeInfo = NULLP;
9399    asn_dec_rval_t rval; /* Decoder return value */
9400    memset(&rval, 0, sizeof(asn_dec_rval_t));
9401
9402    if(protocolIeExtn)
9403    {
9404       for(idx2 = 0; idx2 < protocolIeExtn->list.count; idx2++)
9405       {
9406          extIeInfo = ((CUtoDURRCInformation_ExtIEs_t *)(protocolIeExtn->list.array[idx2]));
9407          id = extIeInfo->id;
9408          switch(id)
9409          {
9410             case ProtocolIE_ID_id_CellGroupConfig:
9411             {
9412                recvBufLen = extIeInfo->extensionValue.choice.CellGroupConfig.size;
9413                /* decoding the CellGroup Buf received */
9414                DU_ALLOC(cellGrpCfg, sizeof(CellGroupConfigRrc_t));
9415                if(cellGrpCfg)
9416                {
9417                   memset(cellGrpCfg, 0, sizeof(CellGroupConfigRrc_t));
9418                   rval = aper_decode(0, &asn_DEF_CellGroupConfigRrc, (void **)&cellGrpCfg,
9419                      extIeInfo->extensionValue.choice.CellGroupConfig.buf, recvBufLen, 0, 0);
9420                   if(rval.code == RC_FAIL || rval.code == RC_WMORE)
9421                   {
9422                      DU_LOG("\nERROR  -->  F1AP : ASN decode failed at decodeCellGrpCfg()");
9423                      return NULLP;
9424                   }
9425                   xer_fprint(stdout, &asn_DEF_CellGroupConfigRrc, cellGrpCfg);
9426                   if(extractRlcCfgToAddMod(cellGrpCfg->rlc_BearerToAddModList, ueCfgDb))
9427                      return NULLP;
9428                }
9429                break;
9430             }
9431             default:
9432                DU_LOG("\nERROR  -->  F1AP : Invalid IE received CUtoDURRCInformation:%d at decodeCellGrpCfg()", id);
9433                break;
9434          }
9435       }
9436    }
9437    return cellGrpCfg;
9438 }
9439
9440 /*******************************************************************
9441  *
9442  * @brief Fills Srb List received by CU
9443  *
9444  * @details
9445  *
9446  *    Function : procSrbListToSetup
9447  *
9448  *    Functionality: Fills Srb List received  by CU
9449  *
9450  * @params[in] SRBs_ToBeSetup_Item_t *cuSrbItem
9451  *             LcCfg pointer
9452  *             RlcBearerCfg pointer
9453  * @return void
9454  *
9455  * ****************************************************************/
9456 uint8_t procSrbListToSetup(SRBs_ToBeSetup_Item_t * srbItem, LcCfg *macLcToAdd, RlcBearerCfg *rlcLcToAdd)
9457 {
9458    uint8_t ret = ROK;
9459
9460    /* Filling RLC INFO */
9461    procRlcLcCfg(srbItem->sRBID, srbItem->sRBID, RB_TYPE_SRB, RLC_AM, CONFIG_ADD, NULL, rlcLcToAdd);
9462
9463    /* Filling MAC INFO */
9464    ret = procMacLcCfg(srbItem->sRBID, RB_TYPE_SRB, CONFIG_ADD, NULL,NULL, NULL, macLcToAdd, NULL);
9465    if(ret == RFAILED)
9466    {
9467       DU_LOG("\nERROR  -->  F1AP : Failed at MAC LC Cfg in procSrbListToSetup()");
9468       return ret;
9469    }
9470    return ret;
9471 }
9472
9473
9474
9475 /*******************************************************************
9476  *
9477  * @brief extract Srb List received by CU
9478  *
9479  * @details
9480  *
9481  *    Function : extractSrbListToSetup
9482  *
9483  *    Functionality: extract Srb List received by CU
9484  *                   for both MAC and RLC
9485  *
9486  * @params[in] SRBs_ToBeSetup_Item_t pointer
9487  *             DuUeCfg pointer
9488  * @return ROK/RFAIED
9489  *
9490  * ****************************************************************/
9491
9492 uint8_t extractSrbListToSetup(SRBs_ToBeSetup_List_t *srbCfg, DuUeCfg *ueCfgDb)
9493 {
9494    uint8_t ret, srbIdx;
9495    SRBs_ToBeSetup_Item_t *srbItem = NULLP;
9496
9497    if(srbCfg)
9498    {
9499       for(srbIdx = 0; srbIdx < srbCfg->list.count; srbIdx++)
9500       {
9501          srbItem = &srbCfg->list.array[srbIdx]->value.choice.SRBs_ToBeSetup_Item;
9502          if(ueCfgDb->numMacLcs > MAX_NUM_LC)
9503          {
9504             DU_LOG("\nERROR   -->  F1AP:  MAX LC Reached in MAC");
9505             ret = RFAILED;
9506             break;
9507          }
9508          if(ueCfgDb->numRlcLcs > MAX_NUM_LC)
9509          {
9510             DU_LOG("\nERROR   -->  F1AP:  MAX LC Reached in RLC");
9511             ret = RFAILED;
9512             break;
9513          }
9514          memset(&ueCfgDb->macLcCfg[ueCfgDb->numMacLcs], 0, sizeof(LcCfg));
9515          memset(&ueCfgDb->rlcLcCfg[ueCfgDb->numRlcLcs], 0, sizeof(RlcBearerCfg));
9516          ret = procSrbListToSetup(srbItem, &ueCfgDb->macLcCfg[ueCfgDb->numMacLcs],\
9517             &ueCfgDb->rlcLcCfg[ueCfgDb->numRlcLcs]);
9518          ueCfgDb->numRlcLcs++;
9519          ueCfgDb->numMacLcs++;
9520          if(ret == RFAILED)
9521          {
9522             DU_LOG("\nERROR  -->  F1AP:  Failed at extractSrbListToSetup()");
9523             break;
9524          }
9525       }
9526    }
9527    else
9528       ret = RFAILED;
9529
9530    return ret;
9531 }
9532
9533 /*******************************************************************
9534  *
9535  * @brief Fills Drb List received by CU
9536  *
9537  * @details
9538  *
9539  *    Function : procDrbListToSetup
9540  *
9541  *    Functionality: Fills Drb List received by CU
9542  *                   for both MAC and RLC
9543  *
9544  * @params[in] SRBs_ToBeSetup_Item_t pointer
9545  *             LcCfg pointer,
9546  *             RlcBearerCfg pointer
9547  * @return void
9548  *
9549  * ****************************************************************/
9550
9551 uint8_t procDrbListToSetup(uint8_t lcId, DRBs_ToBeSetup_Item_t *drbItem,\
9552 DRBs_ToBeSetupMod_Item_t *drbSetupModItem, LcCfg *macLcToAdd, RlcBearerCfg *rlcLcToAdd, UpTnlCfg *upTnlInfo)
9553 {
9554
9555    if(drbItem != NULLP)
9556    {
9557       /* Filling RLC INFO */
9558       procRlcLcCfg(drbItem->dRBID, lcId, RB_TYPE_DRB, drbItem->rLCMode, CONFIG_ADD, NULL, rlcLcToAdd);
9559
9560       /* Filling MAC INFO */
9561       if(procMacLcCfg(lcId, RB_TYPE_DRB, CONFIG_ADD, drbItem, NULL, NULL, macLcToAdd, upTnlInfo) != ROK)
9562       {
9563          DU_LOG("\nERROR  --> F1AP : Failed at RLC LC Cfg in procDrbListToSetup()");
9564          return RFAILED;
9565       }
9566    }
9567    else if(drbSetupModItem != NULLP)
9568    {
9569       procRlcLcCfg(drbSetupModItem->dRBID, lcId, RB_TYPE_DRB, drbSetupModItem->rLCMode, CONFIG_ADD, NULL, rlcLcToAdd);
9570
9571       if(procMacLcCfg(lcId, RB_TYPE_DRB, CONFIG_ADD, NULL, drbSetupModItem, NULL, macLcToAdd, upTnlInfo) != ROK)
9572       {
9573          DU_LOG("\nERROR  --> F1AP : Failed at RLC LC Cfg in procDrbListToSetup()");
9574          return RFAILED;
9575       }
9576    }
9577    return ROK;
9578 }
9579
9580 /*******************************************************************
9581  *
9582  * @brief extract Drb List received by CU
9583  *
9584  * @details
9585  *
9586  *    Function : extractDrbListToSetup
9587  *
9588  *    Functionality: extract Drb List received by CU
9589  *                   for both MAC and RLC
9590  *
9591  * @params[in] DRBs_ToBeSetup_Item_t pointer
9592  *             DuUeCfg pointer
9593  * @return ROK/RFAIED
9594  *
9595  * ****************************************************************/
9596
9597 uint8_t extractDrbListToSetup(uint8_t lcId, DRBs_ToBeSetup_List_t *drbCfg,DRBs_ToBeSetupMod_List_t *drbSetupModCfg,\
9598 uint8_t drbCount, DuUeCfg *ueCfgDb)
9599 {
9600    uint8_t ret, drbIdx;
9601    DRBs_ToBeSetup_Item_t *drbItem = NULLP;
9602    DRBs_ToBeSetupMod_ItemIEs_t *drbSetupModItem = NULLP;
9603
9604    ret = ROK;
9605    if(drbCount > 0)
9606    {
9607       for(drbIdx = 0; drbIdx < drbCount; drbIdx++)
9608       {
9609          if(ueCfgDb->numMacLcs > MAX_NUM_LC)
9610          {
9611             DU_LOG("\nERROR  -->  F1AP :  MAX LC Reached in MAC at extractDrbListToSetup()");
9612             ret = RFAILED;
9613             break;
9614          }
9615          if(ueCfgDb->numRlcLcs > MAX_NUM_LC)
9616          {
9617             DU_LOG("\nERROR  -->  F1AP :  MAX LC Reached in RLC at extractDrbListToSetup()");
9618             ret = RFAILED;
9619             break;
9620          }
9621          memset(&ueCfgDb->macLcCfg[ueCfgDb->numMacLcs], 0, sizeof(LcCfg));
9622          memset(&ueCfgDb->rlcLcCfg[ueCfgDb->numRlcLcs], 0, sizeof(RlcBearerCfg));
9623
9624          if(drbCfg != NULL)
9625          {
9626             drbItem = &drbCfg->list.array[drbIdx]->value.choice.DRBs_ToBeSetup_Item;
9627             ret = procDrbListToSetup(lcId, drbItem, NULL, &ueCfgDb->macLcCfg[ueCfgDb->numMacLcs],\
9628                &ueCfgDb->rlcLcCfg[ueCfgDb->numRlcLcs], &ueCfgDb->upTnlInfo[ueCfgDb->numDrb]);
9629             if(ret == RFAILED)
9630             {
9631                DU_LOG("\nERROR  --> F1AP : Failed at extractDrbListToSetup()");
9632                break;
9633             }
9634          }
9635          else if(drbSetupModCfg != NULL)
9636          {
9637             drbSetupModItem = (DRBs_ToBeSetupMod_ItemIEs_t *) drbSetupModCfg->list.array[drbIdx];
9638             ret = procDrbListToSetup(lcId, NULL, &(drbSetupModItem->value.choice.DRBs_ToBeSetupMod_Item) ,\
9639             &ueCfgDb->macLcCfg[ueCfgDb->numMacLcs], &ueCfgDb->rlcLcCfg[ueCfgDb->numRlcLcs],\
9640             &ueCfgDb->upTnlInfo[ueCfgDb->numDrb]);
9641             if(ret == RFAILED)
9642             {
9643                DU_LOG("\nERROR  --> F1AP : Failed at extractDrbListToSetup()");
9644                break;
9645             }
9646          }
9647          ueCfgDb->numRlcLcs++;
9648          ueCfgDb->numMacLcs++;
9649          ueCfgDb->numDrb++;
9650          if(ret == RFAILED)
9651          {
9652             DU_LOG("\nERROR  --> F1AP : Failed at extractDrbListToSetup()");
9653             break;
9654          }
9655       }
9656    }
9657    else
9658       ret = RFAILED;
9659
9660    return ret;
9661 }
9662
9663 /*******************************************************************
9664  *
9665  * @brief Function to extract Dl RRC Msg received from CU
9666  *
9667  * @details
9668  *
9669  *    Function : extractDlRrcMsg
9670  *
9671  *    Functionality: Function to extract Dl RRC Msg received from CU
9672  *
9673  * @params[in] F1AP message
9674  * @return ROK     - success
9675  *         RFAILED - failure
9676  *
9677  * ****************************************************************/
9678
9679 uint8_t extractDlRrcMsg(uint32_t gnbDuUeF1apId, uint32_t gnbCuUeF1apId, \
9680    F1DlRrcMsg *dlRrcMsg, RRCContainer_t *rrcContainer)
9681 {
9682    uint8_t ret = ROK;
9683    dlRrcMsg->rrcMsgSize = rrcContainer->size;
9684    if(dlRrcMsg->rrcMsgSize > 0)
9685    {
9686       DU_ALLOC_SHRABL_BUF(dlRrcMsg->rrcMsgPdu, dlRrcMsg->rrcMsgSize);
9687       if(!dlRrcMsg->rrcMsgPdu)
9688       {
9689          DU_LOG("\nERROR  --> DU APP : Memory allocation failed for RRC Msg in extractDlRrcMsg()");
9690          ret = RFAILED;
9691       }
9692       else
9693       {
9694          dlRrcMsg->gnbDuUeF1apId = gnbDuUeF1apId;
9695          dlRrcMsg->gnbCuUeF1apId = gnbCuUeF1apId;
9696          dlRrcMsg->srbId = SRB1_LCID;
9697          memcpy(dlRrcMsg->rrcMsgPdu, rrcContainer->buf, dlRrcMsg->rrcMsgSize);
9698       }
9699    }
9700    return ret;
9701 }
9702
9703 /*******************************************************************
9704  *
9705  * @brief Extract UE capability info
9706  *
9707  * @details
9708  *
9709  *    Function : extractUeCapability
9710  *
9711  *    Functionality: Extract UE capability info and stores in ue Cb
9712  *
9713  * @params[in] Octet string of UE capability RAT container list
9714  * @return ROK     - success
9715  *         RFAILED - failure
9716  *
9717  * ****************************************************************/
9718 UE_NR_Capability_t *extractUeCapability(UE_CapabilityRAT_ContainerList_t *ueCapablityListBuf, DuUeCb *ueCb)
9719 {
9720    uint8_t  idx;
9721    uint16_t recvBufLen;
9722    asn_dec_rval_t rval;
9723    UE_NR_Capability_t  *ueNrCap = NULLP;
9724    UE_CapabilityRAT_ContainerListRRC_t  *ueCapRatContList = NULLP;
9725
9726    /* Decoding UE Capability RAT Container List */
9727    recvBufLen = ueCapablityListBuf->size;
9728    DU_ALLOC(ueCapRatContList, sizeof(UE_CapabilityRAT_ContainerListRRC_t));
9729    if(!ueCapRatContList)
9730    {
9731       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in extractUeCapability");
9732       return NULLP;
9733    }
9734    memset(ueCapRatContList, 0, sizeof(UE_CapabilityRAT_ContainerListRRC_t));
9735    memset(&rval, 0, sizeof(asn_dec_rval_t));
9736    rval = aper_decode(0, &asn_DEF_UE_CapabilityRAT_ContainerListRRC, (void **)&ueCapRatContList,
9737           ueCapablityListBuf->buf, recvBufLen, 0, 0);
9738    if(rval.code == RC_FAIL || rval.code == RC_WMORE)
9739    {
9740       DU_LOG("\nERROR  -->  F1AP : ASN decode failed at decodeCellGrpCfg()");
9741       return NULLP;
9742    }
9743    xer_fprint(stdout, &asn_DEF_UE_CapabilityRAT_ContainerListRRC, ueCapRatContList);
9744
9745    /* Free encoded buffer after decoding */
9746
9747    for(idx = 0; idx < ueCapRatContList->list.count; idx++)
9748    {
9749       if(ueCapRatContList->list.array[idx]->rat_Type == RAT_Type_nr)
9750       {
9751          /* Decoding UE NR Capability */
9752           recvBufLen = ueCapRatContList->list.array[idx]->ue_CapabilityRAT_Container.size;
9753           DU_ALLOC(ueNrCap, sizeof(UE_NR_Capability_t));
9754           if(!ueNrCap)
9755           {
9756              DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in extractUeCapability");
9757              DU_FREE(ueCapRatContList, sizeof(UE_CapabilityRAT_ContainerListRRC_t));
9758              return NULLP;
9759           }
9760           memset(ueNrCap, 0, sizeof(UE_NR_Capability_t));
9761           memset(&rval, 0, sizeof(asn_dec_rval_t));
9762           rval = aper_decode(0, &asn_DEF_UE_NR_Capability, (void **)&ueNrCap,
9763                  ueCapRatContList->list.array[idx]->ue_CapabilityRAT_Container.buf, recvBufLen, 0, 0);
9764           if(rval.code == RC_FAIL || rval.code == RC_WMORE)
9765           {
9766              DU_LOG("\nERROR  -->  F1AP : ASN decode failed at decodeCellGrpCfg()");
9767              return NULLP;
9768           }
9769           xer_fprint(stdout, &asn_DEF_UE_NR_Capability, ueNrCap);
9770
9771           /* Free encoded buffer after decoding */
9772           free(ueCapRatContList->list.array[idx]->ue_CapabilityRAT_Container.buf);
9773       }
9774       free(ueCapRatContList->list.array[idx]);
9775    }
9776
9777    /* Free Memory*/
9778    free(ueCapRatContList->list.array);
9779    DU_FREE(ueCapRatContList, sizeof(UE_CapabilityRAT_ContainerListRRC_t));
9780    return ueNrCap;
9781 }
9782
9783 /*******************************************************************
9784 *
9785 * @brief free UE context setup request from CU
9786 *
9787 * @details
9788 *
9789 *    Function : freeAperDecodeF1UeContextSetupReq
9790 *
9791 *    Functionality: freeing part for the memory allocated by aper_decoder
9792 *
9793 * @params[in] F1AP message
9794 * @return ROK     - success
9795 *         RFAILED - failure
9796 *
9797 * ****************************************************************/
9798 void freeAperDecodeF1UeContextSetupReq(UEContextSetupRequest_t   *ueSetReq)
9799 {
9800    uint8_t ieIdx = 0;
9801
9802    if(ueSetReq->protocolIEs.list.array != NULLP)
9803    {
9804       for(ieIdx = 0; ieIdx < ueSetReq->protocolIEs.list.count; ieIdx++)
9805       {
9806          if(ueSetReq->protocolIEs.list.array[ieIdx])
9807          {
9808             switch(ueSetReq->protocolIEs.list.array[ieIdx]->id)
9809             {
9810                case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
9811                   break;
9812                case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
9813                   break;
9814                case ProtocolIE_ID_id_SpCell_ID:
9815                   freeAperDecodeNrcgi(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.NRCGI);
9816                   break;
9817                case ProtocolIE_ID_id_ServCellIndex:
9818                   break;
9819                case ProtocolIE_ID_id_SpCellULConfigured:
9820                   break;
9821                case ProtocolIE_ID_id_CUtoDURRCInformation:
9822
9823                   freeAperDecodeCuToDuInfo(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.CUtoDURRCInformation);
9824                   break;
9825                case ProtocolIE_ID_id_SCell_ToBeSetup_List:
9826
9827                   freeAperDecodeSplCellList(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.SCell_ToBeSetup_List);
9828                   break;
9829                case ProtocolIE_ID_id_SRBs_ToBeSetup_List:
9830
9831                   freeAperDecodeSRBSetup(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.SRBs_ToBeSetup_List);
9832                   break;
9833                case ProtocolIE_ID_id_DRBs_ToBeSetup_List:
9834
9835                   freeAperDecodeDRBSetup(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.DRBs_ToBeSetup_List);
9836                   break;
9837                case ProtocolIE_ID_id_RRCContainer:
9838                   {
9839
9840                      if(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf != NULLP)
9841                      {
9842
9843                         free(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf);
9844                      }
9845                      break;
9846                   }
9847                case ProtocolIE_ID_id_RRCDeliveryStatusRequest:
9848                   break;
9849                case ProtocolIE_ID_id_GNB_DU_UE_AMBR_UL:
9850                   {
9851                      if(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.BitRate.buf)
9852                      {
9853                         free(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.BitRate.buf);
9854                      }
9855                      break;
9856                   }
9857                default:
9858                   DU_LOG("\nERROR  -->  F1AP: Invalid event type %ld " ,ueSetReq->protocolIEs.list.array[ieIdx]->id);
9859             }
9860             free(ueSetReq->protocolIEs.list.array[ieIdx]);
9861          }
9862       }
9863       free(ueSetReq->protocolIEs.list.array);
9864    }
9865 }
9866 /*******************************************************************
9867  *
9868  * @brief Process UE context setup request from CU
9869  *
9870  * @details
9871  *
9872  *    Function : procF1UeContextSetupReq
9873  *
9874  *    Functionality: Process UE context setup request from CU
9875  *
9876  * @params[in] F1AP message
9877  * @return ROK     - success
9878  *         RFAILED - failure
9879  *
9880  * ****************************************************************/
9881 uint8_t procF1UeContextSetupReq(F1AP_PDU_t *f1apMsg)
9882 {
9883    uint8_t  ret=0, ieIdx=0, ueIdx=0, lcId=0, cellIdx=0;
9884    bool ueCbFound = false;
9885    uint32_t gnbCuUeF1apId=0, gnbDuUeF1apId=0, bitRateSize=0;
9886    DuUeCb   *duUeCb = NULL;
9887    UEContextSetupRequest_t   *ueSetReq = NULL;
9888    DRBs_ToBeSetup_List_t *drbCfg = NULL;
9889
9890    ret = ROK;
9891
9892    ueSetReq = &f1apMsg->choice.initiatingMessage->value.choice.UEContextSetupRequest;
9893    for(ieIdx=0; (ieIdx < ueSetReq->protocolIEs.list.count && ret == ROK); ieIdx++)
9894    {
9895       switch(ueSetReq->protocolIEs.list.array[ieIdx]->id)
9896       {
9897          case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
9898             {
9899                gnbCuUeF1apId = ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID;
9900                break;
9901             }
9902          case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
9903             {
9904                gnbDuUeF1apId = ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID;
9905                break;
9906             }
9907          case ProtocolIE_ID_id_ServCellIndex:
9908             {
9909                cellIdx = ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.ServCellIndex;
9910                for(ueIdx = 0; ueIdx < MAX_NUM_UE; ueIdx++)
9911                {
9912                   if((duCb.actvCellLst[cellIdx]->ueCb[ueIdx].gnbDuUeF1apId == gnbDuUeF1apId)&&\
9913                         (duCb.actvCellLst[cellIdx]->ueCb[ueIdx].gnbCuUeF1apId == gnbCuUeF1apId))
9914                   {
9915                      ueCbFound = true;
9916                      duUeCb = &duCb.actvCellLst[cellIdx]->ueCb[ueIdx];
9917                      DU_ALLOC(duUeCb->f1UeDb, sizeof(F1UeContextSetupDb));
9918                      if(duUeCb->f1UeDb)
9919                      {
9920                         memset(duUeCb->f1UeDb, 0, sizeof(F1UeContextSetupDb));
9921                         duUeCb->f1UeDb->actionType = UE_CTXT_SETUP;
9922                         duUeCb->f1UeDb->cellIdx = cellIdx;
9923                      }
9924                      else
9925                      {
9926                         DU_LOG("\nERROR  -->  F1AP: Memory Alloc Failed at procF1UeContextSetupReq()");
9927                         ret = RFAILED;
9928                      }
9929                   }
9930                   else
9931                      ueCbFound = false;
9932
9933                }
9934                if(!ueCbFound)
9935                {
9936                   DU_LOG("\nERROR  -->  F1AP: DuUeCb is not found at procF1UeContextSetupReq()");
9937                   ret = RFAILED;
9938                }
9939                break;
9940             }
9941          case ProtocolIE_ID_id_SpCellULConfigured:
9942             /* Indicates whether the gNB-CU requests the gNB-DU to configure the uplink as no UL,
9943                UL, SUL or UL+SUL for the indicated cell for the UE */
9944             break;
9945          case ProtocolIE_ID_id_CUtoDURRCInformation:
9946             {
9947                if(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.CUtoDURRCInformation.uE_CapabilityRAT_ContainerList)
9948                {
9949                   duUeCb->f1UeDb->duUeCfg.ueNrCapability = \
9950                   extractUeCapability(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.CUtoDURRCInformation.\
9951                   uE_CapabilityRAT_ContainerList, duUeCb);
9952                }
9953                if(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.CUtoDURRCInformation.iE_Extensions)
9954                {
9955                   duUeCb->f1UeDb->duUeCfg.cellGrpCfg = extractCellGrpInfo(ueSetReq->protocolIEs.list.array[ieIdx]->\
9956                         value.choice.CUtoDURRCInformation.iE_Extensions, &duUeCb->f1UeDb->duUeCfg);
9957                   if(!duUeCb->f1UeDb->duUeCfg.cellGrpCfg)
9958                   {
9959                      DU_LOG("\nERROR  -->  F1AP: Failed to extract cell Grp Info");
9960                      //TODO: Update the failure cause in ue context Setup Response
9961                      ret = RFAILED;
9962                   }
9963                }
9964                break;
9965             }
9966          case ProtocolIE_ID_id_SCell_ToBeSetup_List:
9967             {
9968                DU_LOG("\nINFO   -->  DU_APP: Received SCell_ToBeSetup_List but  Not processing the list");
9969                break;
9970             }
9971          case ProtocolIE_ID_id_SRBs_ToBeSetup_List:
9972             {
9973                if(extractSrbListToSetup(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.SRBs_ToBeSetup_List,\
9974                &duUeCb->f1UeDb->duUeCfg))
9975                {
9976                   DU_LOG("\nERROR  -->  DU APP : Failed at extractSrbListToSetup()");
9977                   //TODO: Update the failure cause in ue context Setup Response
9978                   ret = RFAILED;
9979                }
9980                break;
9981             }
9982          case ProtocolIE_ID_id_DRBs_ToBeSetup_List:
9983             {
9984                lcId = getDrbLcId(&duUeCb->drbBitMap);
9985                if(lcId != RFAILED)
9986                {
9987                   drbCfg = &ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.DRBs_ToBeSetup_List;
9988                   if(extractDrbListToSetup(lcId, drbCfg, NULL, drbCfg->list.count, &duUeCb->f1UeDb->duUeCfg))
9989                   {
9990                      DU_LOG("\nERROR  -->  DU APP : Failed at extractDrbListToSetup()");
9991                      //TODO: Update the failure cause in ue context Setup Response
9992                      ret = RFAILED;
9993                   }
9994                }
9995                else
9996                   ret = RFAILED;
9997                break;
9998             }
9999          case ProtocolIE_ID_id_RRCContainer:
10000             {
10001                /* Filling Dl RRC Msg Info */
10002                DU_ALLOC_SHRABL_BUF(duUeCb->f1UeDb->dlRrcMsg, sizeof(F1DlRrcMsg));
10003                if(!duUeCb->f1UeDb->dlRrcMsg)
10004                {
10005                   DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for DL RRC Msg in procUeCtxtSetupReq()");
10006                   ret = RFAILED;
10007                }
10008                else
10009                {
10010                   duUeCb->f1UeDb->dlRrcMsgPres = true;
10011                   memset(duUeCb->f1UeDb->dlRrcMsg, 0, sizeof(F1DlRrcMsg));
10012                   ret = extractDlRrcMsg(gnbDuUeF1apId, gnbCuUeF1apId, duUeCb->f1UeDb->dlRrcMsg,\
10013                         &ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer);
10014                }
10015                break;
10016             }
10017          case ProtocolIE_ID_id_RRCDeliveryStatusRequest:
10018             {
10019                if(duUeCb->f1UeDb->dlRrcMsg->rrcMsgPdu)
10020                {
10021                   duUeCb->f1UeDb->dlRrcMsg->deliveryStatRpt = true;
10022                }
10023                else
10024                {
10025                   DU_LOG("\nERROR  -->  Ignoring delivery report, since rrcContainer is not present");
10026                }
10027                break;
10028             }
10029          case ProtocolIE_ID_id_GNB_DU_UE_AMBR_UL:
10030             {
10031                /* MaximumBitRate Uplink */
10032                bitRateSize = ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.BitRate.size;
10033                if(bitRateSize > 0)
10034                {
10035                   DU_ALLOC_SHRABL_BUF(duUeCb->f1UeDb->duUeCfg.ambrCfg, bitRateSize);
10036                   if(!duUeCb->f1UeDb->duUeCfg.ambrCfg)
10037                   {
10038                      DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for bitRate in procUeCtxtSetupReq");
10039                      ret = RFAILED;
10040                   }
10041                   else
10042                   {
10043                      memset(duUeCb->f1UeDb->duUeCfg.ambrCfg, 0, sizeof(AmbrCfg));
10044                      memcpy(&duUeCb->f1UeDb->duUeCfg.ambrCfg->ulBr,
10045                            ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.BitRate.buf, bitRateSize);
10046                   }
10047                }
10048                else
10049                   ret = RFAILED;
10050                break;
10051             }
10052          default:
10053             {
10054                break;
10055             }
10056       }
10057    }
10058    if(ret == RFAILED)
10059    {
10060       /*TODO : Negative case*/
10061       // BuildAndSendUeContextSetupRsp(ueIdx, cellId);
10062       DU_LOG("\nERROR  -->  F1AP: Failed to process UE CNTXT SETUP REQ at procF1UeContextSetupReq()");
10063    }
10064    else
10065       ret = duProcUeContextSetupRequest(duUeCb);
10066
10067    freeAperDecodeF1UeContextSetupReq(ueSetReq);
10068    return ret;
10069
10070 }
10071 /*******************************************************************
10072  * @brief Free the memory allocated for Dl Tunnel Info
10073  *
10074  * @details
10075  *
10076  *    Function : freeDlTnlInfo
10077  *
10078  *    Functionality:
10079  *       Free the memory allocated for Dl Tunnel Info
10080  *
10081  * @params[in] DLUPTNLInformation_ToBeSetup_List_t *
10082  * @return void
10083  *
10084  * ****************************************************************/
10085
10086 void freeDlTnlInfo(DLUPTNLInformation_ToBeSetup_List_t *tnlInfo)
10087 {
10088    uint8_t arrIdx = 0;
10089
10090    for(arrIdx=0; arrIdx < tnlInfo->list.count; arrIdx++)
10091    {
10092       DU_FREE(tnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel, sizeof(GTPTunnel_t));
10093    }
10094 }
10095
10096 /*******************************************************************
10097  * @brief Free the memory allocated for DRB setup List
10098  *
10099  * @details
10100  *
10101  *    Function : freeDrbSetupList
10102  *
10103  *    Functionality:
10104  *       Free the memory allocated for DRB setup list
10105  *
10106  * @params[in] DRBs_Setup_List_t *
10107  * @return void
10108  *
10109  * ****************************************************************/
10110 void freeDrbSetupList(DRBs_Setup_List_t *drbSetupList)
10111 {
10112    uint8_t arrIdx = 0;
10113    DRBs_Setup_ItemIEs_t *drbItemIe = NULLP;
10114
10115    for(arrIdx = 0; arrIdx < drbSetupList->list.count; arrIdx++)
10116    {
10117       drbItemIe = ((DRBs_Setup_ItemIEs_t *)drbSetupList->list.array[arrIdx]);
10118       freeDlTnlInfo(&drbItemIe->value.choice.DRBs_Setup_Item.dLUPTNLInformation_ToBeSetup_List);
10119    }
10120 }
10121
10122 /*******************************************************************
10123  * @brief Free the memory allocated for UE Setup response
10124  *
10125  * @details
10126  *
10127  *    Function : FreeUeContextSetupRsp
10128  *
10129  *    Functionality:
10130  *       Free the memory allocated for UE Setup response
10131  *
10132  * @params[in] F1AP PDU for UE setup response
10133  * @return ROK     - success
10134  *         RFAILED - failure
10135  *
10136  * ****************************************************************/
10137 void FreeUeContextSetupRsp(F1AP_PDU_t *f1apMsg)
10138 {
10139    uint8_t idx;
10140    UEContextSetupResponse_t *ueSetRsp = NULLP;
10141
10142    if(f1apMsg)
10143    {
10144       if(f1apMsg->choice.successfulOutcome)
10145       {
10146          ueSetRsp = &f1apMsg->choice.successfulOutcome->value.choice.\
10147                     UEContextSetupResponse;
10148          if(ueSetRsp->protocolIEs.list.array)
10149          {
10150             for(idx = 0; idx < ueSetRsp->protocolIEs.list.count; idx++)
10151             {
10152                if(ueSetRsp->protocolIEs.list.array[idx])
10153                {
10154                   switch(ueSetRsp->protocolIEs.list.array[idx]->id)
10155                   {
10156                      case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
10157                         break;
10158                      case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
10159                         break;
10160                      case ProtocolIE_ID_id_DUtoCURRCInformation:
10161                         {
10162                            CellGroupConfig_t *cellGrpCfg = NULLP;
10163                            cellGrpCfg  = &ueSetRsp->protocolIEs.list.array[idx]->value.choice.\
10164                                          DUtoCURRCInformation.cellGroupConfig;
10165                            if(cellGrpCfg->buf != NULLP)
10166                            {
10167                               DU_FREE(cellGrpCfg->buf, cellGrpCfg->size);
10168                               cellGrpCfg = NULLP;
10169                            }
10170                            break;
10171                         }
10172                     case ProtocolIE_ID_id_DRBs_Setup_List:
10173                         {
10174                            freeDrbSetupList(&ueSetRsp->protocolIEs.list.array[idx]->value.choice.DRBs_Setup_List);
10175                            break;
10176                         }
10177                      default:
10178                         DU_LOG("\nERROR  -->  DUAPP: Invalid Id %ld at FreeUeContextSetupRsp()",\
10179                         ueSetRsp->protocolIEs.list.array[idx]->id);
10180                         break;
10181                   }
10182                   DU_FREE(ueSetRsp->protocolIEs.list.array[idx],\
10183                         sizeof(UEContextSetupResponseIEs_t));
10184                }
10185             }
10186             DU_FREE(ueSetRsp->protocolIEs.list.array, \
10187                   ueSetRsp->protocolIEs.list.size);
10188          }
10189          DU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
10190       }
10191       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
10192    }
10193 }
10194
10195 /*******************************************************************
10196  *
10197  * @brief Builds Ue context Setup Rsp DU To CU Info
10198  *
10199  * @details
10200  *
10201  *    Function : EncodeUeCntxtDuToCuInfo
10202  *
10203  *    Functionality: Builds Ue context Setup Rsp DU To CU Info
10204  *
10205  * @params[in] CellGroupConfig_t *, CellGroupConfigRrc_t *
10206  *
10207  * @return ROK     - success
10208  *         RFAILED - failure
10209  *
10210  ******************************************************************/
10211
10212 uint8_t EncodeUeCntxtDuToCuInfo(CellGroupConfig_t *duToCuCellGrp, CellGroupConfigRrc_t *duCellGrpCfg)
10213 {
10214    asn_enc_rval_t        encRetVal;
10215
10216    xer_fprint(stdout, &asn_DEF_CellGroupConfigRrc, duCellGrpCfg);
10217    memset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
10218    encBufSize = 0;
10219    encRetVal = aper_encode(&asn_DEF_CellGroupConfigRrc, 0, duCellGrpCfg, PrepFinalEncBuf, encBuf);
10220    /* Encode results */
10221    if(encRetVal.encoded == ENCODE_FAIL)
10222    {
10223       DU_LOG( "\nERROR  -->  F1AP : Could not encode UeCntxtDuToCuInfo (at %s)\n",\
10224             encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
10225       return RFAILED;
10226    }
10227    else
10228    {
10229       DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for UeCntxtDuToCuInfo\n");
10230       for(int i=0; i< encBufSize; i++)
10231       {
10232          printf("%x",encBuf[i]);
10233       }
10234    }
10235    duToCuCellGrp->size = encBufSize;
10236    DU_ALLOC(duToCuCellGrp->buf, duToCuCellGrp->size);
10237    if(!duToCuCellGrp->buf)
10238    {
10239       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in UeCntxtDuToCuInfo");
10240    }
10241    memcpy(duToCuCellGrp->buf, encBuf, duToCuCellGrp->size);
10242    return ROK;
10243 }
10244
10245 /*******************************************************************
10246  *
10247  * @brief Fills Dl Gtp tunnel Info
10248  *
10249  * @details
10250  *
10251  *    Function : fillGtpTunnelforDl
10252  *
10253  *    Functionality: Fills Dl Gtp tunnel Info
10254  *
10255  * @params[in]
10256  *
10257  * @return ROK     - success
10258  *         RFAILED - failure
10259  *
10260  * ****************************************************************/
10261
10262 uint8_t fillGtpTunnelforDl(GTPTunnel_t *gtpDl, GtpTnlCfg *gtpUeCfg)
10263 {
10264    uint8_t bufSize = 0;
10265
10266    gtpDl->transportLayerAddress.size    = 4*sizeof(uint8_t);
10267    DU_ALLOC(gtpDl->transportLayerAddress.buf, gtpDl->transportLayerAddress.size);
10268    if(gtpDl->transportLayerAddress.buf == NULLP)
10269    {
10270       return RFAILED;
10271    }
10272    memcpy(gtpDl->transportLayerAddress.buf, &gtpUeCfg->dlTnlAddress, gtpDl->transportLayerAddress.size);
10273
10274    /*GTP TEID*/
10275    gtpDl->gTP_TEID.size = 4 * sizeof(uint8_t);
10276    DU_ALLOC(gtpDl->gTP_TEID.buf, gtpDl->gTP_TEID.size);
10277    if(gtpDl->gTP_TEID.buf == NULLP)
10278    {
10279       return RFAILED;
10280    }
10281    bufSize = 3; /*forming an Octect String*/
10282    fillTeIdString(bufSize, gtpUeCfg->teId, gtpDl->gTP_TEID.buf);
10283
10284    return ROK;
10285 }
10286
10287 /*******************************************************************
10288  *
10289  * @brief Fills DL Tunnel Setup List
10290  *
10291  * @details
10292  *
10293  *    Function : fillDlTnlSetupList
10294  *
10295  *    Functionality: Fills the DL Tunnel Setup List
10296  *
10297  * @params[in]
10298  *
10299  * @return ROK     - success
10300  *         RFAILED - failure
10301  *
10302  * ****************************************************************/
10303
10304 uint8_t fillDlTnlSetupList(DLUPTNLInformation_ToBeSetup_List_t *dlTnlInfo, UpTnlCfg *tnlCfg)
10305 {
10306    uint8_t ret = ROK, arrIdx = 0, eleCount = 0;
10307
10308    eleCount = 1;
10309    dlTnlInfo->list.count = eleCount;
10310    dlTnlInfo->list.size = (eleCount * sizeof(DLUPTNLInformation_ToBeSetup_Item_t *));
10311
10312    /* Initialize the DL Tnl Setup List Members */
10313    DU_ALLOC(dlTnlInfo->list.array, dlTnlInfo->list.size);
10314    if(dlTnlInfo->list.array == NULLP)
10315    {
10316       DU_LOG(" ERROR  -->  F1AP : Memory allocation for DL Tnl Setup List in fillDlTnlSetupList()");
10317       ret = RFAILED;
10318    }
10319    for(arrIdx=0; arrIdx < eleCount; arrIdx++)
10320    {
10321       DU_ALLOC(dlTnlInfo->list.array[arrIdx], sizeof(DLUPTNLInformation_ToBeSetup_Item_t));
10322       if(dlTnlInfo->list.array[arrIdx] == NULLP)
10323       {
10324          DU_LOG(" ERROR  -->  F1AP : Memory allocation for arrIdx [%d] failed in fillDlTnlSetupList()", arrIdx);
10325          return RFAILED;
10326       }
10327       dlTnlInfo->list.array[arrIdx]->dLUPTNLInformation.present = UPTransportLayerInformation_PR_gTPTunnel;
10328       DU_ALLOC(dlTnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel, sizeof(GTPTunnel_t));
10329       if(dlTnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel == NULLP)
10330       {
10331          DU_LOG(" ERROR  -->  F1AP : Memory allocation for DL tunnel info in fillDlTnlSetupList()");
10332          return RFAILED;
10333       }
10334       ret = fillGtpTunnelforDl(dlTnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel,\
10335                tnlCfg->tnlCfg1);
10336       if(ret != ROK)
10337          break;
10338    }
10339    return ret;
10340 }
10341
10342 /*******************************************************************
10343  *
10344  * @brief Fills the Drb Setup List for Ue Context Setup Response
10345  *
10346  * @details
10347  *
10348  *    Function : fillDrbSetupList
10349  *
10350  *    Functionality: Fills the Drb Setup List for Ue Context Setup Response
10351  *
10352  * @params[in]
10353  *
10354  * @return ROK     - success
10355  *         RFAILED - failure
10356  *
10357  * ****************************************************************/
10358 uint8_t fillDrbSetupList(DRBs_Setup_List_t *drbSetupList, DuUeCfg *ueCfg)
10359 {
10360    uint8_t ret = ROK, arrIdx = 0, eleCount = 0;
10361    DRBs_Setup_ItemIEs_t *drbItemIe = NULLP;
10362
10363    eleCount = ueCfg->numDrb;
10364    drbSetupList->list.count = eleCount;
10365    drbSetupList->list.size = \
10366         (eleCount * sizeof(DRBs_Setup_Item_t *));
10367
10368    /* Initialize the Drb Setup List Members */
10369    DU_ALLOC(drbSetupList->list.array, drbSetupList->list.size);
10370    if(drbSetupList->list.array == NULLP)
10371    {
10372       DU_LOG(" ERROR  -->  F1AP : Memory allocation for DRB Setup List in fillDrbSetupList()");
10373       ret = RFAILED;
10374    }
10375
10376    for(arrIdx=0; arrIdx < eleCount; arrIdx++)
10377    {
10378       DU_ALLOC(drbSetupList->list.array[arrIdx], sizeof(DRBs_Setup_Item_t));
10379       if(drbSetupList->list.array[arrIdx] == NULLP)
10380       {
10381          DU_LOG(" ERROR  -->  F1AP : Memory allocation for arrIdx [%d] failed in fillDrbSetupList()", arrIdx);
10382          return RFAILED;
10383       }
10384       drbItemIe = ((DRBs_Setup_ItemIEs_t *)drbSetupList->list.array[arrIdx]);
10385       drbItemIe->id = ProtocolIE_ID_id_DRBs_Setup_Item;
10386       drbItemIe->criticality = Criticality_reject;
10387       drbItemIe->value.present = DRBs_Setup_ItemIEs__value_PR_DRBs_Setup_Item;
10388       drbItemIe->value.choice.DRBs_Setup_Item.dRBID = ueCfg->upTnlInfo[arrIdx].drbId;
10389       ret = fillDlTnlSetupList(&drbItemIe->value.choice.DRBs_Setup_Item.dLUPTNLInformation_ToBeSetup_List,\
10390           &ueCfg->upTnlInfo[arrIdx]);
10391       if(ret != ROK)
10392          break;
10393    }
10394    return ret;
10395 }
10396
10397 /*******************************************************************
10398  *
10399  * @brief Builds and sends the UE Setup Response
10400  *
10401  * @details
10402  *
10403  *    Function : BuildAndSendUeContextSetupRsp
10404  *
10405  *    Functionality: Constructs the UE Setup Response and sends
10406  *                   it to the DU through SCTP.
10407  *
10408  * @params[in]
10409  *
10410  * @return ROK     - success
10411  *         RFAILED - failure
10412  *
10413  * ****************************************************************/
10414 uint8_t BuildAndSendUeContextSetupRsp(uint8_t ueIdx, uint8_t cellId)
10415 {
10416    uint8_t   idx, ret, cellIdx, elementCnt;
10417    uint32_t  gnbCuUeF1apId;   /* gNB-CU UE F1AP Id */
10418    uint32_t  gnbDuUeF1apId;   /* gNB-DU UE F1AP Id */
10419    asn_enc_rval_t  encRetVal;        /* Encoder return value */
10420    F1AP_PDU_t               *f1apMsg = NULLP;
10421    UEContextSetupResponse_t *ueSetRsp = NULLP;
10422    CellGroupConfigRrc_t     *cellGrpCfg = NULLP;
10423    DuUeCb                   *ueCb = NULLP;
10424
10425    DU_LOG("\n INFO   -->  F1AP : Building UE Context Setup Response for cellId %d, ueIdx %d\n", cellId, ueIdx);
10426
10427    while(true)
10428    {
10429       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
10430       if(f1apMsg == NULLP)
10431       {
10432          DU_LOG(" ERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
10433          ret = RFAILED;
10434          break;
10435       }
10436
10437       f1apMsg->present = F1AP_PDU_PR_successfulOutcome;
10438       DU_ALLOC(f1apMsg->choice.successfulOutcome,
10439             sizeof(SuccessfulOutcome_t));
10440       if(f1apMsg->choice.successfulOutcome == NULLP)
10441       {
10442          DU_LOG(" ERROR  -->  F1AP : Memory allocation for      F1AP-PDU failed");
10443          ret = RFAILED;
10444          break;
10445       }
10446
10447       f1apMsg->choice.successfulOutcome->procedureCode = \
10448                                                          ProcedureCode_id_UEContextSetup;
10449       f1apMsg->choice.successfulOutcome->criticality = Criticality_reject;
10450       f1apMsg->choice.successfulOutcome->value.present = \
10451                                                          SuccessfulOutcome__value_PR_UEContextSetupResponse;
10452
10453       ueSetRsp =
10454          &f1apMsg->choice.successfulOutcome->value.choice.UEContextSetupResponse;
10455       elementCnt = 4;
10456       ueSetRsp->protocolIEs.list.count = elementCnt;
10457       ueSetRsp->protocolIEs.list.size = \
10458                                         elementCnt * sizeof(UEContextSetupResponse_t *);
10459
10460       /* Initialize the UESetup members */
10461       DU_ALLOC(ueSetRsp->protocolIEs.list.array, \
10462             ueSetRsp->protocolIEs.list.size);
10463       if(ueSetRsp->protocolIEs.list.array == NULLP)
10464       {
10465          DU_LOG(" ERROR  -->  F1AP : Memory allocation for UE Setup Response failed");
10466          ret = RFAILED;
10467          break;
10468       }
10469
10470       for(idx=0; idx<elementCnt; idx++)
10471       {
10472          DU_ALLOC(ueSetRsp->protocolIEs.list.array[idx],\
10473                sizeof(UEContextSetupResponseIEs_t));
10474          if(ueSetRsp->protocolIEs.list.array[idx] == NULLP)
10475          {
10476             DU_LOG(" ERROR  -->  F1AP : Memory allocation for UE Setup Response failed");
10477             ret = RFAILED;
10478             break;
10479          }
10480       }
10481       /* Fetching Ue Cb Info*/
10482       GET_CELL_IDX(cellId, cellIdx);
10483       gnbDuUeF1apId = duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].gnbDuUeF1apId;
10484       gnbCuUeF1apId = duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].gnbCuUeF1apId;
10485       ueCb = &duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1];
10486
10487       idx = 0;
10488       /*GNB CU UE F1AP ID*/
10489       ueSetRsp->protocolIEs.list.array[idx]->id = \
10490                                                   ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
10491       ueSetRsp->protocolIEs.list.array[idx]->criticality = Criticality_reject;
10492       ueSetRsp->protocolIEs.list.array[idx]->value.present = \
10493                                                              UEContextSetupResponseIEs__value_PR_GNB_CU_UE_F1AP_ID;
10494       ueSetRsp->protocolIEs.list.array[idx]->value.choice.GNB_CU_UE_F1AP_ID = gnbCuUeF1apId;
10495
10496       /*GNB DU UE F1AP ID*/
10497       idx++;
10498       ueSetRsp->protocolIEs.list.array[idx]->id = \
10499                                                   ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
10500       ueSetRsp->protocolIEs.list.array[idx]->criticality = Criticality_reject;
10501       ueSetRsp->protocolIEs.list.array[idx]->value.present = \
10502                                                              UEContextSetupResponseIEs__value_PR_GNB_DU_UE_F1AP_ID;
10503       ueSetRsp->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID = gnbDuUeF1apId;
10504
10505
10506       /*DUtoCURRC Information */
10507       idx++;
10508       ueSetRsp->protocolIEs.list.array[idx]->id  = \
10509                                                    ProtocolIE_ID_id_DUtoCURRCInformation;
10510       ueSetRsp->protocolIEs.list.array[idx]->criticality = Criticality_reject;
10511       ueSetRsp->protocolIEs.list.array[idx]->value.present =\
10512                                                             UEContextSetupResponseIEs__value_PR_DUtoCURRCInformation;
10513       if(ueCb->f1UeDb)
10514       {
10515          if(ueCb->f1UeDb->duUeCfg.cellGrpCfg)
10516          {
10517             cellGrpCfg = (CellGroupConfigRrc_t*)ueCb->f1UeDb->duUeCfg.cellGrpCfg;
10518             ret = EncodeUeCntxtDuToCuInfo(&ueSetRsp->protocolIEs.list.array[idx]->value.\
10519                      choice.DUtoCURRCInformation.cellGroupConfig, cellGrpCfg);
10520             if(ret == RFAILED)
10521             {
10522                DU_LOG("\nERROR  -->  F1AP : Failed to EncodeUeCntxtDuToCuInfo in BuildAndSendUeContextSetupRsp()");
10523                freeF1UeDb(ueCb->f1UeDb);
10524                ueCb->f1UeDb = NULLP;
10525                break;
10526             }
10527          }
10528       }
10529       else
10530       {
10531          DU_LOG("\nERROR  -->  F1AP : Failed to form DUtoCU RRCInfo at BuildAndSendUeContextSetupRsp()");
10532          ret = RFAILED;
10533          break;
10534       }
10535
10536       /* Drb Setup List */
10537       idx++;
10538       ueSetRsp->protocolIEs.list.array[idx]->id  = \
10539                                  ProtocolIE_ID_id_DRBs_Setup_List;
10540       ueSetRsp->protocolIEs.list.array[idx]->criticality = Criticality_reject;
10541       ueSetRsp->protocolIEs.list.array[idx]->value.present =\
10542                                  UEContextSetupResponseIEs__value_PR_DRBs_Setup_List;
10543       ret = fillDrbSetupList(&ueSetRsp->protocolIEs.list.array[idx]->value.choice.DRBs_Setup_List,\
10544                &ueCb->f1UeDb->duUeCfg);
10545       if(ret == RFAILED)
10546       {
10547          DU_LOG("\nERROR  -->  F1AP : Failed to fillDrbSetupList in BuildAndSendUeContextSetupRsp()");
10548          freeF1UeDb(ueCb->f1UeDb);
10549          ueCb->f1UeDb = NULLP;
10550          break;
10551       }
10552
10553        /* Free UeContext Db created during Ue context Req */
10554        freeF1UeDb(ueCb->f1UeDb);
10555        ueCb->f1UeDb = NULLP;
10556
10557       /* TODO: To send Drb list */
10558       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
10559
10560       /* Encode the UE context setup response type as APER */
10561       memset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
10562       encBufSize = 0;
10563       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
10564             encBuf);
10565       /* Encode results */
10566       if(encRetVal.encoded == ENCODE_FAIL)
10567       {
10568          DU_LOG( "\nERROR  -->  F1AP : Could not encode UE Context Setup Response structure (at %s)\n",\
10569                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
10570          ret = RFAILED;
10571          break;
10572       }
10573       else
10574       {
10575          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for UE Context Setup Response\n");
10576          for(int i=0; i< encBufSize; i++)
10577          {
10578             printf("%x",encBuf[i]);
10579          }
10580       }
10581
10582       /* Sending  msg  */
10583       if(SendF1APMsg(DU_APP_MEM_REGION,DU_POOL) != ROK)
10584       {
10585          DU_LOG("\nERROR  -->  F1AP : Sending UE Context Setup Response failed");
10586          ret = RFAILED;
10587          break;
10588       }
10589       break;
10590    }
10591    FreeUeContextSetupRsp(f1apMsg);
10592    return ret;
10593 }/* End of BuildAndSendUeContextSetupRsp */
10594 /*******************************************************************
10595 *
10596 * @brief  Build And Send Ue Context Rsp
10597 *
10598 * @details
10599 *
10600 *    Function : BuildAndSendUeCtxtRsp
10601 *
10602 *    Functionality : Build And Send Ue Context Rsp
10603
10604 * @params[in]
10605 * @return sucess = ROK
10606 *         failure = RFAILED
10607 *
10608 * ****************************************************************/
10609 uint8_t BuildAndSendUeCtxtRsp(uint8_t ueIdx, uint8_t cellId)
10610 {
10611    uint8_t cellIdx = 0, actionType = 0;
10612
10613    GET_CELL_IDX(cellId, cellIdx);
10614    actionType = duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].f1UeDb->actionType;
10615
10616    switch(actionType)
10617    {
10618       case UE_CTXT_SETUP:
10619          BuildAndSendUeContextSetupRsp(ueIdx, cellId);
10620          break;
10621       case UE_CTXT_MOD:
10622          BuildAndSendUeContextModResp(ueIdx, cellId);
10623          break;
10624       default:
10625          DU_LOG("ERROR  -->  F1AP: Invalid Action Type %d at BuildAndSendUeCtxtRsp()", actionType);
10626          break;
10627
10628    }
10629    return ROK;
10630 }
10631
10632 /*******************************************************************
10633  *
10634  * @brief deallocating the memory of  F1reset msg
10635  *
10636  * @details
10637  *
10638  *    Function : FreeF1ResetReq
10639  *
10640  *    Functionality :
10641  *         - freeing memory of F1reset request msg
10642  *
10643  * @params[in]
10644  * @return void
10645  *
10646  *
10647  * ****************************************************************/
10648 void FreeF1ResetReq(F1AP_PDU_t *f1apMsg)
10649 {
10650    uint8_t idx =0 ;
10651    Reset_t *f1ResetMsg;
10652
10653    if(f1apMsg)
10654    {
10655       if(f1apMsg->choice.initiatingMessage)
10656       {
10657          f1ResetMsg = &f1apMsg->choice.initiatingMessage->value.choice.Reset;
10658
10659          if(f1ResetMsg->protocolIEs.list.array)
10660          {
10661             for(idx=0 ;idx < f1ResetMsg->protocolIEs.list.count ; idx++)
10662             {
10663                if(f1ResetMsg->protocolIEs.list.array[idx])
10664                {
10665                   DU_FREE(f1ResetMsg->protocolIEs.list.array[idx],sizeof(ResetIEs_t));
10666                }
10667             }
10668             DU_FREE(f1ResetMsg->protocolIEs.list.array,f1ResetMsg->protocolIEs.list.size);
10669          }
10670          DU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
10671       }
10672       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
10673    }
10674 }
10675 /*******************************************************************
10676  *
10677  * @brief Build and Send F1reset request
10678  *
10679  * @details
10680  *
10681  *    Function : BuildAndSendF1ResetReq
10682  *
10683  *    Functionality:
10684  *         - Build and Send F1reset request msg
10685  *
10686  * @params[in]
10687  * @return ROK     - success
10688  *         RFAILED - failure
10689  *
10690  * ****************************************************************/
10691 uint8_t BuildAndSendF1ResetReq()
10692 {
10693    uint8_t          elementCnt=0;
10694    uint8_t          idx=0;
10695    uint8_t          ret= RFAILED;
10696    Reset_t          *f1ResetMsg = NULLP;
10697    F1AP_PDU_t       *f1apMsg = NULLP;
10698    asn_enc_rval_t   encRetVal;
10699    DU_LOG("\nINFO   -->  F1AP : Building F1 Reset request \n");
10700    do
10701    {
10702       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
10703       if(f1apMsg == NULLP)
10704       {
10705          break;
10706       }
10707       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
10708       DU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
10709       if(f1apMsg->choice.initiatingMessage == NULLP)
10710       {
10711          break;
10712       }
10713       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_Reset;
10714       f1apMsg->choice.initiatingMessage->criticality = Criticality_reject;
10715       f1apMsg->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_Reset;
10716
10717       f1ResetMsg = &f1apMsg->choice.initiatingMessage->value.choice.Reset;
10718
10719       elementCnt = 3;
10720       f1ResetMsg->protocolIEs.list.count = elementCnt;
10721       f1ResetMsg->protocolIEs.list.size = elementCnt * sizeof(ResetIEs_t *);
10722
10723       /* Initialize the F1Setup members */
10724       DU_ALLOC(f1ResetMsg->protocolIEs.list.array,f1ResetMsg->protocolIEs.list.size);
10725       if(f1ResetMsg->protocolIEs.list.array == NULLP)
10726       {
10727          break;
10728       }
10729       for(idx=0; idx<elementCnt; idx++)
10730       {
10731          DU_ALLOC(f1ResetMsg->protocolIEs.list.array[idx],sizeof(ResetIEs_t));
10732          if(f1ResetMsg->protocolIEs.list.array[idx] == NULLP)
10733          {
10734             break;
10735          }
10736       }
10737
10738       /*TransactionID*/
10739       idx=0;
10740       f1ResetMsg->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_TransactionID;
10741       f1ResetMsg->protocolIEs.list.array[idx]->criticality = Criticality_reject;
10742       f1ResetMsg->protocolIEs.list.array[idx]->value.present = ResetIEs__value_PR_TransactionID;
10743       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.TransactionID = 1;
10744
10745       /*Cause*/
10746       idx++;
10747       f1ResetMsg->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_Cause;
10748       f1ResetMsg->protocolIEs.list.array[idx]->criticality = Criticality_ignore;
10749       f1ResetMsg->protocolIEs.list.array[idx]->value.present = ResetIEs__value_PR_Cause;
10750       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.Cause.present = Cause_PR_radioNetwork;
10751       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.Cause.choice.radioNetwork = CauseRadioNetwork_action_desirable_for_radio_reasons;
10752
10753       /*Reset Type*/
10754       idx++;
10755       f1ResetMsg->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_ResetType;
10756       f1ResetMsg->protocolIEs.list.array[idx]->criticality = Criticality_reject;
10757       f1ResetMsg->protocolIEs.list.array[idx]->value.present = ResetIEs__value_PR_ResetType;
10758       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.ResetType.present = ResetType_PR_f1_Interface;
10759       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.ResetType.choice.f1_Interface = ResetAll_reset_all;
10760
10761       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
10762
10763       /* Encode the F1SetupRequest type as APER */
10764       memset(encBuf, 0, ENC_BUF_MAX_LEN);
10765       encBufSize = 0;
10766       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
10767             encBuf);
10768
10769       /* Encode results */
10770       if(encRetVal.encoded == ENCODE_FAIL)
10771       {
10772          DU_LOG("\nERROR  -->  F1AP : Could not encode F1Reset structure (at %s)\n",\
10773                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
10774          break;
10775       }
10776       else
10777       {
10778          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for F1Reset\n");
10779          for(idx=0; idx< encBufSize; idx++)
10780          {
10781             printf("%x",encBuf[idx]);
10782          }
10783       }
10784
10785       if(SendF1APMsg(DU_APP_MEM_REGION, DU_POOL) != ROK)
10786       {
10787          DU_LOG("\nERROR  -->  F1AP : Sending F1 Reset request failed");
10788          break;
10789       }
10790
10791       ret = ROK;
10792       break;
10793    }while(true);
10794
10795    FreeF1ResetReq(f1apMsg);
10796    return ret;
10797 }
10798 /*******************************************************************
10799  *
10800  * @brief Build And Send F1ResetAck
10801  *
10802  * @details
10803  *
10804  *    Function : BuildAndSendF1ResetAck
10805  *
10806  *    Functionality:
10807  *         - Build And Send  F1ResetRSP
10808  *
10809  * @return ROK     - success
10810  *         RFAILED - failure
10811  *
10812  * ****************************************************************/
10813 void FreeF1ResetAck(F1AP_PDU_t *f1apMsg)
10814 {
10815    uint8_t idx;
10816    ResetAcknowledge_t *f1ResetAck;
10817
10818    if(f1apMsg)
10819    {
10820       if(f1apMsg->choice.successfulOutcome)
10821       {
10822          f1ResetAck= &f1apMsg->choice.successfulOutcome->value.choice.ResetAcknowledge;
10823
10824          if(f1ResetAck->protocolIEs.list.array)
10825          {
10826             for(idx=0; idx<f1ResetAck->protocolIEs.list.count ; idx++)
10827             {
10828                if(f1ResetAck->protocolIEs.list.array[idx])
10829                {
10830                   DU_FREE(f1ResetAck->protocolIEs.list.array[idx], sizeof(ResetAcknowledgeIEs_t));
10831                }
10832             }
10833             DU_FREE(f1ResetAck->protocolIEs.list.array, f1ResetAck->protocolIEs.list.size );
10834          }
10835          DU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
10836       }
10837       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
10838    }
10839 }
10840
10841 /*******************************************************************
10842  *
10843  * @brief Build And Send F1ResetAck
10844  *
10845  * @details
10846  *
10847  *    Function : BuildAndSendF1ResetAck
10848  *
10849  *    Functionality:
10850  *         - Build And Send  F1ResetRSP
10851  *
10852  *  @params[in]
10853  * @return ROK     - success
10854  *         RFAILED - failure
10855  *
10856  * ****************************************************************/
10857 uint8_t BuildAndSendF1ResetAck()
10858 {
10859    uint8_t                idx = 0;
10860    uint8_t                elementCnt = 0;
10861    uint8_t                ret = RFAILED;
10862    F1AP_PDU_t             *f1apMsg = NULL;
10863    ResetAcknowledge_t     *f1ResetAck = NULLP;
10864    asn_enc_rval_t         encRetVal;
10865    DU_LOG("\nINFO   -->  F1AP : Building F1 Reset Acknowledgment \n");
10866
10867    do{
10868       /* Allocate the memory for F1ResetRequest_t */
10869       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
10870       if(f1apMsg == NULLP)
10871       {
10872          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
10873          break;
10874       }
10875
10876       f1apMsg->present =  F1AP_PDU_PR_successfulOutcome;
10877
10878       DU_ALLOC(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
10879       if(f1apMsg->choice.successfulOutcome == NULLP)
10880       {
10881          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
10882          break;
10883       }
10884       f1apMsg->choice.successfulOutcome->criticality   = Criticality_reject;
10885       f1apMsg->choice.successfulOutcome->value.present = SuccessfulOutcome__value_PR_ResetAcknowledge;
10886       f1ResetAck = &f1apMsg->choice.successfulOutcome->value.choice.ResetAcknowledge;
10887
10888       elementCnt = 1;
10889
10890       f1ResetAck->protocolIEs.list.count = elementCnt;
10891       f1ResetAck->protocolIEs.list.size = elementCnt*sizeof(ResetAcknowledgeIEs_t *);
10892
10893       DU_ALLOC(f1ResetAck->protocolIEs.list.array, f1ResetAck->protocolIEs.list.size );
10894       if(f1ResetAck->protocolIEs.list.array == NULLP)
10895       {
10896          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1ResetAckIEs failed");
10897          break;
10898       }
10899
10900       for(idx=0; idx<elementCnt; idx++)
10901       {
10902          DU_ALLOC(f1ResetAck->protocolIEs.list.array[idx], sizeof(ResetAcknowledgeIEs_t));
10903          if(f1ResetAck->protocolIEs.list.array[idx] == NULLP)
10904          {
10905             break;
10906          }
10907       }
10908       /*TransactionID*/
10909       idx = 0;
10910       f1ResetAck->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_TransactionID;
10911       f1ResetAck->protocolIEs.list.array[idx]->criticality = Criticality_reject;
10912       f1ResetAck->protocolIEs.list.array[idx]->value.present = ResetAcknowledgeIEs__value_PR_TransactionID;
10913       f1ResetAck->protocolIEs.list.array[idx]->value.choice.TransactionID = TRANS_ID;
10914
10915       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
10916
10917       /* Encode the F1SetupRequest type as UPER */
10918       memset(encBuf, 0, ENC_BUF_MAX_LEN);
10919       encBufSize = 0;
10920       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
10921
10922       /* Check encode results */
10923       if(encRetVal.encoded == ENCODE_FAIL)
10924       {
10925          DU_LOG("\nERROR  -->  F1AP : Could not encode F1ResetAck structure (at %s)\n",\
10926                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
10927          break;
10928       }
10929       else
10930       {
10931          DU_LOG("\nDUBUG   -->  F1AP : Created APER encoded buffer for F1ResetAck\n");
10932          for(int i=0; i< encBufSize; i++)
10933          {
10934             printf("%x",encBuf[i]);
10935          }
10936       }
10937       /* Sending msg */
10938       if(SendF1APMsg(DU_APP_MEM_REGION, DU_POOL) != ROK)
10939       {
10940          DU_LOG("\nERROR  -->  F1AP : Sending F1 Reset Acknowledgement failed");
10941          break;
10942       }
10943
10944       ret = ROK;
10945       break;
10946    }while(true);
10947
10948    FreeF1ResetAck(f1apMsg);
10949    return ret;
10950 }
10951 /******************************************************************
10952 *
10953 * @brief free F1 reset msg allocated by aper_decoder
10954 *
10955 * @details
10956 *
10957 *    Function : freeAperDecodeF1ResetMsg
10958 *
10959 *    Functionality: free F1 reset msg allocated by aper_decoder
10960 *
10961 * @params[in] Reset_t *f1ResetMsg
10962 * @return void
10963 *
10964 * ****************************************************************/
10965
10966 void freeAperDecodeF1ResetMsg(Reset_t *f1ResetMsg)
10967 {
10968    uint8_t ieIdx =0;
10969    if(f1ResetMsg->protocolIEs.list.array)
10970    {
10971       for(ieIdx=0 ;ieIdx < f1ResetMsg->protocolIEs.list.count ; ieIdx++)
10972       {
10973          if(f1ResetMsg->protocolIEs.list.array[ieIdx])
10974          {
10975             free(f1ResetMsg->protocolIEs.list.array[ieIdx]);
10976          }
10977       }
10978       free(f1ResetMsg->protocolIEs.list.array);
10979    }
10980 }
10981
10982 /******************************************************************
10983  *
10984  * @brief Processes DL RRC Message Transfer  sent by CU
10985  *
10986  * @details
10987  *
10988  *    Function : procF1ResetReq
10989  *
10990  *    Functionality: Processes DL RRC Message Transfer sent by CU
10991  *
10992  * @params[in] F1AP_PDU_t ASN decoded F1AP message
10993  * @return ROK     - success
10994  *         RFAILED - failure
10995  *
10996  * ****************************************************************/
10997 uint8_t procF1ResetReq(F1AP_PDU_t *f1apMsg)
10998 {
10999    /* we are currently not supporting Ue release. right now we are supporting only init case of fireset */
11000    uint8_t       ieIdx = 0;
11001    uint8_t        ret = ROK;
11002    Reset_t       *f1ResetMsg = NULLP;
11003
11004    DU_LOG("\nINFO   -->  Processing F1 reset request");
11005    f1ResetMsg = &f1apMsg->choice.initiatingMessage->value.choice.Reset;
11006
11007    for(ieIdx=0; ieIdx<f1ResetMsg->protocolIEs.list.count; ieIdx++)
11008    {
11009       switch(f1ResetMsg->protocolIEs.list.array[ieIdx]->id)
11010       {
11011          case ProtocolIE_ID_id_TransactionID:
11012             break;
11013
11014          case ProtocolIE_ID_id_Cause:
11015             break;
11016
11017          case ProtocolIE_ID_id_ResetType:
11018             {
11019                break;
11020             }
11021
11022          default:
11023             break;
11024       }
11025    }
11026    ret = BuildAndSendF1ResetAck();
11027    DU_LOG("\nINFO   -->  UE release is not supported for now");
11028
11029    freeAperDecodeF1ResetMsg(f1ResetMsg);
11030
11031    return ret;
11032 }
11033
11034 /*******************************************************************
11035  *
11036  * @brief free the RRC delivery report
11037  *
11038  * @details
11039  *
11040  *    Function : freeRrcDeliveryReport
11041  *
11042  *    Functionality: free the RRC delivery report
11043  *
11044  * @params[in]
11045  * @return ROK     - success
11046  *         RFAILED - failure
11047  *
11048  * ****************************************************************/
11049 void freeRrcDeliveryReport(F1AP_PDU_t  *f1apMsg )
11050 {
11051    uint8_t idx=0;
11052    RRCDeliveryReport_t *rrcDeliveryReport= NULLP;
11053
11054    if(f1apMsg)
11055    {
11056       if(f1apMsg->choice.initiatingMessage)
11057       {
11058          rrcDeliveryReport = &f1apMsg->choice.initiatingMessage->value.choice.RRCDeliveryReport;
11059          if(rrcDeliveryReport->protocolIEs.list.array)
11060          {
11061             for(idx =0 ;idx <rrcDeliveryReport->protocolIEs.list.count ;
11062                   idx++)
11063             {
11064                if(rrcDeliveryReport->protocolIEs.list.array[idx])
11065                {
11066                   DU_FREE(rrcDeliveryReport->protocolIEs.list.array[idx],
11067                         sizeof(RRCDeliveryReportIEs_t));
11068                }
11069             }
11070             DU_FREE(rrcDeliveryReport->protocolIEs.list.array,
11071                   rrcDeliveryReport->protocolIEs.list.size);
11072          }
11073          DU_FREE(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
11074       }
11075       DU_FREE(f1apMsg,
11076             sizeof(F1AP_PDU_t));
11077    }
11078 }
11079
11080 /*******************************************************************
11081 *
11082 * @brief Builds and sends the RRC delivery report
11083 *
11084 * @details
11085 *
11086 *    Function : BuildAndSendRrcDeliveryReport
11087 *
11088 *    Functionality: Builds and sends the RRC delivery report
11089 *
11090 * @params[in]
11091 *
11092 * @return ROK     - success
11093 *         RFAILED - failure
11094 *
11095 * ****************************************************************/
11096 uint8_t BuildAndSendRrcDeliveryReport(uint32_t gnbCuUeF1apId, \
11097    uint32_t gnbDuUeF1apId, RrcDeliveryReport *rrcDelivery)
11098 {
11099    uint8_t             ret = RFAILED;
11100    uint8_t             idx    = 0;
11101    uint8_t             idx1   = 0;
11102    uint8_t             elementCnt = 0;
11103    F1AP_PDU_t          *f1apMsg = NULLP;
11104    asn_enc_rval_t      encRetVal;
11105    RRCDeliveryReport_t *rrcDeliveryReport= NULLP;
11106
11107    do{
11108
11109       DU_LOG("\nINFO   -->  F1AP : Building RRC delivery Message Transfer Message\n");
11110       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
11111       if(f1apMsg == NULLP)
11112       {
11113          DU_LOG(" ERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
11114          break;
11115       }
11116       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
11117       DU_ALLOC(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
11118       if(f1apMsg->choice.initiatingMessage == NULLP)
11119       {
11120          DU_LOG(" ERROR  -->  F1AP : Memory allocation for  F1AP-PDU  failed");
11121          break;
11122       }
11123       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_RRCDeliveryReport;
11124       f1apMsg->choice.initiatingMessage->criticality   = Criticality_ignore;
11125       f1apMsg->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_RRCDeliveryReport;
11126
11127       rrcDeliveryReport = &f1apMsg->choice.initiatingMessage->value.choice.RRCDeliveryReport;
11128       elementCnt = 4;
11129       rrcDeliveryReport->protocolIEs.list.count = elementCnt;
11130       rrcDeliveryReport->protocolIEs.list.size = elementCnt * sizeof(RRCDeliveryReportIEs_t *);
11131
11132       /* Initialize the F1Setup members */
11133       DU_ALLOC(rrcDeliveryReport->protocolIEs.list.array, rrcDeliveryReport->protocolIEs.list.size);
11134       if(rrcDeliveryReport->protocolIEs.list.array == NULLP)
11135       {
11136          DU_LOG(" ERROR  -->  F1AP : Memory allocation for RRC Delivery  failed");
11137          break;
11138       }
11139       for(idx =0 ;idx <elementCnt; idx++)
11140       {
11141          DU_ALLOC(rrcDeliveryReport->protocolIEs.list.array[idx], sizeof(RRCDeliveryReportIEs_t));
11142          if(rrcDeliveryReport->protocolIEs.list.array[idx] == NULLP)
11143          {
11144             break;
11145          }
11146       }
11147
11148       idx1 = 0;
11149
11150       /*GNB CU UE F1AP ID*/
11151       rrcDeliveryReport->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
11152       rrcDeliveryReport->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
11153       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.present = RRCDeliveryReportIEs__value_PR_GNB_CU_UE_F1AP_ID;
11154       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.choice.GNB_CU_UE_F1AP_ID = gnbCuUeF1apId;
11155
11156       /*GNB DU UE F1AP ID*/
11157       idx1++;
11158       rrcDeliveryReport->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
11159       rrcDeliveryReport->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
11160       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.present = RRCDeliveryReportIEs__value_PR_GNB_DU_UE_F1AP_ID;
11161       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.choice.GNB_DU_UE_F1AP_ID = gnbDuUeF1apId;
11162
11163       /*RRC delivery status*/
11164       idx1++;
11165       rrcDeliveryReport->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_RRCDeliveryStatus;
11166       rrcDeliveryReport->protocolIEs.list.array[idx1]->criticality = Criticality_ignore;
11167       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.present = RRCDeliveryReportIEs__value_PR_RRCDeliveryStatus;
11168       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.choice.RRCDeliveryStatus.delivery_status =\
11169       rrcDelivery->rrcDeliveryStatus.deliveryStatus;
11170       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.choice.RRCDeliveryStatus.triggering_message =\
11171       rrcDelivery->rrcDeliveryStatus.triggeringMessage;
11172
11173       /* SRB ID */
11174       idx1++;
11175       rrcDeliveryReport->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_SRBID;
11176       rrcDeliveryReport->protocolIEs.list.array[idx1]->criticality = Criticality_ignore;
11177       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.present = RRCDeliveryReportIEs__value_PR_SRBID;
11178       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.choice.SRBID =  rrcDelivery->srbId;
11179
11180       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
11181
11182       /* Encode the RRC DELIVERY REPORT type as APER */
11183       memset(encBuf, 0, ENC_BUF_MAX_LEN);
11184       encBufSize = 0;
11185       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
11186             encBuf);
11187
11188       /* Encode results */
11189       if(encRetVal.encoded == ENCODE_FAIL)
11190       {
11191          DU_LOG("\nERROR  -->  F1AP : Could not encode RRC Delivery Msg structure (at %s)\n",\
11192                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
11193          break;
11194       }
11195       else
11196       {
11197          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for RRC Delivery Msg \n");
11198          for(idx=0; idx< encBufSize; idx++)
11199          {
11200             printf("%x",encBuf[idx]);
11201          }
11202       }
11203
11204       /* Sending msg */
11205       if(SendF1APMsg(DU_APP_MEM_REGION, DU_POOL) != ROK)
11206       {
11207          DU_LOG("\nERROR  -->  F1AP : Sending RRC delivery  msg request failed");
11208          break;
11209       }
11210       ret = ROK;
11211       break;
11212
11213    }while(true);
11214
11215    freeRrcDeliveryReport(f1apMsg);
11216    return ret;
11217 }
11218
11219 /*******************************************************************
11220  *
11221  * @brief Processes cells to be activated
11222  *
11223  * @details
11224  *
11225  *    Function : extractCellsToBeActivated
11226  *
11227  *    Functionality:
11228  *      - Processes cells to be activated list received in F1SetupRsp
11229  *
11230  * @params[in] void
11231  * @return ROK     - success
11232  *         RFAILED - failure
11233  *
11234  * ****************************************************************/
11235
11236 uint8_t extractCellsToBeActivated(Cells_to_be_Activated_List_t cellsToActivate)
11237 {
11238    uint8_t  ret = ROK;
11239    uint16_t idx, nci, pci = 0;
11240    Cells_to_be_Activated_List_Item_t cell;
11241
11242    for(idx=0; idx<cellsToActivate.list.count; idx++)
11243    {
11244       nci = 0;
11245       cell = cellsToActivate.list.array[idx]->value.choice.Cells_to_be_Activated_List_Item;
11246       bitStringToInt(&cell.nRCGI.nRCellIdentity, &nci);
11247
11248       if(cell.nRPCI)
11249       {
11250          pci = *cell.nRPCI;
11251       }
11252       ret = duProcCellsToBeActivated(cell.nRCGI.pLMN_Identity.buf, nci, pci);
11253    }
11254    return ret;
11255 }
11256 /******************************************************************
11257 *
11258 * @brief Processes F1 Setup Response allocated by aper_decoder
11259 *
11260 * @details
11261 *
11262 *    Function : freeF1SetupRsp
11263 *
11264 *    Functionality: free F1 Setup Response allocated by aper_decoder
11265 *
11266 * @params[in] F1SetupResponse_t *f1SetRspMsg
11267 * @return void
11268 *
11269 * ****************************************************************/
11270
11271 void freeAperDecodeF1SetupRsp(F1SetupResponse_t *f1SetRspMsg)
11272 {
11273    uint8_t ieIdx =0;
11274    uint8_t arrIdx =0;
11275    Cells_to_be_Activated_List_t *cellToActivate =NULLP;
11276    RRC_Version_t      *rrcVer =NULLP;
11277
11278    if(f1SetRspMsg->protocolIEs.list.array)
11279    {
11280       for(ieIdx=0; ieIdx<f1SetRspMsg->protocolIEs.list.count; ieIdx++)
11281       {
11282          if(f1SetRspMsg->protocolIEs.list.array[ieIdx])
11283          {
11284             switch(f1SetRspMsg->protocolIEs.list.array[ieIdx]->id)
11285             {
11286                case ProtocolIE_ID_id_Cells_to_be_Activated_List:
11287                   {
11288                      cellToActivate =
11289                         &f1SetRspMsg->protocolIEs.list.array[ieIdx]->value.choice.Cells_to_be_Activated_List;
11290                      if(cellToActivate->list.array)
11291                      {
11292                         for(arrIdx=0; arrIdx<cellToActivate->list.count ; arrIdx++)
11293                         {
11294                            if(cellToActivate->list.array[arrIdx])
11295                            {
11296
11297                               if(cellToActivate->list.array[0]->value.choice.Cells_to_be_Activated_List_Item.nRCGI.\
11298                               pLMN_Identity.buf)
11299                               {
11300                                  if(cellToActivate->list.array[0]->value.choice.\
11301                                        Cells_to_be_Activated_List_Item.nRCGI.nRCellIdentity.buf)
11302                                  {
11303                                     free(cellToActivate->list.array[0]->value.choice.\
11304                                           Cells_to_be_Activated_List_Item.nRCGI.nRCellIdentity.buf);
11305                                  }
11306
11307                                  free(cellToActivate->list.array[0]->value.choice.Cells_to_be_Activated_List_Item.\
11308                                        nRCGI.pLMN_Identity.buf);
11309                               }
11310                               free(cellToActivate->list.array[arrIdx]);
11311                            }
11312                         }
11313                         free(cellToActivate->list.array);
11314                      }
11315                      break;
11316                   }
11317                case ProtocolIE_ID_id_TransactionID:
11318                   {
11319                      break;
11320                   }
11321                case ProtocolIE_ID_id_gNB_CU_Name:
11322                   {
11323                      free(f1SetRspMsg->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_Name.buf);
11324                      break;
11325                   }
11326                case ProtocolIE_ID_id_GNB_CU_RRC_Version:
11327                   {
11328                      rrcVer = &f1SetRspMsg->protocolIEs.list.array[ieIdx]->value.choice.RRC_Version;
11329                      if(rrcVer->latest_RRC_Version.buf)
11330                      {
11331                         if(rrcVer->iE_Extensions)
11332                         {
11333                            if(rrcVer->iE_Extensions->list.array)
11334                            {
11335                               if(rrcVer->iE_Extensions->list.array[0])
11336                               {
11337                                  if(rrcVer->iE_Extensions->list.\
11338                                        array[0]->extensionValue.choice.Latest_RRC_Version_Enhanced.buf)
11339                                  {
11340                                     free(rrcVer->iE_Extensions->list.\
11341                                           array[0]->extensionValue.choice.Latest_RRC_Version_Enhanced.buf);
11342                                  }
11343                                  free(rrcVer->iE_Extensions->list.array[0]);
11344                               }
11345                               free(rrcVer->iE_Extensions->list.array);
11346                            }
11347                            free(rrcVer->iE_Extensions);
11348                         }
11349                         free(rrcVer->latest_RRC_Version.buf);
11350                      }
11351                      break;
11352
11353                   }
11354                default:
11355                   {
11356                      DU_LOG("\nERROR  -->  DU_APP : Invalid IE received in F1SetupRsp:%ld",
11357                            f1SetRspMsg->protocolIEs.list.array[ieIdx]->id);
11358                   }
11359             }
11360             free(f1SetRspMsg->protocolIEs.list.array[ieIdx]);
11361          }
11362       }
11363       free(f1SetRspMsg->protocolIEs.list.array);
11364    }
11365 }
11366 /******************************************************************
11367  *
11368  * @brief Processes F1 Setup Response sent by CU
11369  *
11370  * @details
11371  *
11372  *    Function : procF1SetupRsp
11373  *
11374  *    Functionality: Processes F1 Setup Response sent by CU
11375  *
11376  * @params[in] F1AP_PDU_t ASN decoded F1AP message
11377  * @return ROK     - success
11378  *         RFAILED - failure
11379  *
11380  * ****************************************************************/
11381 uint8_t procF1SetupRsp(F1AP_PDU_t *f1apMsg)
11382 {
11383    uint8_t ret = ROK;
11384    uint16_t idx =0;
11385    F1SetupResponse_t *f1SetRspMsg = NULLP;
11386    GNB_CU_Name_t     *cuName = NULLP;
11387    F1SetupRsp  f1SetRspDb;
11388    RRC_Version_t      *rrcVer =NULLP;
11389
11390    memset(&f1SetRspDb, 0, sizeof(F1SetupRsp));
11391
11392    DU_LOG("\nINFO   -->  F1AP : F1 Setup Response received");
11393    f1SetRspMsg = &f1apMsg->choice.successfulOutcome->value.choice.F1SetupResponse;
11394
11395    for(idx=0; idx<f1SetRspMsg->protocolIEs.list.count; idx++)
11396    {
11397       switch(f1SetRspMsg->protocolIEs.list.array[idx]->id)
11398       {
11399          case ProtocolIE_ID_id_Cells_to_be_Activated_List:
11400             {
11401                extractCellsToBeActivated(f1SetRspMsg->protocolIEs.list.array[idx]->\
11402                      value.choice.Cells_to_be_Activated_List);
11403                break;
11404             }
11405          case ProtocolIE_ID_id_TransactionID:
11406             {
11407                f1SetRspDb.transId = f1SetRspMsg->protocolIEs.list.array[idx]->\
11408                                     value.choice.TransactionID;
11409                break;
11410             }
11411          case ProtocolIE_ID_id_gNB_CU_Name:
11412             {
11413                cuName = &f1SetRspMsg->protocolIEs.list.array[idx]->\
11414                         value.choice.GNB_CU_Name;
11415                strcpy(f1SetRspDb.cuName, (const char*)cuName->buf);
11416                break;
11417             }
11418          case ProtocolIE_ID_id_GNB_CU_RRC_Version:
11419             {
11420                rrcVer = &f1SetRspMsg->protocolIEs.list.array[idx]->value.choice.RRC_Version;
11421                strcpy(f1SetRspDb.rrcVersion.rrcVer,
11422                      (const char*)rrcVer->latest_RRC_Version.buf);
11423                break;
11424             }
11425          default:
11426             DU_LOG("\nERROR  -->  DU_APP : Invalid IE received in F1SetupRsp:%ld",
11427                   f1SetRspMsg->protocolIEs.list.array[idx]->id);
11428       }
11429       duProcF1SetupRsp();
11430    }
11431
11432    freeAperDecodeF1SetupRsp(f1SetRspMsg);
11433    return ret;
11434 }
11435 /*******************************************************************
11436 *
11437 * @brief free GNB DU config update ack
11438 *
11439 * @details
11440 *
11441 *    Function : freeAperDecodeGnbDuAck
11442 *
11443 *    Functionality: Processes GNB DU config update ack And
11444 *                     added free part for the memory allocated by aper_decoder
11445 *
11446 * @params[in] F1AP_PDU_t ASN decoded F1AP message
11447 * @return ROK     - success
11448 *         RFAILED - failure
11449 *
11450 * ****************************************************************/
11451
11452 void freeAperDecodeGnbDuAck(GNBDUConfigurationUpdateAcknowledge_t *gnbDuAck)
11453 {
11454    uint8_t ieIdx = 0;
11455
11456    if(gnbDuAck->protocolIEs.list.array)
11457    {
11458       for(ieIdx=0; ieIdx < gnbDuAck->protocolIEs.list.count; ieIdx++)
11459       {
11460          if(gnbDuAck->protocolIEs.list.array[ieIdx])
11461          {
11462             free(gnbDuAck->protocolIEs.list.array[ieIdx]);
11463          }
11464       }
11465       free(gnbDuAck->protocolIEs.list.array);
11466    }
11467 }
11468 /*******************************************************************
11469 *
11470 * @brief Processes GNB DU config update ack
11471 *
11472 * @details
11473 *
11474 *    Function : procF1GNBDUCfgUpdAck
11475 *
11476 *    Functionality: added free part for the memory allocated by aper_decoder
11477 *
11478 * @params[in] F1AP_PDU_t *f1apMsg
11479 * @return void
11480 *
11481 * ****************************************************************/
11482 uint8_t procF1GNBDUCfgUpdAck(F1AP_PDU_t *f1apMsg)
11483 {
11484    uint8_t ieIdx;
11485    GNBDUConfigurationUpdateAcknowledge_t *gnbDuAck = NULLP;
11486
11487    DU_LOG("\nINFO   -->  F1AP : GNB-DU config update acknowledgment");
11488    gnbDuAck = &f1apMsg->choice.successfulOutcome->value.choice.GNBDUConfigurationUpdateAcknowledge;
11489
11490    for(ieIdx=0; ieIdx < gnbDuAck->protocolIEs.list.count; ieIdx++)
11491    {
11492       switch(gnbDuAck->protocolIEs.list.array[ieIdx]->id)
11493       {
11494          case ProtocolIE_ID_id_TransactionID:
11495             break;
11496          case ProtocolIE_ID_id_Cells_to_be_Activated_List:
11497             break;
11498          default :
11499             DU_LOG("\nERROR  -->  F1AP: Invalid IE Received: %ld, at procF1GNBDUCfgUpdAck()", \
11500             gnbDuAck->protocolIEs.list.array[ieIdx]->id);
11501             break;
11502       }
11503    }
11504    duProcGnbDuCfgUpdAckMsg();
11505 #if 0
11506    if(BuildAndSendF1ResetReq() != ROK)
11507    {
11508       return RFAILED;
11509    }
11510 #endif
11511
11512    freeAperDecodeGnbDuAck(gnbDuAck);
11513    return ROK;
11514 }
11515 /******************************************************************
11516 *
11517 * @brief free DL RRC Message Transfer allocated by aper_decoder
11518 *
11519 * @details
11520 *
11521 *    Function : freeAperDecodef1DlRrcMsg
11522 *
11523 *    Functionality: free DL RRC Message Transfer allocated by aper_decoder
11524 *
11525 * @params[in] DLRRCMessageTransfer_t *f1DlRrcMsg
11526 * @return ROK     - success
11527 *         RFAILED - failure
11528 *
11529 * ****************************************************************/
11530
11531 void freeAperDecodef1DlRrcMsg(DLRRCMessageTransfer_t *f1DlRrcMsg)
11532 {
11533    uint8_t ieIdx =0;
11534    RRCContainer_t *rrcContainer = NULLP;
11535
11536    if(f1DlRrcMsg->protocolIEs.list.array)
11537    {
11538       for(ieIdx=0; ieIdx<f1DlRrcMsg->protocolIEs.list.count; ieIdx++)
11539       {
11540          if(f1DlRrcMsg->protocolIEs.list.array[ieIdx])
11541          {
11542             switch(f1DlRrcMsg->protocolIEs.list.array[ieIdx]->id)
11543             {
11544                case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
11545                   break;
11546                case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
11547                   break;
11548                case ProtocolIE_ID_id_SRBID:
11549                   break;
11550                case ProtocolIE_ID_id_RRCContainer:
11551                   {
11552                      rrcContainer =&f1DlRrcMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer;
11553                      free(rrcContainer->buf);
11554                   }
11555                case ProtocolIE_ID_id_ExecuteDuplication:
11556                   break;
11557                case ProtocolIE_ID_id_RRCDeliveryStatusRequest:
11558                   break;
11559                   break;
11560             }
11561             free(f1DlRrcMsg->protocolIEs.list.array[ieIdx]);
11562          }
11563       }
11564       free(f1DlRrcMsg->protocolIEs.list.array);
11565    }
11566 }
11567 /******************************************************************
11568  *
11569  * @brief Processes DL RRC Message Transfer  sent by CU
11570  *
11571  * @details
11572  *
11573  *    Function : procF1DlRrcMsgTrans
11574  *
11575  *    Functionality: Processes DL RRC Message Transfer sent by CU
11576  *
11577  * @params[in] F1AP_PDU_t ASN decoded F1AP message
11578  * @return ROK     - success
11579  *         RFAILED - failure
11580  *
11581  * ****************************************************************/
11582 uint8_t procF1DlRrcMsgTrans(F1AP_PDU_t *f1apMsg)
11583 {
11584    uint8_t  idx, ret;
11585    DLRRCMessageTransfer_t *f1DlRrcMsg = NULLP;
11586    F1DlRrcMsg dlMsg;
11587    memset(&dlMsg, 0, sizeof(F1DlRrcMsg));
11588
11589    DU_LOG("\nINFO   -->  DU_APP : DL RRC message transfer Recevied");
11590    f1DlRrcMsg = &f1apMsg->choice.initiatingMessage->value.choice.DLRRCMessageTransfer;
11591
11592    ret = ROK;
11593
11594    for(idx=0; idx<f1DlRrcMsg->protocolIEs.list.count; idx++)
11595    {
11596       switch(f1DlRrcMsg->protocolIEs.list.array[idx]->id)
11597       {
11598          case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
11599             {
11600                dlMsg.gnbCuUeF1apId = f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.GNB_CU_UE_F1AP_ID;
11601                break;
11602             }
11603          case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
11604             {
11605                dlMsg.gnbDuUeF1apId = f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID;
11606                break;
11607             }
11608          case ProtocolIE_ID_id_SRBID:
11609             {
11610                dlMsg.srbId = f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.SRBID;
11611                break;
11612             }
11613          case ProtocolIE_ID_id_ExecuteDuplication:
11614             dlMsg.execDup = true;
11615             break;
11616
11617          case ProtocolIE_ID_id_RRCContainer:
11618             {
11619                if(f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.size > 0)
11620                {
11621                   dlMsg.rrcMsgSize = f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.size;
11622                   DU_ALLOC(dlMsg.rrcMsgPdu, dlMsg.rrcMsgSize);
11623                   if(dlMsg.rrcMsgPdu)
11624                   {
11625                      memcpy(dlMsg.rrcMsgPdu, f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.buf,\
11626                         dlMsg.rrcMsgSize);
11627                   }
11628                   else
11629                   {
11630                      DU_LOG("\nERROR  -->  DU APP : Memory alloc Failed at RRC Container at procF1DlRrcMsgTrans()");
11631                      return RFAILED;
11632                   }
11633                }
11634                else
11635                {
11636                   DU_LOG("\nERROR  -->  DU_APP : RRC Container Size is invalid:%ld",\
11637                   f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.size);
11638                   return RFAILED;
11639                }
11640                break;
11641             }
11642          case ProtocolIE_ID_id_RRCDeliveryStatusRequest:
11643             {
11644                dlMsg.deliveryStatRpt = true;
11645                break;
11646             }
11647          default:
11648             DU_LOG("\nERROR  -->  DU_APP : Invalid IE received in DL RRC Msg Transfer:%ld",
11649                   f1DlRrcMsg->protocolIEs.list.array[idx]->id);
11650       }
11651    }
11652
11653    ret = duProcDlRrcMsg(&dlMsg);
11654
11655    freeAperDecodef1DlRrcMsg(f1DlRrcMsg);
11656    return ret;
11657 }
11658 /*******************************************************************
11659  *
11660 * @brief Builds the DRB to be Setup Mod list
11661 *
11662 * @details
11663 *
11664 *    Function :
11665 *
11666 *    Functionality: Constructs the DRB to be Setup Mod list
11667 *
11668 * @params[in] DRBs_SetupMod_List_t *drbSet
11669 *
11670 * @return ROK     - success
11671 *         RFAILED - failure
11672 *
11673 * ****************************************************************/
11674
11675 uint8_t BuildDrbSetupModList(DRBs_SetupMod_List_t *drbSet , DuUeCfg *ueCfg)
11676 {
11677    uint8_t arrIdx =0;
11678    uint8_t drbCnt =0;
11679    struct DRBs_SetupMod_ItemIEs *drbItemIe;
11680
11681    drbCnt = 1;
11682    drbSet->list.count = drbCnt;
11683    drbSet->list.size = drbCnt * sizeof(DRBs_SetupMod_ItemIEs_t *);
11684    DU_ALLOC(drbSet->list.array, drbSet->list.size);
11685    if(drbSet->list.array == NULLP)
11686    {
11687       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDrbToBeSetupModList");
11688       return  RFAILED;
11689    }
11690    for(arrIdx=0; arrIdx<drbCnt; arrIdx++)
11691    {
11692       DU_ALLOC(drbSet->list.array[arrIdx], sizeof(DRBs_SetupMod_ItemIEs_t));
11693       if(drbSet->list.array[arrIdx] == NULLP)
11694       {
11695               DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDrbToBeSetupModList");
11696               return  RFAILED;
11697       }
11698
11699       drbItemIe = (struct DRBs_SetupMod_ItemIEs *)drbSet->list.array[arrIdx];
11700       drbItemIe->id = ProtocolIE_ID_id_DRBs_SetupMod_Item;
11701       drbItemIe->criticality = Criticality_reject;
11702       drbItemIe->value.present = DRBs_SetupMod_ItemIEs__value_PR_DRBs_SetupMod_Item;
11703       drbItemIe->value.choice.DRBs_SetupMod_Item.dRBID = ueCfg->upTnlInfo[arrIdx].drbId;
11704       if(fillDlTnlSetupList(&drbItemIe->value.choice.DRBs_SetupMod_Item.dLUPTNLInformation_ToBeSetup_List,\
11705       &ueCfg->upTnlInfo[arrIdx])!= ROK)
11706       {
11707          DU_LOG("\nERROR  -->  F1AP : Failed to fill DlTnl SetupList in BuildDrbToBeSetupModList");
11708          return RFAILED;
11709       }
11710
11711    }
11712
11713    return ROK;
11714 }
11715 /*******************************************************************
11716 * @brief Free the memory allocated for DRB setup List
11717 *
11718 * @details
11719 *
11720 *    Function : FreeDrbSetupModList
11721 *
11722 *    Functionality:
11723 *       Free the memory allocated for DRB setup list
11724 *
11725 * @params[in] DRBs_Setup_List_t *
11726 * @return void
11727 *
11728 * ****************************************************************/
11729 void FreeDrbSetupModList(DRBs_SetupMod_List_t *drbSetupList)
11730 {
11731    uint8_t arrIdx = 0;
11732    DRBs_SetupMod_ItemIEs_t *drbItemIe = NULLP;
11733
11734    for(arrIdx = 0; arrIdx < drbSetupList->list.count; arrIdx++)
11735    {
11736       drbItemIe = ((DRBs_SetupMod_ItemIEs_t *)drbSetupList->list.array[arrIdx]);
11737       freeDlTnlInfo(&drbItemIe->value.choice.DRBs_SetupMod_Item.dLUPTNLInformation_ToBeSetup_List);
11738    }
11739 }
11740 /*******************************************************************
11741 * @brief Free the memory allocated for UE Context Mod Response
11742 *
11743 * @details
11744 *
11745 *    Function : FreeUeContextModResp
11746 *
11747 *    Functionality:
11748 *       Free the memory allocated for UE Context Mod Response
11749 *
11750 * @params[in] F1AP_PDU_t *f1apMsg
11751 * @return void
11752 *
11753 * ****************************************************************/
11754
11755 void FreeUeContextModResp(F1AP_PDU_t *f1apMsg)
11756 {
11757    uint8_t ieIdx;
11758    UEContextModificationResponse_t *ueContextModifyRes = NULLP;
11759    if(f1apMsg)
11760    {
11761       if(f1apMsg->choice.successfulOutcome)
11762       {
11763          ueContextModifyRes =&f1apMsg->choice.successfulOutcome->value.choice.UEContextModificationResponse;
11764          if(ueContextModifyRes->protocolIEs.list.array)
11765          {
11766             for(ieIdx=0 ; ieIdx<ueContextModifyRes->protocolIEs.list.count; ieIdx++)
11767             {
11768                if(ueContextModifyRes->protocolIEs.list.array[ieIdx])
11769                {
11770                   switch(ueContextModifyRes->protocolIEs.list.array[ieIdx]->id)
11771                   {
11772                      case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
11773                         break;
11774                      case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
11775                         break;
11776                      case ProtocolIE_ID_id_DRBs_SetupMod_List:
11777                         {
11778                             FreeDrbSetupModList(&(ueContextModifyRes->protocolIEs.list.array[ieIdx]->\
11779                             value.choice.DRBs_SetupMod_List));
11780                             break;
11781                         }
11782                   }
11783                   DU_FREE(ueContextModifyRes->protocolIEs.list.array[ieIdx], sizeof(UEContextModificationResponse_t));
11784                }
11785
11786             }
11787             DU_FREE(ueContextModifyRes->protocolIEs.list.array, ueContextModifyRes->protocolIEs.list.size);
11788          }
11789          DU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
11790       }
11791       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
11792    }
11793 }
11794
11795 /*****************************************************************i
11796 *
11797 * @brief Creating the ue context modifcation response and sending
11798 *
11799 * @details
11800 *
11801 *    Function : BuildAndSendUeContextModResp
11802 *
11803 *    Functionality:
11804 *         - Creating the ue context modifcation response
11805 *
11806 * @params[in]
11807 * @return ROK     - success
11808 *         RFAILED - failure
11809 *
11810 * ****************************************************************/
11811 uint8_t BuildAndSendUeContextModResp(uint8_t ueIdx, uint8_t cellId)
11812 {
11813    uint8_t   ieIdx = 0;
11814    uint8_t   cellIdx =0;
11815    uint8_t   elementCnt = 0;
11816    uint8_t   ret = RFAILED;
11817    uint32_t  gnbCuUeF1apId;   /* gNB-CU UE F1AP Id */
11818    uint32_t  gnbDuUeF1apId;   /* gNB-DU UE F1AP Id */
11819    F1AP_PDU_t *f1apMsg = NULLP;
11820    asn_enc_rval_t         encRetVal;
11821    UEContextModificationResponse_t *ueContextModifyRes = NULLP;
11822    DuUeCb                   *ueCb = NULLP;
11823
11824    DU_LOG("\nINFO  -->  F1AP : Building Ue context modification response\n");
11825
11826    while(1)
11827    {
11828       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
11829       if(f1apMsg == NULLP)
11830       {
11831          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed Ue context modification");
11832          break;
11833       }
11834
11835       f1apMsg->present =  F1AP_PDU_PR_successfulOutcome;
11836
11837       DU_ALLOC(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
11838       if(f1apMsg->choice.successfulOutcome == NULLP)
11839       {
11840          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed Ue context modification");
11841          break;
11842       }
11843       f1apMsg->choice.successfulOutcome->procedureCode = ProcedureCode_id_UEContextModification;
11844       f1apMsg->choice.successfulOutcome->criticality = Criticality_reject;
11845       f1apMsg->choice.successfulOutcome->value.present = SuccessfulOutcome__value_PR_UEContextModificationResponse;
11846
11847       ueContextModifyRes =&f1apMsg->choice.successfulOutcome->value.choice.UEContextModificationResponse;
11848
11849       elementCnt = 3;
11850       ueContextModifyRes->protocolIEs.list.count = elementCnt;
11851       ueContextModifyRes->protocolIEs.list.size = elementCnt*sizeof(UEContextModificationResponse_t*);
11852
11853       /* Initialize the UE context modification members */
11854       DU_ALLOC(ueContextModifyRes->protocolIEs.list.array, ueContextModifyRes->protocolIEs.list.size);
11855       if(ueContextModifyRes->protocolIEs.list.array == NULLP)
11856       {
11857          DU_LOG("\nERROR  -->  F1AP : Memory allocation for UE context modifcation Request failed");
11858          break;
11859       }
11860
11861       for(ieIdx=0 ; ieIdx<elementCnt; ieIdx++)
11862       {
11863          DU_ALLOC(ueContextModifyRes->protocolIEs.list.array[ieIdx], sizeof(UEContextModificationResponse_t));
11864          if(ueContextModifyRes->protocolIEs.list.array[ieIdx] == NULLP)
11865          {
11866             DU_LOG("\nERROR  -->  F1AP : Memory allocation for UE context modifcation Request failed");
11867             break;
11868          }
11869       }
11870
11871       /* Fetching Ue Cb Info*/
11872       GET_CELL_IDX(cellId, cellIdx);
11873       gnbDuUeF1apId = duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].gnbDuUeF1apId;
11874       gnbCuUeF1apId = duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].gnbCuUeF1apId;
11875       ueCb = &duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1];
11876
11877       ieIdx=0;
11878       ueContextModifyRes->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
11879       ueContextModifyRes->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
11880       ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.present =\
11881       UEContextModificationResponseIEs__value_PR_GNB_CU_UE_F1AP_ID;
11882       ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID = gnbCuUeF1apId;
11883
11884       ieIdx++;
11885       ueContextModifyRes->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
11886       ueContextModifyRes->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
11887       ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.present=\
11888       UEContextModificationResponseIEs__value_PR_GNB_DU_UE_F1AP_ID;
11889       ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID = gnbDuUeF1apId;
11890
11891       ieIdx++;
11892       ueContextModifyRes->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_DRBs_SetupMod_List;
11893       ueContextModifyRes->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
11894       ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.present =\
11895       UEContextModificationResponseIEs__value_PR_DRBs_SetupMod_List;
11896       if(ueCb->f1UeDb)
11897       {
11898          ret = BuildDrbSetupModList(&(ueContextModifyRes->protocolIEs.list.array[ieIdx]->\
11899                   value.choice.DRBs_SetupMod_List) , &ueCb->f1UeDb->duUeCfg);
11900          if(ret != ROK)
11901          {
11902             DU_LOG( "\nERROR  -->  F1AP : Failed to build drb setupmod List ");
11903             break;
11904          }
11905          freeF1UeDb(ueCb->f1UeDb);
11906          ueCb->f1UeDb = NULLP;
11907       }
11908       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
11909
11910       /* Encode the F1SetupRequest type as APER */
11911       memset(encBuf, 0, ENC_BUF_MAX_LEN);
11912       encBufSize = 0;
11913       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,encBuf);
11914
11915       /* Encode results */
11916       if(encRetVal.encoded == ENCODE_FAIL)
11917       {
11918          DU_LOG( "\nERROR  -->  F1AP : Could not encode UE Context Setup Request structure (at %s)\n",\
11919                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
11920          ret = RFAILED;
11921          break;
11922       }
11923       else
11924       {
11925          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for UE Context Modification Response\n");
11926          for(int i=0; i< encBufSize; i++)
11927          {
11928             printf("%x",encBuf[i]);
11929          }
11930       }
11931
11932       /* Sending  msg  */
11933       if(SendF1APMsg(DU_APP_MEM_REGION,DU_POOL) != ROK)
11934       {
11935          DU_LOG("\nERROR  -->  F1AP : Sending UE Context Setup Res Failed");
11936          ret = RFAILED;
11937          break;
11938       }
11939       break;
11940    }
11941    FreeUeContextModResp(f1apMsg);
11942    return ret;
11943
11944 }
11945 /*******************************************************************
11946  *
11947  * @brief Deallocating the memory allocated by the aper decoder
11948  *          for QOSInfo
11949  *
11950  * @details
11951  *
11952  *    Function : freeAperDecodeQosInfo
11953  *
11954  *    Functionality:  Deallocating the memory allocated for QOSInfo
11955  *
11956  * @params[in] QoSFlowLevelQoSParameters_t *drbQos
11957  *
11958  * @return void
11959  *
11960  * ****************************************************************/
11961
11962 void freeAperDecodeQosInfo(QoSFlowLevelQoSParameters_t *drbQos)
11963 {
11964    if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI != NULLP)
11965    {
11966       if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow!=NULLP)
11967       {
11968          if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume!=NULLP)
11969          {
11970             free(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume);
11971          }
11972          free(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow);
11973       }
11974       free(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI);
11975    }
11976 }
11977 /*******************************************************************
11978  *
11979  * @brief Deallocating the memory allocated by the aper decoder
11980  *          for UlTnlInfoforDrb
11981  *
11982  * @details
11983  *
11984  *    Function : freeAperDecodeUlTnlInfoforDrbSetupMod
11985  *
11986  *    Functionality:  Deallocating memory allocated for UlTnlInfoforDrb
11987  *
11988  * @params[in] ULUPTNLInformation_ToBeSetup_List_t *ulInfo
11989  *
11990  * @return void
11991  *
11992  * ****************************************************************/
11993 void freeAperDecodeUlTnlInfoforDrbSetupMod(ULUPTNLInformation_ToBeSetup_List_t *ulInfo)
11994 {
11995    uint8_t arrIdx =0;
11996
11997    if(ulInfo->list.array)
11998    {
11999       for(arrIdx=0; arrIdx<ulInfo->list.count ; arrIdx++)
12000       {
12001          if(ulInfo->list.array[arrIdx])
12002          {
12003             if(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel )
12004             {
12005                if(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf)
12006                {
12007                   if(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf)
12008                   {
12009                      free(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
12010                            gTP_TEID.buf);
12011                   }
12012                   free(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
12013                         transportLayerAddress.buf);
12014                }
12015                free(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel);
12016             }
12017             free(ulInfo->list.array[arrIdx]);
12018          }
12019       }
12020       free(ulInfo->list.array);
12021    }
12022 }
12023 /*******************************************************************
12024  *
12025  * @brief Deallocating the memory allocated by the aper decoder
12026  *          for DrbSetupModItem
12027  *
12028  * @details
12029  *
12030  *    Function : freeAperDecodeDrbSetupModItem
12031  *
12032  *    Functionality:  Deallocating memory allocated for DrbSetupModItem
12033  *
12034  * @params[in] DRBs_ToBeSetupMod_Item_t *drbItem
12035  *
12036  * @return void
12037  *
12038  * ****************************************************************/
12039
12040 void freeAperDecodeDrbSetupModItem(DRBs_ToBeSetupMod_Item_t *drbItem)
12041 {
12042    uint8_t arrIdx =0;
12043    SNSSAI_t *snssai =NULLP;
12044    Flows_Mapped_To_DRB_List_t *flowMap = NULLP;
12045
12046    drbItem->qoSInformation.present = QoSInformation_PR_choice_extension;
12047    switch(drbItem->qoSInformation.present)
12048    {
12049       case QoSInformation_PR_NOTHING:
12050          break;
12051       case QoSInformation_PR_eUTRANQoS:
12052          {
12053             if(drbItem->qoSInformation.choice.eUTRANQoS)
12054             {
12055                free(drbItem->qoSInformation.choice.eUTRANQoS);
12056             }
12057             break;
12058          }
12059       case QoSInformation_PR_choice_extension:
12060          {
12061             if(drbItem->qoSInformation.choice.choice_extension)
12062             {
12063                freeAperDecodeQosInfo(&drbItem->qoSInformation.choice.choice_extension->value.choice.\
12064                      DRB_Information.dRB_QoS);
12065                snssai = &drbItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI;
12066                if(snssai->sST.buf)
12067                {
12068                   free(snssai->sST.buf);
12069                }
12070                if(snssai->sD)
12071                {
12072                   if(snssai->sD->buf)
12073                   {
12074                      free(snssai->sD->buf);
12075                   }
12076                   free(snssai->sD);
12077                }
12078
12079                flowMap = &drbItem->qoSInformation.choice.choice_extension->value.choice.\
12080                          DRB_Information.flows_Mapped_To_DRB_List;
12081                if(flowMap->list.array)
12082                {
12083                   for(arrIdx=0; arrIdx<flowMap->list.count; arrIdx++)
12084                   {
12085                      if(flowMap->list.array[arrIdx] )
12086                      {
12087                         freeAperDecodeQosInfo(&flowMap->list.array[arrIdx]->qoSFlowLevelQoSParameters);
12088                         free(flowMap->list.array[arrIdx]);
12089                      }
12090                   }
12091                   free(flowMap->list.array);
12092                }
12093
12094                free(drbItem->qoSInformation.choice.choice_extension);
12095             }
12096             break;
12097          }
12098
12099    }
12100    freeAperDecodeUlTnlInfoforDrbSetupMod(&drbItem->uLUPTNLInformation_ToBeSetup_List);
12101    if(drbItem->uLConfiguration)
12102    {
12103       free(drbItem->uLConfiguration);
12104    }
12105 }
12106
12107 /*******************************************************************
12108  *
12109  * @brief Deallocating the memory allocated by the aper decoder
12110  *          for DrbToBeSetupModList
12111  *
12112  * @details
12113  *
12114  *    Function : freeAperDecodeDrbToBeSetupModList
12115  *
12116  *    Functionality:  Deallocating memory allocated for DrbToBeSetupModList
12117  *
12118  * @params[in] DRBs_ToBeSetupMod_List_t *drbSet
12119  *
12120  * @return void
12121  *
12122  * ****************************************************************/
12123
12124 void freeAperDecodeDrbToBeSetupModList(DRBs_ToBeSetupMod_List_t *drbSet)
12125 {
12126    uint8_t arrIdx =0;
12127    struct DRBs_ToBeSetupMod_ItemIEs *drbItemIe;
12128
12129    if(drbSet->list.array)
12130    {
12131       for(arrIdx=0; arrIdx<drbSet->list.count ; arrIdx++)
12132       {
12133          if(drbSet->list.array[arrIdx] != NULLP)
12134          {
12135             if(arrIdx == 0)
12136             {
12137                drbItemIe = (DRBs_ToBeSetupMod_ItemIEs_t *)drbSet->list.array[arrIdx];
12138                freeAperDecodeDrbSetupModItem(&(drbItemIe->value.choice.DRBs_ToBeSetupMod_Item));
12139             }
12140             free(drbSet->list.array[arrIdx]);
12141          }
12142       }
12143       free(drbSet->list.array);
12144    }
12145
12146 }
12147 /*******************************************************************
12148  *
12149  * @brief Deallocating the memory allocated by the aper decoder
12150  *          for UeContextModificationReqMsg
12151  *
12152  * @details
12153  *
12154  *    Function : freeAperDecodeUeContextModificationReqMsg
12155  *
12156  *    Functionality:  Deallocating memory allocated for
12157  *                  UeContextModificationReqMsg
12158  *
12159  * @params[in] UEContextModificationRequest_t *UeContextModifyReq
12160  *
12161  * @return void
12162  *
12163  * ****************************************************************/
12164 void freeAperDecodeUeContextModificationReqMsg(UEContextModificationRequest_t *UeContextModifyReq )
12165 {
12166    uint8_t arrIdx, ieId;
12167
12168    if(UeContextModifyReq->protocolIEs.list.array)
12169    {
12170       for( arrIdx = 0 ; arrIdx<UeContextModifyReq->protocolIEs.list.count ; arrIdx++)
12171       {
12172          if(UeContextModifyReq->protocolIEs.list.array[arrIdx])
12173          {
12174             ieId = UeContextModifyReq->protocolIEs.list.array[arrIdx]->id;
12175             switch(ieId)
12176             {
12177                case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
12178                   break;
12179                case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
12180                   break;
12181                case ProtocolIE_ID_id_DRBs_ToBeSetupMod_List:
12182                   {
12183                      freeAperDecodeDrbToBeSetupModList(&UeContextModifyReq->protocolIEs.list.array[arrIdx]->\
12184                            value.choice.DRBs_ToBeSetupMod_List);
12185                      break;
12186                   }
12187             }
12188             free(UeContextModifyReq->protocolIEs.list.array[arrIdx]);
12189          }
12190       }
12191       free(UeContextModifyReq->protocolIEs.list.array);
12192    }
12193 }
12194 /*******************************************************************
12195  *
12196  * @brief processing the F1 UeContextModificationReq
12197  *
12198  * @details
12199  *
12200  *    Function : procF1UeContextModificationReq
12201  *
12202  *    Functionality:  processing the F1 UeContextModificationReq
12203  *
12204  * @params[in] F1AP_PDU_t *f1apMsg
12205  *
12206  * @return
12207  * ****************************************************************/
12208 uint8_t procF1UeContextModificationReq(F1AP_PDU_t *f1apMsg)
12209 {
12210    UEContextModificationRequest_t *ueContextModifyReq = NULLP;
12211    uint8_t  ret = ROK, ieIdx = 0, lcId =0,cellIdx=0, ueIdx=0;
12212    DuUeCb   *duUeCb = NULLP;
12213    DRBs_ToBeSetupMod_List_t *drbSetupModCfg;
12214    uint32_t gnbCuUeF1apId, gnbDuUeF1apId;
12215
12216    ueContextModifyReq = &f1apMsg->choice.initiatingMessage->value.choice.UEContextModificationRequest;
12217    for(ieIdx=0; (ieIdx < ueContextModifyReq->protocolIEs.list.count && ret == ROK); ieIdx++)
12218    {
12219       switch(ueContextModifyReq->protocolIEs.list.array[ieIdx]->id)
12220       {
12221          case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
12222             {
12223                gnbCuUeF1apId = ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID;
12224                break;
12225             }
12226          case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
12227             {
12228                gnbDuUeF1apId = ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID;
12229                break;
12230             }
12231          case ProtocolIE_ID_id_DRBs_ToBeSetupMod_List:
12232             {
12233                for(cellIdx = 0; cellIdx < duCb.numActvCells; cellIdx++)
12234                {
12235                   for(ueIdx = 0; ueIdx < duCb.numUe; ueIdx++)
12236                   {
12237                      if((duCb.actvCellLst[cellIdx]->ueCb[ueIdx].gnbDuUeF1apId == gnbDuUeF1apId)&&\
12238                            (duCb.actvCellLst[cellIdx]->ueCb[ueIdx].gnbCuUeF1apId == gnbCuUeF1apId))
12239                      {
12240
12241                         duUeCb = &duCb.actvCellLst[cellIdx]->ueCb[ueIdx];
12242                         lcId = getDrbLcId(&duUeCb->drbBitMap);
12243                         if(lcId != RFAILED)
12244                         {
12245                            DU_ALLOC(duUeCb->f1UeDb, sizeof(F1UeContextSetupDb));
12246                            if(duUeCb->f1UeDb)
12247                            {
12248                               duUeCb->f1UeDb->actionType = UE_CTXT_MOD;
12249                               drbSetupModCfg = &ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.\
12250                               choice.DRBs_ToBeSetupMod_List;
12251                               if(extractDrbListToSetup(lcId, NULL, drbSetupModCfg ,drbSetupModCfg->list.count, \
12252                               &duUeCb->f1UeDb->duUeCfg))
12253                               {
12254                                  DU_LOG("\nERROR  -->  DU APP : Failed at extractDrbListToSetup()");
12255                                  ret = RFAILED;
12256                               }
12257                            }
12258                         }
12259                      }
12260                      else
12261                      {
12262                         DU_LOG("\nERROR  -->  DU APP : wrong values of gnbCuUeF1apId and gnbDuUeF1apId ");
12263                         ret = RFAILED;
12264                      }
12265                   }
12266                }
12267                break;
12268             }
12269       }
12270    }
12271    if(ret != RFAILED)
12272    {
12273       ret = duProcUeContextModReq(duUeCb);
12274    }
12275    freeAperDecodeUeContextModificationReqMsg(ueContextModifyReq);
12276    return ret;
12277 }
12278 /*****************************************************************i
12279  *
12280  * @brief Handles received F1AP message and sends back response
12281  *
12282  * @details
12283  *
12284  *    Function : F1APMsgHdlr
12285  *
12286  *    Functionality:
12287  *         - Decodes received F1AP control message
12288  *         - Prepares response message, encodes and sends to SCTP
12289  *
12290  * @params[in]
12291  * @return ROK     - success
12292  *         RFAILED - failure
12293  *
12294  * ****************************************************************/
12295 void F1APMsgHdlr(Buffer *mBuf)
12296 {
12297    int i =0;
12298    char *recvBuf =NULLP;
12299    MsgLen copyCnt =0;
12300    MsgLen recvBufLen =0;
12301    F1AP_PDU_t *f1apMsg =NULLP;
12302    asn_dec_rval_t rval; /* Decoder return value */
12303    F1AP_PDU_t f1apasnmsg ;
12304    DU_LOG("\nINFO  -->  F1AP : Received F1AP message buffer");
12305    ODU_PRINT_MSG(mBuf, 0,0);
12306
12307    /* Copy mBuf into char array to decode it */
12308    ODU_GET_MSG_LEN(mBuf, &recvBufLen);
12309    DU_ALLOC(recvBuf, (Size)recvBufLen);
12310
12311    if(recvBuf == NULLP)
12312    {
12313       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed");
12314       return;
12315    }
12316    if(ODU_COPY_MSG_TO_FIX_BUF(mBuf, 0, recvBufLen, (Data *)recvBuf, &copyCnt) != ROK)
12317    {
12318       DU_LOG("\nERROR   -->  F1AP : Failed while copying %d", copyCnt);
12319       return;
12320    }
12321
12322    printf("\nDEBUG   -->  F1AP : Received flat buffer to be decoded : ");
12323    for(i=0; i< recvBufLen; i++)
12324    {
12325       printf("%x",recvBuf[i]);
12326    }
12327
12328    /* Decoding flat buffer into F1AP messsage */
12329    f1apMsg = &f1apasnmsg;
12330    memset(f1apMsg, 0, sizeof(F1AP_PDU_t));
12331
12332    rval = aper_decode(0, &asn_DEF_F1AP_PDU, (void **)&f1apMsg, recvBuf, recvBufLen, 0, 0);
12333    DU_FREE(recvBuf, (Size)recvBufLen);
12334
12335    if(rval.code == RC_FAIL || rval.code == RC_WMORE)
12336    {
12337       DU_LOG("\nERROR  -->  F1AP : ASN decode failed");
12338       return;
12339    }
12340    printf("\n");
12341    xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
12342
12343    switch(f1apMsg->present)
12344    {
12345       case F1AP_PDU_PR_successfulOutcome:
12346          {
12347             switch(f1apMsg->choice.successfulOutcome->value.present)
12348             {
12349                case SuccessfulOutcome__value_PR_ResetAcknowledge:
12350                   {
12351                      DU_LOG("\nINFO   -->  F1AP : F1ResetAcknowledge is received successfully ");
12352                      break;
12353                   }
12354                case SuccessfulOutcome__value_PR_F1SetupResponse:
12355                   {
12356 #ifndef ODU_TEST_STUB
12357                      procF1SetupRsp(f1apMsg);
12358 #endif
12359                      break;
12360                   }
12361
12362                case SuccessfulOutcome__value_PR_GNBDUConfigurationUpdateAcknowledge:
12363                   {
12364                      procF1GNBDUCfgUpdAck(f1apMsg);
12365                      break;
12366                   }
12367
12368                default:
12369                   {
12370                      DU_LOG("\nERROR  -->  F1AP : Invalid type of SuccessfulOutcome__value_PR_ResetAcknowledge [%d]",\
12371                            f1apMsg->choice.successfulOutcome->value.present);
12372                      return;
12373                   }
12374             }/* End of switch(successfulOutcome) */
12375             free(f1apMsg->choice.successfulOutcome);
12376             break;
12377          }
12378       case F1AP_PDU_PR_initiatingMessage:
12379          {
12380             switch(f1apMsg->choice.initiatingMessage->value.present)
12381             {
12382                case InitiatingMessage__value_PR_Reset:
12383                   {
12384                      procF1ResetReq(f1apMsg);
12385                      break;
12386                   }
12387                case InitiatingMessage__value_PR_DLRRCMessageTransfer:
12388                   {
12389                      procF1DlRrcMsgTrans(f1apMsg);
12390                      break;
12391                   }
12392                case InitiatingMessage__value_PR_UEContextSetupRequest:
12393                   {
12394                      procF1UeContextSetupReq(f1apMsg);
12395                      break;
12396                   }
12397                case InitiatingMessage__value_PR_UEContextModificationRequest:
12398                   {
12399                      procF1UeContextModificationReq(f1apMsg);
12400                      break;
12401                   }
12402                default:
12403                   {
12404                      DU_LOG("\nERROR  -->  F1AP : Invalid type of F1AP_PDU_PR_initiatingMessage [%d]",
12405                            f1apMsg->choice.initiatingMessage->value.present);
12406                      return;
12407                   }
12408             }/* End of switch(initiatingMessage) */
12409             free(f1apMsg->choice.initiatingMessage);
12410             break;
12411          }
12412
12413       default:
12414          {
12415             DU_LOG("\nERROR  -->  F1AP : Invalid type of f1apMsg->present [%d]",f1apMsg->present);
12416             return;
12417          }
12418          free(f1apMsg);
12419
12420    }/* End of switch(f1apMsg->present) */
12421
12422 } /* End of F1APMsgHdlr */
12423
12424 /**********************************************************************
12425   End of file
12426  **********************************************************************/