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 int16_t getPollPdu(uint8_t pollPduCfg)
 178 {
 179    int16_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 =\
1095                                                              strlen(( char *)duCfgParam.srvdCellLst[0].duSysInfo.mibMsg);
1096    DU_ALLOC(srvCellItem->gNB_DU_System_Information->mIB_message.buf,
1097          srvCellItem->gNB_DU_System_Information->mIB_message.size);
1098    if(!srvCellItem->gNB_DU_System_Information->mIB_message.buf)
1099    {
1100       return RFAILED;
1101    }
1102    strcpy((char *)srvCellItem->gNB_DU_System_Information->mIB_message.buf,
1103          (char *)duCfgParam.srvdCellLst[0].duSysInfo.mibMsg);
1104
1105    /* SIB1 */
1106    srvCellItem->gNB_DU_System_Information->sIB1_message.size =\
1107                                                               duCfgParam.srvdCellLst[0].duSysInfo.sib1Len;
1108
1109    DU_ALLOC(srvCellItem->gNB_DU_System_Information->sIB1_message.buf,
1110          srvCellItem->gNB_DU_System_Information->sIB1_message.size);
1111    if(!srvCellItem->gNB_DU_System_Information->sIB1_message.buf)
1112    {
1113       return RFAILED;
1114    }
1115    for(int x=0; x<srvCellItem->gNB_DU_System_Information->sIB1_message.size; x++)
1116    {
1117       srvCellItem->gNB_DU_System_Information->sIB1_message.buf[x]=\
1118                                                                   duCfgParam.srvdCellLst[0].duSysInfo.sib1Msg[x];
1119    }
1120    return ROK;
1121 }
1122 /*******************************************************************
1123  *
1124  * @brief Builds RRC Version
1125  *
1126  * @details
1127  *
1128  *    Function : BuildRrcVer
1129  *
1130  *    Functionality: Building RRC Version
1131  *
1132  * @params[in] int idx,int elementCnt,RRC_Version_t *rrcver
1133  * @return ROK     - success
1134  *         RFAILED - failure
1135  *
1136  * ****************************************************************/
1137 uint8_t BuildRrcVer(RRC_Version_t *rrcVer)
1138 {
1139    uint8_t rrcExt;
1140    uint8_t rrcLatest;
1141    rrcVer->latest_RRC_Version.size = sizeof(uint8_t);
1142    DU_ALLOC(rrcVer->latest_RRC_Version.buf,sizeof(uint8_t));
1143    if(rrcVer->latest_RRC_Version.buf == NULLP)
1144    {
1145       return RFAILED;
1146    }
1147    rrcVer->latest_RRC_Version.buf[0] = 0;
1148    rrcVer->latest_RRC_Version.bits_unused = 5;
1149    DU_ALLOC(rrcVer->iE_Extensions,sizeof(ProtocolExtensionContainer_4624P81_t));
1150    if(rrcVer->iE_Extensions == NULLP)
1151    {
1152       return RFAILED;
1153    }
1154    rrcVer->iE_Extensions->list.count = 1;
1155    rrcVer->iE_Extensions->list.size = sizeof(RRC_Version_ExtIEs_t *);
1156    DU_ALLOC(rrcVer->iE_Extensions->list.array,rrcVer->iE_Extensions->list.size);
1157    if(rrcVer->iE_Extensions->list.array == NULLP)
1158    {
1159       return RFAILED;
1160    }
1161    rrcExt = 0;
1162    DU_ALLOC(rrcVer->iE_Extensions->list.array[0],\
1163          sizeof(RRC_Version_ExtIEs_t));
1164    if(rrcVer->iE_Extensions->list.array[0] == NULLP)
1165    {
1166       return RFAILED;
1167    }
1168    rrcVer->iE_Extensions->list.array[rrcExt]->id = \
1169                                                    ProtocolIE_ID_id_latest_RRC_Version_Enhanced;
1170    rrcVer->iE_Extensions->list.array[rrcExt]->criticality = Criticality_reject;
1171    rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.present =\
1172                                                                       RRC_Version_ExtIEs__extensionValue_PR_Latest_RRC_Version_Enhanced;
1173    rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.choice\
1174       .Latest_RRC_Version_Enhanced.size = 3*sizeof(uint8_t);
1175    DU_ALLOC(rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.choice\
1176          .Latest_RRC_Version_Enhanced.buf,rrcVer->iE_Extensions->list.\
1177          array[rrcExt]->extensionValue.choice.Latest_RRC_Version_Enhanced.size);
1178    if(rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.choice\
1179          .Latest_RRC_Version_Enhanced.buf == NULLP)
1180    {
1181       return RFAILED;
1182    }
1183    rrcLatest = 0;
1184    rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.choice.\
1185       Latest_RRC_Version_Enhanced.buf[rrcLatest] = 15;
1186    rrcLatest++;
1187    rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.choice.\
1188       Latest_RRC_Version_Enhanced.buf[rrcLatest] = 5;
1189    rrcLatest++;
1190    rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.choice.\
1191       Latest_RRC_Version_Enhanced.buf[rrcLatest] = 0;
1192    return ROK;
1193 }
1194 /*******************************************************************
1195  *
1196  * @brief Sends F1 msg over SCTP
1197  *
1198  * @details
1199  *
1200  *    Function : SendF1APMsg
1201  *
1202  *    Functionality: Sends F1 msg over SCTP
1203  *
1204  * @params[in] Region region
1205  *             Pool pool
1206  * @return ROK     - success
1207  *         RFAILED - failure
1208  *
1209  * ****************************************************************/
1210 uint8_t SendF1APMsg(Region region, Pool pool)
1211 {
1212    Buffer *mBuf = NULLP;
1213
1214    if(ODU_GET_MSG_BUF(region, pool, &mBuf) == ROK)
1215    {
1216       if(ODU_ADD_POST_MSG_MULT((Data *)encBuf, encBufSize, mBuf) == ROK)
1217       {
1218             ODU_PRINT_MSG(mBuf, 0,0);
1219
1220             if(sctpSend(mBuf, F1_INTERFACE) != ROK)
1221             {
1222                DU_LOG("\nERROR  -->  F1AP : SCTP Send failed");
1223                ODU_PUT_MSG_BUF(mBuf);
1224                return RFAILED;
1225             }
1226       }
1227       else
1228       {
1229          DU_LOG("\nERROR  -->  F1AP : ODU_ADD_POST_MSG_MULT failed");
1230          ODU_PUT_MSG_BUF(mBuf);
1231          return RFAILED;
1232       }
1233       ODU_PUT_MSG_BUF(mBuf);
1234    }
1235    else
1236    {
1237       DU_LOG("\nERROR  -->  F1AP : Failed to allocate memory");
1238       return RFAILED;
1239    }
1240    return ROK;
1241 } /* SendF1APMsg */
1242
1243 /*******************************************************************
1244  *
1245  * @brief  deallocating the memory of function BuildAndSendF1SetupReq()
1246  *
1247  * @details
1248  *
1249  *    Function :  FreeRrcVer
1250  *
1251  *    Functionality: deallocating the memory of function BuildRrcVer
1252  *
1253  * @params[in] RRC_Version_t *rrcVer
1254  *
1255  * @return void
1256  *
1257  *****************************************************************/
1258 void FreeRrcVer(RRC_Version_t *rrcVer)
1259 {
1260    if(rrcVer->latest_RRC_Version.buf != NULLP)
1261    {
1262       if(rrcVer->iE_Extensions != NULLP)
1263       {
1264          if(rrcVer->iE_Extensions->list.array != NULLP)
1265          {
1266             if(rrcVer->iE_Extensions->list.array[0] != NULLP)
1267             {
1268                if(rrcVer->iE_Extensions->list.array[0]->extensionValue.choice.Latest_RRC_Version_Enhanced.buf
1269                      != NULLP)
1270                {
1271                   DU_FREE(rrcVer->iE_Extensions->list.array[0]->extensionValue.choice\
1272                         .Latest_RRC_Version_Enhanced.buf,rrcVer->iE_Extensions->list.\
1273                         array[0]->extensionValue.choice.Latest_RRC_Version_Enhanced.size);
1274                }
1275                DU_FREE(rrcVer->iE_Extensions->list.array[0],sizeof(RRC_Version_ExtIEs_t));
1276             }
1277             DU_FREE(rrcVer->iE_Extensions->list.array,sizeof(RRC_Version_ExtIEs_t*));
1278          }
1279          DU_FREE(rrcVer->iE_Extensions,sizeof(ProtocolExtensionContainer_4624P81_t));
1280       }
1281       DU_FREE(rrcVer->latest_RRC_Version.buf,rrcVer->latest_RRC_Version.size);
1282    }
1283 }
1284 /*******************************************************************
1285  *
1286  * @brief  deallocating the memory of function BuildAndSendF1SetupReq()
1287  *
1288  * @details
1289  *
1290  *    Function :  FreeServedCellList
1291  *
1292  *    Functionality:  deallocating the memory of function BuildServedCellList
1293
1294  *
1295  * @params[in] GNB_DU_Served_Cells_List_t *duServedCell
1296  *
1297  * @return void
1298  *
1299  * ****************************************************************/
1300 void FreeServedCellList( GNB_DU_Served_Cells_List_t *duServedCell)
1301 {
1302    uint8_t   plmnCnt=1;
1303    uint8_t  servId=0;
1304    uint8_t sliceId=0;
1305    uint8_t  ieId=0;
1306    uint8_t   extensionCnt=1;
1307    uint8_t plmnidx=0;
1308    GNB_DU_Served_Cells_Item_t *srvCellItem= &duServedCell->list.array[0]->value.choice.GNB_DU_Served_Cells_Item;
1309    if(duServedCell->list.array!=NULLP)
1310    {
1311       if(duServedCell->list.array[0]!=NULLP)
1312       {
1313          if(srvCellItem->served_Cell_Information.nRCGI.pLMN_Identity.buf!=NULLP)
1314          {
1315             if(srvCellItem->served_Cell_Information.nRCGI.nRCellIdentity.buf !=NULLP)
1316             {
1317                if(srvCellItem->served_Cell_Information.fiveGS_TAC!=NULLP)
1318                {
1319                   if(srvCellItem->served_Cell_Information.fiveGS_TAC->buf!=NULLP)
1320                   {
1321                      if(srvCellItem->served_Cell_Information.servedPLMNs.list.array!=NULLP)
1322                      {
1323                         if(srvCellItem->served_Cell_Information.servedPLMNs.list.array[0]!=NULLP)
1324                         {
1325                            if(srvCellItem->served_Cell_Information.servedPLMNs.list.array[servId]->pLMN_Identity.buf!=NULLP)
1326                            {
1327                               if(srvCellItem->served_Cell_Information.servedPLMNs.list.array[servId]->iE_Extensions!=NULLP)
1328                               {
1329                                  if(srvCellItem->served_Cell_Information.servedPLMNs.list.array[servId]->iE_Extensions->list.array!=NULLP)
1330                                  {
1331                                     if(srvCellItem->served_Cell_Information.servedPLMNs.list.array[servId]->iE_Extensions->list.array[0]!=NULLP)
1332                                     {
1333                                        if(srvCellItem->served_Cell_Information.servedPLMNs.list.array[servId]->iE_Extensions->list.array[0]->\
1334                                              extensionValue.choice.SliceSupportList.list.array!=NULLP)
1335                                        {
1336                                           if(srvCellItem->served_Cell_Information.servedPLMNs.list.array[servId]->iE_Extensions->list.array[0]->\
1337                                                 extensionValue.choice.SliceSupportList.list.array[sliceId]!= NULLP)
1338                                           {
1339                                              if(srvCellItem->served_Cell_Information.servedPLMNs.list.array[servId]->iE_Extensions->list.array[0]->\
1340                                                    extensionValue.choice.SliceSupportList.list.array[sliceId]->sNSSAI.sST.buf!=NULLP)
1341                                              {
1342                                                 if(srvCellItem->served_Cell_Information.servedPLMNs.list.array[servId]->iE_Extensions->list.array[0]->\
1343                                                       extensionValue.choice.SliceSupportList.list.array[sliceId]->sNSSAI.sD!=NULLP)
1344                                                 {
1345                                                    if(srvCellItem->served_Cell_Information.servedPLMNs.list.array[servId]->iE_Extensions->\
1346                                                          list.array[0]->extensionValue.choice.SliceSupportList.list.array[sliceId]->sNSSAI.sD->buf!=NULLP)
1347                                                    {
1348                                                       if(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD!=NULLP)
1349                                                       {
1350                                                          if(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD->uL_NRFreqInfo.\
1351                                                                freqBandListNr.list.array!=NULLP)
1352                                                          {
1353                                                             if(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD->uL_NRFreqInfo.\
1354                                                                   freqBandListNr.list.array[0]!=NULLP)
1355                                                             {
1356                                                                if(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD->dL_NRFreqInfo.\
1357                                                                      freqBandListNr.list.array)
1358                                                                {
1359                                                                   if(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD->dL_NRFreqInfo.\
1360                                                                         freqBandListNr.list.array[0]!=NULLP)
1361                                                                   {
1362                                                                      if(srvCellItem->served_Cell_Information.measurementTimingConfiguration.buf!=NULLP)
1363                                                                      {
1364                                                                         if(!srvCellItem->gNB_DU_System_Information)
1365                                                                         {
1366                                                                            if(srvCellItem->gNB_DU_System_Information->mIB_message.buf!=NULLP)
1367                                                                            {
1368                                                                               if(srvCellItem->gNB_DU_System_Information->sIB1_message.buf!=NULLP)
1369                                                                               {
1370                                                                                  DU_FREE(srvCellItem->gNB_DU_System_Information->sIB1_message.buf,\
1371                                                                                        srvCellItem->gNB_DU_System_Information->sIB1_message.size);
1372                                                                                  DU_FREE(duCfgParam.srvdCellLst[0].duSysInfo.sib1Msg,\
1373                                                                                        srvCellItem->gNB_DU_System_Information->sIB1_message.size);
1374                                                                               }
1375                                                                               DU_FREE(srvCellItem->gNB_DU_System_Information->mIB_message.buf,\
1376                                                                                     srvCellItem->gNB_DU_System_Information->mIB_message.size);
1377                                                                               DU_FREE(duCfgParam.srvdCellLst[0].duSysInfo.mibMsg,\
1378                                                                                     strlen((char*)duCfgParam.srvdCellLst[0].duSysInfo.mibMsg));
1379                                                                            }
1380                                                                            DU_FREE(srvCellItem->gNB_DU_System_Information,sizeof(GNB_DU_System_Information_t));
1381                                                                         }
1382                                                                         DU_FREE(srvCellItem->served_Cell_Information.measurementTimingConfiguration.buf,\
1383                                                                               srvCellItem->served_Cell_Information.measurementTimingConfiguration.size);
1384                                                                      }
1385                                                                      DU_FREE(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD->dL_NRFreqInfo.\
1386                                                                            freqBandListNr.list.array[0],sizeof(FreqBandNrItem_t));
1387                                                                   }
1388                                                                   DU_FREE(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD->dL_NRFreqInfo.\
1389                                                                         freqBandListNr.list.array,sizeof(FreqBandNrItem_t *));
1390                                                                }
1391                                                                DU_FREE(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD->uL_NRFreqInfo.freqBandListNr.\
1392                                                                      list.array[0],sizeof(FreqBandNrItem_t));
1393                                                             }
1394                                                             DU_FREE(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD->uL_NRFreqInfo.freqBandListNr.\
1395                                                                   list.array,sizeof(FreqBandNrItem_t*));
1396                                                          }
1397                                                          DU_FREE(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD,sizeof(FDD_Info_t));
1398                                                       }
1399                                                       DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.array[servId]->\
1400                                                             iE_Extensions->list.array[ieId]->extensionValue.choice.SliceSupportList.list.array[sliceId]->\
1401                                                             sNSSAI.sD->buf,srvCellItem->served_Cell_Information.servedPLMNs.list.array[servId]->iE_Extensions->
1402                                                             list.array[ieId]->extensionValue.choice.SliceSupportList.list.array[sliceId]->sNSSAI.sD->size);
1403                                                    }
1404                                                    DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.array[servId]->\
1405                                                          iE_Extensions->list.array[ieId]->extensionValue.choice.SliceSupportList.\
1406                                                          list.array[sliceId]->sNSSAI.sD,sizeof(OCTET_STRING_t));
1407                                                 }
1408                                                 DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.array[servId]->\
1409                                                       iE_Extensions->list.array[ieId]->extensionValue.choice.SliceSupportList.list.array[sliceId]->\
1410                                                       sNSSAI.sST.buf,sizeof(uint8_t));
1411                                              }
1412                                              DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.array[servId]->iE_Extensions->list.array[0]->\
1413                                                    extensionValue.choice.SliceSupportList.list.array[sliceId],sizeof(SliceSupportItem_t));
1414                                           }
1415                                           DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.array[servId]->iE_Extensions->list.array[0]->\
1416                                                 extensionValue.choice.SliceSupportList.list.array,sizeof(SliceSupportItem_t*));
1417                                        }
1418                                        DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.\
1419                                              array[servId]->iE_Extensions->list.array[plmnidx],sizeof(ServedPLMNs_ItemExtIEs_t));
1420                                     }
1421                                     DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.\
1422                                           array[servId]->iE_Extensions->list.array,\
1423                                           extensionCnt*sizeof(ServedPLMNs_ItemExtIEs_t*));
1424                                  }
1425                                  DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.\
1426                                        array[servId]->iE_Extensions,sizeof(ProtocolExtensionContainer_4624P3_t));
1427                               }
1428                               DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.\
1429                                     array[servId]->pLMN_Identity.buf,srvCellItem->served_Cell_Information.\
1430                                     servedPLMNs.list.array[servId]->pLMN_Identity.size
1431                                     * sizeof(uint8_t));
1432                            }
1433                            DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.array[plmnidx],\
1434                                  sizeof(ServedPLMNs_Item_t *));
1435                         }
1436                         DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.array,\
1437                               sizeof(ServedPLMNs_Item_t *));
1438                      }
1439                      DU_FREE(srvCellItem->served_Cell_Information.fiveGS_TAC->buf,\
1440                            sizeof(srvCellItem->served_Cell_Information.fiveGS_TAC->size));
1441                   }
1442                   DU_FREE(srvCellItem->served_Cell_Information.fiveGS_TAC,sizeof(FiveGS_TAC_t));
1443                }
1444                DU_FREE(srvCellItem->served_Cell_Information.nRCGI.nRCellIdentity.buf,\
1445                      srvCellItem->served_Cell_Information.nRCGI.nRCellIdentity.size *
1446                      sizeof(uint8_t));
1447             }
1448             DU_FREE(srvCellItem->served_Cell_Information.nRCGI.pLMN_Identity.buf,\
1449                   srvCellItem->served_Cell_Information.nRCGI.pLMN_Identity.size *
1450                   sizeof(uint8_t));
1451          }
1452          DU_FREE(duServedCell->list.array[plmnidx],sizeof(GNB_DU_Served_Cells_ItemIEs_t));
1453       }
1454       DU_FREE(duServedCell->list.array,plmnCnt*sizeof(GNB_DU_Served_Cells_ItemIEs_t*));
1455    }
1456 }
1457 /*******************************************************************
1458  *
1459  * @brief  deallocating the memory of function BuildAndSendF1SetupReq()
1460  *
1461  * @details
1462  *
1463  *    Function :  FreeF1SetupReq
1464  *
1465  *    Functionality:  deallocating the memory of function BuildAndSendF1SetupReq
1466  *
1467  * @params[in] F1AP_PDU_t *f1apMsg
1468  *
1469  * @return void
1470  *
1471  * ****************************************************************/
1472 void FreeF1SetupReq(F1AP_PDU_t *f1apMsg)
1473 {
1474    uint8_t ieIdx, ieIdx2;
1475    F1SetupRequest_t *f1SetupReq=NULLP;
1476
1477    if(f1apMsg != NULLP)
1478    {
1479       if(f1apMsg->choice.initiatingMessage != NULLP)
1480       {
1481          f1SetupReq = &f1apMsg->choice.initiatingMessage->value.choice.F1SetupRequest;
1482          if(f1SetupReq->protocolIEs.list.array != NULLP)
1483          {
1484             for(ieIdx = 0; ieIdx < f1SetupReq->protocolIEs.list.count; ieIdx++)
1485             {
1486                if(f1SetupReq->protocolIEs.list.array[ieIdx] != NULLP)
1487                {
1488                   switch(f1SetupReq->protocolIEs.list.array[ieIdx]->id)
1489                   {
1490                      case ProtocolIE_ID_id_TransactionID:
1491                         break;
1492                      case ProtocolIE_ID_id_gNB_DU_ID:
1493                         DU_FREE(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf,\
1494                               f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.size);
1495                         break;
1496                      case ProtocolIE_ID_id_gNB_DU_Name:
1497                         DU_FREE(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_Name.buf,\
1498                               strlen((char *)duCfgParam.duName));
1499                         break;
1500                      case ProtocolIE_ID_id_gNB_DU_Served_Cells_List:
1501                         FreeServedCellList(&f1SetupReq->protocolIEs.list.\
1502                               array[ieIdx]->value.choice.GNB_DU_Served_Cells_List);
1503                         break;
1504                      case ProtocolIE_ID_id_GNB_DU_RRC_Version:
1505                         FreeRrcVer(&f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.RRC_Version);
1506                         break;
1507                      default:
1508                         DU_LOG("\nERROR  -->  Invalid Event Type %ld", f1SetupReq->protocolIEs.list.array[ieIdx]->id);
1509                         break;
1510                   }
1511                }
1512                break;
1513             }
1514             for(ieIdx2=0; ieIdx2< ieIdx; ieIdx2++)
1515             {
1516                DU_FREE(f1SetupReq->protocolIEs.list.array[ieIdx2],sizeof(F1SetupRequestIEs_t));
1517             }
1518             DU_FREE(f1SetupReq->protocolIEs.list.array,\
1519                   f1SetupReq->protocolIEs.list.size);
1520          }
1521          DU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
1522       }
1523       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
1524    }
1525 }
1526 /*******************************************************************
1527  *
1528  * @brief Builds and Send the F1SetupRequest
1529  *
1530  * @details
1531  *
1532  *    Function : BuildAndSendF1SetupReq
1533  *
1534  * Functionality:Fills the F1SetupRequest
1535  *
1536  * @return ROK     - success
1537  *         RFAILED - failure
1538  *
1539  ******************************************************************/
1540 uint8_t BuildAndSendF1SetupReq()
1541 {
1542    uint8_t   ret, ieIdx, elementCnt;
1543    F1AP_PDU_t                 *f1apMsg = NULLP;
1544    F1SetupRequest_t           *f1SetupReq=NULLP;
1545    GNB_DU_Served_Cells_List_t *duServedCell=NULLP;
1546    RRC_Version_t              *rrcVer=NULLP;
1547    asn_enc_rval_t             encRetVal;        /* Encoder return value */
1548    ret= RFAILED;
1549
1550    DU_LOG("\nINFO   -->  F1AP : Building F1 Setup Request\n");
1551    do
1552    {
1553       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
1554       if(f1apMsg == NULLP)
1555       {
1556          break;
1557       }
1558       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
1559       DU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
1560       if(f1apMsg->choice.initiatingMessage == NULLP)
1561       {
1562          break;
1563       }
1564       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_F1Setup;
1565       f1apMsg->choice.initiatingMessage->criticality = Criticality_reject;
1566       f1apMsg->choice.initiatingMessage->value.present = \
1567                                                          InitiatingMessage__value_PR_F1SetupRequest;
1568
1569       f1SetupReq = &f1apMsg->choice.initiatingMessage->value.choice.F1SetupRequest;
1570
1571       elementCnt = (duCfgParam.duName != NULL) ? 5 : 4;
1572
1573       f1SetupReq->protocolIEs.list.count = elementCnt;
1574       f1SetupReq->protocolIEs.list.size = elementCnt * sizeof(F1SetupRequestIEs_t );
1575
1576       /* Initialize the F1Setup members */
1577       DU_ALLOC(f1SetupReq->protocolIEs.list.array,f1SetupReq->protocolIEs.list.size);
1578       if(f1SetupReq->protocolIEs.list.array == NULLP)
1579       {
1580          break;
1581       }
1582       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
1583       {
1584          DU_ALLOC(f1SetupReq->protocolIEs.list.array[ieIdx],\
1585                sizeof(F1SetupRequestIEs_t));
1586          if(f1SetupReq->protocolIEs.list.array[ieIdx] == NULLP)
1587          {
1588             break;
1589          }
1590       }
1591
1592       ieIdx = 0;
1593       /*TransactionID*/
1594       f1SetupReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_TransactionID;
1595       f1SetupReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
1596       f1SetupReq->protocolIEs.list.array[ieIdx]->value.present =\
1597                                                                F1SetupRequestIEs__value_PR_TransactionID;
1598       f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.TransactionID = \
1599                                                                              TRANS_ID;
1600
1601       /*DU ID*/
1602       ieIdx++;
1603       f1SetupReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_ID;
1604       f1SetupReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
1605       f1SetupReq->protocolIEs.list.array[ieIdx]->value.present = \
1606                                                                 F1SetupRequestIEs__value_PR_GNB_DU_ID;
1607       f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.size =\
1608                                                                              sizeof(uint8_t);
1609
1610       DU_ALLOC(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf,\
1611             f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.size);
1612       if(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf == \
1613             NULLP)
1614       {
1615          break;
1616       }
1617
1618       f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf[0] =\
1619          duCfgParam.duId;
1620
1621       /*DU Name*/
1622       if(duCfgParam.duName != NULL)
1623       {
1624          ieIdx++;
1625          f1SetupReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_Name;
1626          f1SetupReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_ignore;
1627          f1SetupReq->protocolIEs.list.array[ieIdx]->value.present = F1SetupRequestIEs__value_PR_GNB_DU_Name;
1628          f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_Name.size =\
1629             strlen((char *)duCfgParam.duName);
1630          DU_ALLOC(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.\
1631                GNB_DU_Name.buf, strlen((char *)duCfgParam.duName));
1632          if(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_Name.\
1633                buf == NULLP)
1634          {
1635             break;
1636          }
1637          strcpy((char*)f1SetupReq->protocolIEs.list.array[ieIdx]->value.\
1638                choice.GNB_DU_Name.buf,
1639                (char*)&duCfgParam.duName);
1640
1641       }
1642
1643       /*Served Cell list */
1644       ieIdx++;
1645       f1SetupReq->protocolIEs.list.array[ieIdx]->id = \
1646                                                      ProtocolIE_ID_id_gNB_DU_Served_Cells_List;
1647       f1SetupReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
1648       f1SetupReq->protocolIEs.list.array[ieIdx]->value.present = \
1649                                                                 F1SetupRequestIEs__value_PR_GNB_DU_Served_Cells_List;
1650       duServedCell = &f1SetupReq->protocolIEs.list.\
1651                      array[ieIdx]->value.choice.GNB_DU_Served_Cells_List;
1652       if(BuildServedCellList(duServedCell))
1653       {
1654          break;
1655       }
1656       /*RRC Version*/
1657       ieIdx++;
1658       f1SetupReq->protocolIEs.list.array[ieIdx]->id = \
1659                                                      ProtocolIE_ID_id_GNB_DU_RRC_Version ;
1660       f1SetupReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
1661       f1SetupReq->protocolIEs.list.array[ieIdx]->value.present = \
1662                                                                 F1SetupRequestIEs__value_PR_RRC_Version;
1663       rrcVer = &f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.RRC_Version;
1664       if(BuildRrcVer(rrcVer))
1665       {
1666          break;
1667       }
1668       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
1669
1670       /* Encode the F1SetupRequest type as APER */
1671       memset(encBuf, 0, ENC_BUF_MAX_LEN);
1672       encBufSize = 0;
1673       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
1674             encBuf);
1675
1676       /* Encode results */
1677       if(encRetVal.encoded == ENCODE_FAIL)
1678       {
1679          DU_LOG("\nERROR  -->  F1AP : Could not encode F1SetupRequest structure (at %s)\n",\
1680                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
1681          break;
1682       }
1683       else
1684       {
1685          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for F1SetupRequest\n");
1686          for(ieIdx=0; ieIdx< encBufSize; ieIdx++)
1687          {
1688             printf("%x",encBuf[ieIdx]);
1689          }
1690       }
1691
1692       /* Sending msg */
1693       if(SendF1APMsg(DU_APP_MEM_REGION, DU_POOL) != ROK)
1694       {
1695          DU_LOG("\nERROR  -->  F1AP : Sending F1 Setup request failed");
1696          break;
1697       }
1698
1699       ret=ROK;
1700       break;
1701    }while(true);
1702
1703    FreeF1SetupReq(f1apMsg);
1704
1705    return ret;
1706 }/* End of BuildAndSendF1SetupReq */
1707
1708 /*******************************************************************
1709  *
1710  * @brief Deallocating memory of BuildAndSendDUConfigUpdate
1711  *
1712  * @details
1713  *
1714  *    Function : FreeDUConfigUpdate
1715  *
1716  *    Functionality: Deallocating memory of variables allocated in
1717  *                    BuildAndSendDUConfigUpdate function
1718  *
1719  * @params[in]  F1AP_PDU_t *f1apDuCfg
1720  *
1721  * @return ROK     - void
1722  *
1723  * ****************************************************************/
1724 void FreeDUConfigUpdate(F1AP_PDU_t *f1apDuCfg)
1725 {
1726    uint8_t  i;
1727    uint8_t  idx;
1728    GNBDUConfigurationUpdate_t *duCfgUpdate = NULLP;
1729    Served_Cells_To_Modify_List_t  *cellsToModify;
1730    Served_Cells_To_Modify_Item_t *modifyItem;
1731    idx=0;
1732    i=1;
1733    if(f1apDuCfg != NULLP)
1734    {
1735       if(f1apDuCfg->choice.initiatingMessage != NULLP)
1736       {
1737          duCfgUpdate = &f1apDuCfg->choice.initiatingMessage->\
1738                        value.choice.GNBDUConfigurationUpdate;
1739          if(duCfgUpdate->protocolIEs.list.array != NULLP)
1740          {
1741             if(duCfgUpdate->protocolIEs.list.array[i] != NULLP)
1742             {
1743                cellsToModify = &duCfgUpdate->protocolIEs.list.array[i]->\
1744                                value.choice.Served_Cells_To_Modify_List;
1745                if(cellsToModify->list.array != NULLP)
1746                {
1747                   if(cellsToModify->list.array[idx] != NULLP)
1748                   {
1749                      modifyItem=&cellsToModify->list.array[idx]->value.choice.\
1750                                 Served_Cells_To_Modify_Item;
1751                      if(modifyItem->oldNRCGI.pLMN_Identity.buf != NULLP)
1752                      {
1753                         if(modifyItem->oldNRCGI.nRCellIdentity.buf != NULLP)
1754                         {
1755                            if(modifyItem->served_Cell_Information.nRCGI.pLMN_Identity.buf != NULLP)
1756                            {
1757                               if(modifyItem->served_Cell_Information.nRCGI.nRCellIdentity.buf
1758                                     != NULLP)
1759                               {
1760                                  if(modifyItem->served_Cell_Information.servedPLMNs.list.array\
1761                                        != NULLP)
1762                                  {
1763                                     if(!modifyItem->served_Cell_Information.servedPLMNs.list.array[idx])
1764                                     {
1765                                        if(modifyItem->served_Cell_Information.servedPLMNs.list.\
1766                                              array[idx]->pLMN_Identity.buf != NULLP)
1767                                        {
1768                                           if(modifyItem->served_Cell_Information.servedPLMNs.list.\
1769                                                 array[idx]->iE_Extensions!= NULLP)
1770                                           {
1771                                              if(modifyItem->served_Cell_Information.servedPLMNs.list.\
1772                                                    array[idx]->iE_Extensions->list.array != NULLP)
1773                                              {
1774                                                 if(modifyItem->served_Cell_Information.servedPLMNs.list.\
1775                                                       array[idx]->iE_Extensions->list.array[idx])
1776                                                 {
1777                                                    if(modifyItem->served_Cell_Information.servedPLMNs.list.array[idx]->\
1778                                                          iE_Extensions->list.array[idx]->extensionValue.choice.SliceSupportList.\
1779                                                          list.array !=NULLP)
1780                                                    {
1781                                                       if(modifyItem->served_Cell_Information.servedPLMNs.list.array[idx]->\
1782                                                             iE_Extensions->list.array[idx]->extensionValue.choice.SliceSupportList.\
1783                                                             list.array[idx]!=NULLP)
1784                                                       {
1785                                                          if(modifyItem->served_Cell_Information.servedPLMNs.list.array[idx]->\
1786                                                                iE_Extensions->list.array[idx]->extensionValue.choice.SliceSupportList.\
1787                                                                list.array[idx]->sNSSAI.sST.buf!=NULLP)
1788                                                          {
1789                                                             if(modifyItem->served_Cell_Information.servedPLMNs.list.array[idx]->\
1790                                                                   iE_Extensions->list.array[idx]->extensionValue.choice.SliceSupportList.\
1791                                                                   list.array[idx]->sNSSAI.sD != NULLP)
1792                                                             {
1793                                                                if(modifyItem->served_Cell_Information.servedPLMNs.list.array[idx]->\
1794                                                                      iE_Extensions->list.array[idx]->extensionValue.choice.SliceSupportList.\
1795                                                                      list.array[idx]->sNSSAI.sD->buf!=NULLP)
1796                                                                {
1797                                                                   if(modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD
1798                                                                         !=NULLP)
1799                                                                   {
1800                                                                      if(modifyItem->served_Cell_Information.nR_Mode_Info.choice.\
1801                                                                            fDD->uL_NRFreqInfo.freqBandListNr.list.array!=NULLP)
1802                                                                      {
1803                                                                         if(modifyItem->served_Cell_Information.nR_Mode_Info.choice.\
1804                                                                               fDD->uL_NRFreqInfo.freqBandListNr.list.array[idx]!=NULLP)
1805                                                                         {
1806                                                                            if(modifyItem->served_Cell_Information.nR_Mode_Info.choice.\
1807                                                                                  fDD->dL_NRFreqInfo.freqBandListNr.list.array !=NULLP)
1808                                                                            {
1809                                                                               if(modifyItem->served_Cell_Information.nR_Mode_Info.\
1810                                                                                     choice.fDD->dL_NRFreqInfo.freqBandListNr.list.\
1811                                                                                     array[idx]!= NULLP)
1812                                                                               {
1813                                                                                  if(modifyItem->served_Cell_Information.\
1814                                                                                        measurementTimingConfiguration.buf !=NULLP)
1815                                                                                  {
1816                                                                                     idx=2;
1817                                                                                     if(duCfgUpdate->protocolIEs.list.array[idx]->value.\
1818                                                                                           choice.GNB_DU_ID.buf!=NULLP)
1819                                                                                     {
1820                                                                                        DU_FREE(duCfgUpdate->protocolIEs.list.\
1821                                                                                              array[idx]->value.choice.GNB_DU_ID.buf,\
1822                                                                                              duCfgUpdate->protocolIEs.list.array[idx]->\
1823                                                                                              value.choice.GNB_DU_ID.size);
1824                                                                                     }
1825                                                                                     idx=0;
1826                                                                                     DU_FREE(modifyItem->served_Cell_Information.\
1827                                                                                           measurementTimingConfiguration.\
1828                                                                                           buf,modifyItem->served_Cell_Information.\
1829                                                                                           measurementTimingConfiguration.size);
1830                                                                                  }
1831                                                                                  DU_FREE(modifyItem->served_Cell_Information.\
1832                                                                                        nR_Mode_Info.choice.fDD->dL_NRFreqInfo.freqBandListNr.\
1833                                                                                        list.array[idx],sizeof(FreqBandNrItem_t));
1834                                                                               }
1835                                                                               DU_FREE(modifyItem->served_Cell_Information.nR_Mode_Info\
1836                                                                                     .choice.fDD->dL_NRFreqInfo.freqBandListNr.list.array,\
1837                                                                                     modifyItem->served_Cell_Information.nR_Mode_Info.\
1838                                                                                     choice.fDD->dL_NRFreqInfo.freqBandListNr.list.size);
1839                                                                            }
1840                                                                            DU_FREE(modifyItem->served_Cell_Information.nR_Mode_Info.\
1841                                                                                  choice.fDD->uL_NRFreqInfo.freqBandListNr.list.\
1842                                                                                  array[idx],sizeof(FreqBandNrItem_t));
1843                                                                         }
1844                                                                         DU_FREE(modifyItem->served_Cell_Information.nR_Mode_Info.\
1845                                                                               choice.\
1846                                                                               fDD->uL_NRFreqInfo.freqBandListNr.list.\
1847                                                                               array,modifyItem->served_Cell_Information.nR_Mode_Info.choice.\
1848                                                                               fDD->uL_NRFreqInfo.freqBandListNr.list.size);
1849                                                                      }
1850                                                                      DU_FREE(modifyItem->served_Cell_Information.nR_Mode_Info.choice.\
1851                                                                            fDD,sizeof(FDD_Info_t));
1852                                                                   }
1853                                                                   DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.\
1854                                                                         array[idx]->iE_Extensions->list.array[idx]->extensionValue.choice.\
1855                                                                         SliceSupportList.\
1856                                                                         list.array[idx]->sNSSAI.sD->buf,modifyItem->served_Cell_Information.\
1857                                                                         servedPLMNs.list.array[idx]->iE_Extensions->list.array[idx]->\
1858                                                                         extensionValue.choice.SliceSupportList.list.array[idx]->\
1859                                                                         sNSSAI.sD->size);
1860
1861                                                                }
1862                                                                DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.\
1863                                                                      array[idx]->\
1864                                                                      iE_Extensions->list.array[idx]->extensionValue.choice.SliceSupportList.\
1865                                                                      list.array[idx]->sNSSAI.sD,sizeof(OCTET_STRING_t));
1866                                                             }
1867                                                             DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.array[idx]->\
1868                                                                   iE_Extensions->list.array[idx]->extensionValue.choice.SliceSupportList.\
1869                                                                   list.array[idx]->sNSSAI.sST.buf,modifyItem->served_Cell_Information.\
1870                                                                   servedPLMNs.\
1871                                                                   list.array[idx]->iE_Extensions->list.array[idx]->extensionValue.choice.\
1872                                                                   SliceSupportList.list.array[idx]->sNSSAI.sST.size);
1873                                                          }
1874                                                          DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.array[idx]->\
1875                                                                iE_Extensions->list.array[idx]->extensionValue.choice.SliceSupportList.\
1876                                                                list.array[idx],sizeof(SliceSupportItem_t));
1877                                                       }
1878                                                       DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.array[idx]->\
1879                                                             iE_Extensions->list.array[idx]->extensionValue.choice.SliceSupportList.\
1880                                                             list.array,\
1881                                                             modifyItem->served_Cell_Information.servedPLMNs.list.array[idx]->\
1882                                                             iE_Extensions->list.array[idx]->extensionValue.choice.SliceSupportList.list.size);
1883                                                    }
1884                                                 }
1885                                                 for(i=0;i<modifyItem->served_Cell_Information.servedPLMNs.list.\
1886                                                       array[idx]->iE_Extensions->list.count;i++)
1887                                                 {
1888                                                    DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.\
1889                                                          array[idx]->iE_Extensions->list.array[i],\
1890                                                          sizeof(ServedPLMNs_ItemExtIEs_t ));
1891                                                 }
1892                                                 DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.\
1893                                                       array[idx]->iE_Extensions->list.array,modifyItem->served_Cell_Information.servedPLMNs.
1894                                                       list.array[idx]->iE_Extensions->list.size);
1895                                              }
1896                                              DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.\
1897                                                    array[idx]->iE_Extensions,sizeof(ProtocolExtensionContainer_4624P3_t));
1898                                           }
1899                                           DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.\
1900                                                 array[idx]->pLMN_Identity.buf,
1901                                                 modifyItem->served_Cell_Information.servedPLMNs.list.array[idx]->pLMN_Identity.size);
1902                                        }
1903                                     }
1904                                     for(i=0;i<modifyItem->served_Cell_Information.servedPLMNs.list.count;i++)
1905                                     {
1906                                        if(modifyItem->served_Cell_Information.servedPLMNs.list.array[i]
1907                                              != NULLP)
1908                                        {
1909                                           DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.array[i],\
1910                                                 sizeof(ServedPLMNs_Item_t));
1911                                        }
1912                                     }
1913                                     DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.array,\
1914                                           modifyItem->served_Cell_Information.servedPLMNs.list.size);
1915                                  }
1916                                  DU_FREE(modifyItem->served_Cell_Information.nRCGI.nRCellIdentity.buf,\
1917                                        modifyItem->served_Cell_Information.nRCGI.nRCellIdentity.size);
1918                               }
1919                               DU_FREE(modifyItem->served_Cell_Information.nRCGI.pLMN_Identity.buf,\
1920                                     modifyItem->served_Cell_Information.nRCGI.pLMN_Identity.size);
1921                            }
1922                            DU_FREE(modifyItem->oldNRCGI.nRCellIdentity.buf,\
1923                                  modifyItem->oldNRCGI.nRCellIdentity.size);
1924                         }
1925                         DU_FREE(modifyItem->oldNRCGI.pLMN_Identity.buf,\
1926                               modifyItem->oldNRCGI.pLMN_Identity.size);
1927                      }
1928                   }
1929                   for(i=0; i<cellsToModify->list.count ;i++)
1930                   {
1931                      if(cellsToModify->list.array[i] != NULLP)
1932                      {
1933                         DU_FREE(cellsToModify->list.array[i],\
1934                               sizeof(Served_Cells_To_Modify_ItemIEs_t));
1935                      }
1936                   }
1937                   DU_FREE(cellsToModify->list.array,cellsToModify->list.size);
1938                }
1939             }
1940             for(i=0;i<duCfgUpdate->protocolIEs.list.count;i++)
1941             {
1942                if(duCfgUpdate->protocolIEs.list.array[i] !=NULLP)
1943                {
1944                   DU_FREE(duCfgUpdate->protocolIEs.list.array[i],\
1945                         sizeof(GNBDUConfigurationUpdateIEs_t));
1946                }
1947             }
1948             DU_FREE(duCfgUpdate->protocolIEs.list.array,duCfgUpdate->protocolIEs.list.size);
1949          }
1950          DU_FREE(f1apDuCfg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
1951       }
1952       DU_FREE(f1apDuCfg, (Size)sizeof(F1AP_PDU_t));
1953    }
1954 }
1955
1956 /*******************************************************************
1957  *
1958  * @brief Fills Served Plmns required in ServCellInfo IE
1959  *
1960  * @details
1961  *
1962  *    Function : fillServedPlmns
1963  *
1964  *    Functionality: Fills Served Plmns required in ServCellInfo IE
1965  *
1966  * @params[in] Pointer to ServedPLMNs_List_t *
1967  *
1968  * @return ROK     - success
1969  *         RFAILED - failure
1970  *
1971  *****************************************************************/
1972
1973 uint8_t fillServedPlmns(ServedPLMNs_List_t *servedPlmn)
1974 {
1975    uint8_t ieIdx, ieListCnt;
1976
1977    servedPlmn->list.array[0]->pLMN_Identity.size = 3*sizeof(uint8_t);
1978    DU_ALLOC(servedPlmn->list.array[0]->pLMN_Identity.buf, servedPlmn->list.\
1979          array[0]->pLMN_Identity.size);
1980    if(servedPlmn->list.array[0]->pLMN_Identity.buf == NULLP)
1981    {
1982       return RFAILED;
1983    }
1984    buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.plmn[0],\
1985          servedPlmn->list.array[0]->pLMN_Identity.buf);
1986    DU_ALLOC(servedPlmn->list.array[0]->iE_Extensions,sizeof(ProtocolExtensionContainer_4624P3_t));
1987    if(servedPlmn->list.array[0]->iE_Extensions == NULLP)
1988    {
1989       return RFAILED;
1990    }
1991
1992    ieListCnt=1;
1993    servedPlmn->list.array[0]->iE_Extensions->list.count = ieListCnt;
1994    servedPlmn->list.array[0]->iE_Extensions->list.size = ieListCnt *sizeof(ServedPLMNs_ItemExtIEs_t *);
1995    DU_ALLOC(servedPlmn->list.array[0]->iE_Extensions->list.array,servedPlmn->list.array[0]->\
1996          iE_Extensions->list.size);
1997    if(servedPlmn->list.array[0]->iE_Extensions->list.array == NULLP)
1998    {
1999       return RFAILED;
2000    }
2001    for(ieIdx=0;ieIdx<ieListCnt;ieIdx++)
2002    {
2003       DU_ALLOC(servedPlmn->list.array[0]->iE_Extensions->list.array[ieIdx],\
2004             sizeof(ServedPLMNs_ItemExtIEs_t));
2005       if(servedPlmn->list.array[0]->iE_Extensions->list.array[ieIdx] == NULLP)
2006       {
2007          return RFAILED;
2008       }
2009    }
2010    //plmnIeExt = servedPlmn->list.array[0]->iE_Extensions;
2011    servedPlmn->list.array[0]->iE_Extensions->list.array[0]->id =ProtocolIE_ID_id_TAISliceSupportList;
2012    servedPlmn->list.array[0]->iE_Extensions->list.array[0]->criticality = Criticality_ignore;
2013    servedPlmn->list.array[0]->iE_Extensions->list.array[0]->extensionValue.present = \
2014       ServedPLMNs_ItemExtIEs__extensionValue_PR_SliceSupportList;
2015    servedPlmn->list.array[0]->iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2016       list.count = 1;
2017    servedPlmn->list.array[0]->\
2018       iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2019       list.size = sizeof(SliceSupportItem_t *);
2020    DU_ALLOC(servedPlmn->list.array[0]->\
2021          iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2022          list.array,servedPlmn->list.array[0]->\
2023          iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.list.size);
2024    if(servedPlmn->list.array[0]->\
2025          iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2026          list.array == NULLP)
2027    {
2028       return RFAILED;
2029    }
2030
2031    DU_ALLOC(servedPlmn->list.array[0]->\
2032          iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2033          list.array[0],sizeof( SliceSupportItem_t));
2034    if(servedPlmn->list.array[0]->\
2035          iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2036          list.array[0] == NULLP)
2037    {
2038       return RFAILED;
2039    }
2040    servedPlmn->list.array[0]->\
2041       iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2042       list.array[0]->sNSSAI.sST.size = sizeof(uint8_t);
2043    DU_ALLOC(servedPlmn->list.array[0]->\
2044          iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2045          list.array[0]->sNSSAI.sST.buf,servedPlmn->list.array[0]->\
2046          iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.list.array[0]->sNSSAI.sST.size);
2047    if(servedPlmn->list.array[0]->\
2048          iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2049          list.array[0]->sNSSAI.sST.buf == NULLP)
2050    {
2051       return RFAILED;
2052    }
2053    servedPlmn->list.array[0]->\
2054       iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2055       list.array[0]->sNSSAI.sST.buf[0] = 3;
2056    DU_ALLOC(servedPlmn->list.array[0]->\
2057          iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2058          list.array[0]->sNSSAI.sD,sizeof(OCTET_STRING_t));
2059    if(servedPlmn->list.array[0]->\
2060          iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2061          list.array[0]->sNSSAI.sD == NULLP)
2062    {
2063       return RFAILED;
2064    }
2065    servedPlmn->list.array[0]->\
2066       iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2067       list.array[0]->sNSSAI.sD->size = 3*sizeof(uint8_t);
2068    DU_ALLOC(servedPlmn->list.array[0]->\
2069          iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2070          list.array[0]->sNSSAI.sD->buf,servedPlmn->list.array[0]->\
2071          iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2072          list.array[0]->sNSSAI.sD->size);
2073    if(servedPlmn->list.array[0]->\
2074          iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2075          list.array[0]->sNSSAI.sD->buf == NULLP)
2076    {
2077       return RFAILED;
2078    }
2079    servedPlmn->list.array[0]->\
2080       iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2081       list.array[0]->sNSSAI.sD->buf[0] = 3;
2082    servedPlmn->list.array[0]->\
2083       iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2084       list.array[0]->sNSSAI.sD->buf[1] = 6;
2085    servedPlmn->list.array[0]->\
2086       iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2087       list.array[0]->sNSSAI.sD->buf[2] = 9;
2088    return ROK;
2089 }
2090
2091 /*******************************************************************
2092  *
2093  * @brief Fills Nr Fdd Info required in ServCellInfo IE
2094  *
2095  * @details
2096  *
2097  *    Function : fillNrFddInfo
2098  *
2099  *    Functionality: Fills Nr Fdd Info required in ServCellInfo IE
2100  *
2101  * @params[in] Pointer to NR_Mode_Info_t *
2102  *
2103  * @return ROK     - success
2104  *         RFAILED - failure
2105  *
2106  *****************************************************************/
2107
2108 uint8_t fillNrFddInfo(NR_Mode_Info_t *nrFdd)
2109 {
2110    nrFdd->choice.fDD->uL_NRFreqInfo.nRARFCN = duCfgParam.srvdCellLst[0].duCellInfo.\
2111       f1Mode.mode.fdd.ulNrFreqInfo.nrArfcn;
2112    nrFdd->choice.fDD->uL_NRFreqInfo.freqBandListNr.list.count = 1;
2113    nrFdd->choice.fDD->uL_NRFreqInfo.freqBandListNr.list.size = sizeof(FreqBandNrItem_t*);
2114    DU_ALLOC(nrFdd->choice.fDD->uL_NRFreqInfo.freqBandListNr.list.\
2115          array, nrFdd->choice.fDD->uL_NRFreqInfo.freqBandListNr.list.size);
2116    if(nrFdd->choice.fDD->uL_NRFreqInfo.freqBandListNr.list.array == NULLP)
2117    {
2118       return RFAILED;
2119    }
2120    DU_ALLOC(nrFdd->choice.fDD->uL_NRFreqInfo.freqBandListNr.list.array[0], \
2121       sizeof(FreqBandNrItem_t));
2122    if(nrFdd->choice.fDD->uL_NRFreqInfo.freqBandListNr.list.array[0] == NULLP)
2123    {
2124       return RFAILED;
2125    }
2126    nrFdd->choice.fDD->uL_NRFreqInfo.freqBandListNr.list.array[0]->freqBandIndicatorNr = \
2127       duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.fdd.ulNrFreqInfo.\
2128       freqBand[0].nrFreqBand;
2129    nrFdd->choice.fDD->uL_NRFreqInfo.freqBandListNr.list.array[0]->supportedSULBandList.list.count=0;
2130    nrFdd->choice.fDD->dL_NRFreqInfo.nRARFCN = duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.fdd.\
2131       dlNrFreqInfo.nrArfcn;
2132    nrFdd->choice.fDD->dL_NRFreqInfo.freqBandListNr.list.count = 1;
2133    nrFdd->choice.fDD->dL_NRFreqInfo.freqBandListNr.list.size = sizeof(FreqBandNrItem_t *);
2134    DU_ALLOC(nrFdd->choice.fDD->dL_NRFreqInfo.freqBandListNr.list.array,nrFdd->\
2135          choice.fDD->dL_NRFreqInfo.freqBandListNr.list.size);
2136    if(nrFdd->choice.fDD->dL_NRFreqInfo.freqBandListNr.list.array == NULLP)
2137    {
2138       return RFAILED;
2139    }
2140    DU_ALLOC(nrFdd->choice.fDD->dL_NRFreqInfo.freqBandListNr.list.array[0],\
2141          sizeof(FreqBandNrItem_t));
2142    if(nrFdd->choice.fDD->dL_NRFreqInfo.freqBandListNr.list.array[0] == NULLP)
2143    {
2144       return RFAILED;
2145    }
2146    nrFdd->choice.fDD->dL_NRFreqInfo.freqBandListNr.list.array[0]->freqBandIndicatorNr = \
2147       duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.fdd.dlNrFreqInfo.\
2148       freqBand[0].nrFreqBand;
2149    nrFdd->choice.fDD->dL_NRFreqInfo.freqBandListNr.list.array[0]->supportedSULBandList.list.count=0;
2150
2151    /*Transmission Bandwidth*/
2152    nrFdd->choice.fDD->uL_Transmission_Bandwidth.nRSCS = duCfgParam.srvdCellLst[0].duCellInfo.\
2153       f1Mode.mode.fdd.ulTxBw.nrScs;
2154    nrFdd->choice.fDD->uL_Transmission_Bandwidth.nRNRB = duCfgParam.srvdCellLst[0].duCellInfo.\
2155       f1Mode.mode.fdd.ulTxBw.nrb;
2156    nrFdd->choice.fDD->dL_Transmission_Bandwidth.nRSCS = duCfgParam.srvdCellLst[0].duCellInfo.\
2157       f1Mode.mode.fdd.dlTxBw.nrScs;
2158    nrFdd->choice.fDD->dL_Transmission_Bandwidth.nRNRB = duCfgParam.srvdCellLst[0].duCellInfo.\
2159       f1Mode.mode.fdd.dlTxBw.nrb;
2160
2161    return ROK;
2162 }
2163
2164 /*******************************************************************
2165  *
2166  * @brief Fills ServCellInfo IE
2167  *
2168  * @details
2169  *
2170  *    Function : fillServedCellInfo
2171  *
2172  *    Functionality: Fills ServCellInfo
2173  *
2174  * @params[in] Pointer to Served_Cell_Information_t *
2175  *
2176  * @return ROK     - success
2177  *         RFAILED - failure
2178  *
2179  *****************************************************************/
2180
2181 uint8_t fillServedCellInfo(Served_Cell_Information_t *srvCellInfo)
2182 {
2183    uint8_t tmp, ieIdx, ieListCnt;
2184
2185    /*nRCGI*/
2186    srvCellInfo->nRCGI.pLMN_Identity.size =3*sizeof(uint8_t);
2187    DU_ALLOC(srvCellInfo->nRCGI.pLMN_Identity.buf,\
2188          srvCellInfo->nRCGI.pLMN_Identity.size);
2189    if(srvCellInfo->nRCGI.pLMN_Identity.buf == NULLP)
2190    {
2191       return RFAILED;
2192    }
2193    buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrCgi.plmn,\
2194          srvCellInfo->nRCGI.pLMN_Identity.buf);
2195    srvCellInfo->nRCGI.nRCellIdentity.size =5*sizeof(uint8_t);
2196    DU_ALLOC(srvCellInfo->nRCGI.nRCellIdentity.buf,\
2197          srvCellInfo->nRCGI.nRCellIdentity.size);
2198    if(srvCellInfo->nRCGI.nRCellIdentity.buf == NULLP)
2199    {
2200       return RFAILED;
2201    }
2202    for (tmp = 0 ; tmp < srvCellInfo->\
2203          nRCGI.nRCellIdentity.size-1 ; tmp++)
2204    {
2205       srvCellInfo->nRCGI.nRCellIdentity.buf[tmp] = 0;
2206    }
2207    srvCellInfo->nRCGI.nRCellIdentity.buf[4] = 16;
2208    srvCellInfo->nRCGI.nRCellIdentity.bits_unused =4;
2209
2210    /*nRPCI*/
2211    srvCellInfo->nRPCI = duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrPci;
2212
2213    /*servedPLMNs*/
2214    ieListCnt = 1;
2215    srvCellInfo->servedPLMNs.list.count = ieListCnt;
2216    srvCellInfo->servedPLMNs.list.size = ieListCnt*sizeof(ServedPLMNs_Item_t *);
2217    DU_ALLOC(srvCellInfo->servedPLMNs.list.array,\
2218          srvCellInfo->servedPLMNs.list.size);
2219    if(srvCellInfo->servedPLMNs.list.array == NULLP)
2220    {
2221       return RFAILED;
2222    }
2223    for(ieIdx=0; ieIdx < ieListCnt; ieIdx++)
2224    {
2225       DU_ALLOC(srvCellInfo->servedPLMNs.list.array[ieIdx],\
2226             sizeof(ServedPLMNs_Item_t));
2227       if(srvCellInfo->servedPLMNs.list.array[ieIdx]== NULLP)
2228       {
2229          return RFAILED;
2230       }
2231    }
2232    if(fillServedPlmns(&srvCellInfo->servedPLMNs))
2233    {
2234       return RFAILED;
2235    }
2236
2237    /*nR Mode Info with FDD*/
2238    srvCellInfo->nR_Mode_Info.present = NR_Mode_Info_PR_fDD;
2239    DU_ALLOC(srvCellInfo->nR_Mode_Info.choice.fDD,\
2240          sizeof(FDD_Info_t));
2241    if(srvCellInfo->nR_Mode_Info.choice.fDD == NULLP)
2242    {
2243       return RFAILED;
2244    }
2245    if(fillNrFddInfo(&srvCellInfo->nR_Mode_Info))
2246       return RFAILED;
2247
2248    /*Measurement timing Config*/
2249    srvCellInfo->measurementTimingConfiguration.size = sizeof(uint8_t);
2250    DU_ALLOC(srvCellInfo->measurementTimingConfiguration.\
2251          buf,srvCellInfo->measurementTimingConfiguration.size);
2252    if(srvCellInfo->measurementTimingConfiguration.buf == NULLP)
2253    {
2254       return RFAILED;
2255    }
2256    srvCellInfo->measurementTimingConfiguration.\
2257          buf[0] = duCfgParam.srvdCellLst[0].duCellInfo.measTimeCfg;
2258
2259    return ROK;
2260 }
2261
2262 /*******************************************************************
2263  *
2264  * @brief Fills ServCellToModItem IE
2265  *
2266  * @details
2267  *
2268  *    Function : fillServCellToModItem
2269  *
2270  *    Functionality: Fills ServCellToModItem IE
2271  *
2272  * @params[in] Pointer to Served_Cells_To_Modify_Item_t *
2273  *
2274  * @return ROK     - success
2275  *         RFAILED - failure
2276  *
2277  *****************************************************************/
2278
2279 uint8_t fillServCellToModItem(Served_Cells_To_Modify_Item_t *modifyItem)
2280 {
2281    uint8_t ieIdx;
2282
2283    /*pLMN_Identity*/
2284    modifyItem->oldNRCGI.pLMN_Identity.size = 3*sizeof(uint8_t);
2285    DU_ALLOC(modifyItem->oldNRCGI.pLMN_Identity.buf,modifyItem->oldNRCGI.pLMN_Identity.size);
2286    if(modifyItem->oldNRCGI.pLMN_Identity.buf == NULLP)
2287    {
2288       return RFAILED;
2289    }
2290    buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrCgi.plmn,\
2291          modifyItem->oldNRCGI.pLMN_Identity.buf);
2292
2293    /*nRCellIdentity*/
2294    modifyItem->oldNRCGI.nRCellIdentity.size = 5*sizeof(uint8_t);
2295    DU_ALLOC(modifyItem->oldNRCGI.nRCellIdentity.buf,\
2296          modifyItem->oldNRCGI.nRCellIdentity.size);
2297    if(modifyItem->oldNRCGI.nRCellIdentity.buf == NULLP)
2298    {
2299       return RFAILED;
2300    }
2301    for(ieIdx = 0; ieIdx < modifyItem->oldNRCGI.nRCellIdentity.size-1; ieIdx++)
2302    {
2303       modifyItem->oldNRCGI.nRCellIdentity.buf[ieIdx] = 0;
2304    }
2305    modifyItem->oldNRCGI.nRCellIdentity.buf[4] = 16;
2306    modifyItem->oldNRCGI.nRCellIdentity.bits_unused = 4;
2307
2308    if(fillServedCellInfo(&modifyItem->served_Cell_Information))
2309       return RFAILED;
2310    else
2311       return ROK;
2312 }
2313
2314 /*******************************************************************
2315  *
2316  * @brief Builds ServCellToModList
2317  *
2318  * @details
2319  *
2320  *    Function : buildServCellToModList
2321  *
2322  *    Functionality: Builds the serv cell to Mod List
2323  *
2324  * @params[in] Pointer to Served_Cells_To_Modify_List_t *
2325  *
2326  * @return ROK     - success
2327  *         RFAILED - failure
2328  *
2329  *****************************************************************/
2330
2331 uint8_t buildServCellToModList(Served_Cells_To_Modify_List_t *cellsToModify)
2332 {
2333    uint8_t ieListCnt, ieIdx;
2334    Served_Cells_To_Modify_Item_t *modifyItem = NULLP;
2335
2336    ieListCnt = 1;
2337    cellsToModify->list.count = ieListCnt;
2338    cellsToModify->list.size = ieListCnt*sizeof(Served_Cells_To_Modify_ItemIEs_t *);
2339    DU_ALLOC(cellsToModify->list.array,cellsToModify->list.size);
2340    if(cellsToModify->list.array == NULLP)
2341    {
2342       return RFAILED;
2343    }
2344    for(ieIdx=0; ieIdx< ieListCnt; ieIdx++)
2345    {
2346       DU_ALLOC(cellsToModify->list.array[ieIdx],sizeof(Served_Cells_To_Modify_ItemIEs_t));
2347       if(cellsToModify->list.array[ieIdx] == NULLP)
2348       {
2349          return RFAILED;
2350       }
2351    }
2352    cellsToModify->list.array[0]->id = ProtocolIE_ID_id_Served_Cells_To_Modify_Item;
2353    cellsToModify->list.array[0]->criticality = Criticality_reject;
2354    cellsToModify->list.array[0]->value.present =\
2355       Served_Cells_To_Modify_ItemIEs__value_PR_Served_Cells_To_Modify_Item;
2356    modifyItem=&cellsToModify->list.array[0]->value.choice.Served_Cells_To_Modify_Item;
2357
2358    if(fillServCellToModItem(modifyItem))
2359       return RFAILED;
2360    else
2361       return ROK;
2362 }
2363
2364 /*******************************************************************
2365  *
2366  * @brief Builds and sends the DUConfigUpdate
2367  *
2368  * @details
2369  *
2370  *    Function : BuildAndSendDUConfigUpdate
2371  *
2372  *    Functionality: Constructs the DU Update message and sends
2373  *                   it to the CU through SCTP.
2374  *
2375  * @params[in] void **buf,Buffer to which encoded pattern is written into
2376  * @params[in] int *size,size of buffer
2377  *
2378  * @return ROK     - success
2379  *         RFAILED - failure
2380  *
2381  * ****************************************************************/
2382 uint8_t BuildAndSendDUConfigUpdate()
2383 {
2384    uint8_t ret, ieIdx, elementCnt;
2385    F1AP_PDU_t                 *f1apDuCfg = NULLP;
2386    GNBDUConfigurationUpdate_t *duCfgUpdate = NULLP;
2387    asn_enc_rval_t encRetVal;     /* Encoder return value */
2388    memset(&encRetVal, 0, sizeof(asn_enc_rval_t));
2389    ret= RFAILED;
2390
2391    while(true)
2392    {
2393       DU_LOG("\nINFO   -->  F1AP : Building DU config update\n");
2394       /* Allocate the memory for F1DuCfg */
2395       DU_ALLOC(f1apDuCfg, sizeof(F1AP_PDU_t));
2396       if(f1apDuCfg == NULLP)
2397       {
2398          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
2399          break;
2400       }
2401
2402       f1apDuCfg->present = F1AP_PDU_PR_initiatingMessage;
2403       DU_ALLOC(f1apDuCfg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
2404       if(f1apDuCfg->choice.initiatingMessage == NULLP)
2405       {
2406          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
2407          break;
2408       }
2409
2410       f1apDuCfg->choice.initiatingMessage->procedureCode = \
2411                                                            ProcedureCode_id_gNBDUConfigurationUpdate;
2412       f1apDuCfg->choice.initiatingMessage->criticality = Criticality_reject;
2413       f1apDuCfg->choice.initiatingMessage->value.present = \
2414                                                            InitiatingMessage__value_PR_GNBDUConfigurationUpdate;
2415       duCfgUpdate = &f1apDuCfg->choice.initiatingMessage->value.\
2416                     choice.GNBDUConfigurationUpdate;
2417       elementCnt = 3;
2418       duCfgUpdate->protocolIEs.list.count = elementCnt;
2419       duCfgUpdate->protocolIEs.list.size = \
2420                                            elementCnt * sizeof(GNBDUConfigurationUpdateIEs_t*);
2421
2422       /* Initialize the F1Setup members */
2423       DU_ALLOC(duCfgUpdate->protocolIEs.list.array,duCfgUpdate->protocolIEs.list.size);
2424       if(duCfgUpdate->protocolIEs.list.array == NULLP)
2425       {
2426          DU_LOG("ERROR  -->  F1AP : Memory allocation for F1RequestIEs failed");
2427          break;
2428       }
2429       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
2430       {
2431          DU_ALLOC(duCfgUpdate->protocolIEs.list.array[ieIdx],sizeof(GNBDUConfigurationUpdateIEs_t));
2432          if(duCfgUpdate->protocolIEs.list.array[ieIdx] == NULLP)
2433          {
2434             break;
2435          }
2436       }
2437
2438       /*TransactionID*/
2439       ieIdx = 0;
2440       duCfgUpdate->protocolIEs.list.array[ieIdx]->id=ProtocolIE_ID_id_TransactionID;
2441       duCfgUpdate->protocolIEs.list.array[ieIdx]->criticality= Criticality_reject;
2442       duCfgUpdate->protocolIEs.list.array[ieIdx]->value.present = \
2443          GNBDUConfigurationUpdateIEs__value_PR_TransactionID;
2444       duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.TransactionID = TRANS_ID;
2445
2446       /*Served Cell to Modify */
2447       ieIdx++;
2448       duCfgUpdate->protocolIEs.list.array[ieIdx]->id = \
2449                                                       ProtocolIE_ID_id_Served_Cells_To_Modify_List;
2450       duCfgUpdate->protocolIEs.list.array[ieIdx]->criticality =Criticality_reject;
2451       duCfgUpdate->protocolIEs.list.array[ieIdx]->value.present = \
2452          GNBDUConfigurationUpdateIEs__value_PR_Served_Cells_To_Modify_List;
2453       if(buildServCellToModList(&duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.\
2454          Served_Cells_To_Modify_List))
2455          break;
2456
2457       // NOTE :GNB DU SYS INFO:MIB AND SIB1 INFORMATION TO BE BUILT AND FILLED HERE
2458       /*GNB DU ID */
2459       ieIdx++;
2460       duCfgUpdate->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_ID;
2461       duCfgUpdate->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
2462       duCfgUpdate->protocolIEs.list.array[ieIdx]->value.present = \
2463         GNBDUConfigurationUpdateIEs__value_PR_GNB_DU_ID;
2464       duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.size = sizeof(uint8_t);
2465       DU_ALLOC(duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf,\
2466             duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.size);
2467       if(duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf == NULLP)
2468       {
2469          break;
2470       }
2471       duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf[0] = duCfgParam.duId;
2472
2473       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apDuCfg);
2474
2475       /* Encode the DU Config Update type as APER */
2476       memset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
2477       encBufSize = 0;
2478       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apDuCfg, PrepFinalEncBuf, encBuf);
2479
2480       /* Checking encode results */
2481       if(encRetVal.encoded == ENCODE_FAIL)
2482       {
2483          DU_LOG("ERROR  -->  F1AP : Could not encode DUConfigUpdate structure (at %s)\n",\
2484          encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
2485          break;
2486       }
2487       else
2488       {
2489          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for DUConfigUpdate\n");
2490          for(ieIdx =0; ieIdx < encBufSize; ieIdx++)
2491          {
2492             printf("%x",encBuf[ieIdx]);
2493          }
2494       }
2495       /* Sending msg */
2496       if(SendF1APMsg(DU_APP_MEM_REGION, DU_POOL) != ROK)
2497       {
2498          DU_LOG("\nERROR  -->  F1AP : Sending GNB-DU Config Update failed");
2499          break;
2500       }
2501
2502       ret = ROK;
2503       break;
2504    }
2505    FreeDUConfigUpdate(f1apDuCfg);
2506
2507    return ret;
2508 }
2509
2510
2511 /*******************************************************************
2512  *
2513  * @brief free the ULRRCMessageTransfer
2514  *
2515  * @details
2516  *
2517  *    Function : FreeULRRCMessageTransfer
2518  *
2519  *    Functionality: Deallocating the memory of variable allocated in
2520  *                      FreeULRRCMessageTransfer
2521  *
2522  * @params[in]
2523  *
2524  * @return ROK     - void
2525  *
2526  ******************************************************************/
2527 void FreeULRRCMessageTransfer( F1AP_PDU_t *f1apMsg)
2528 {
2529    uint8_t idx1;
2530    ULRRCMessageTransfer_t  *ulRRCMsg;
2531
2532    if(f1apMsg != NULLP)
2533    {
2534       if(f1apMsg->choice.initiatingMessage != NULLP)
2535       {
2536          ulRRCMsg = &f1apMsg->choice.initiatingMessage->value.choice.ULRRCMessageTransfer;
2537          if(ulRRCMsg->protocolIEs.list.array != NULLP)
2538          {
2539             for(idx1=0;idx1<ulRRCMsg->protocolIEs.list.count;idx1++)
2540             {
2541                if(ulRRCMsg->protocolIEs.list.array[idx1] != NULLP)
2542                {
2543                   if(ulRRCMsg->protocolIEs.list.array[idx1]->value.present ==
2544                         ULRRCMessageTransferIEs__value_PR_RRCContainer)
2545                   {
2546                      DU_FREE(ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.buf,
2547                            ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.size);
2548                   }
2549                   DU_FREE(ulRRCMsg->protocolIEs.list.array[idx1],sizeof(ULRRCMessageTransferIEs_t));
2550                }
2551             }
2552             DU_FREE(ulRRCMsg->protocolIEs.list.array,ulRRCMsg->protocolIEs.list.size );
2553          }
2554          DU_FREE(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
2555       }
2556       DU_FREE(f1apMsg,sizeof(F1AP_PDU_t));
2557    }
2558 }
2559 /*******************************************************************
2560  *
2561  * @brief Builds and sends the ULRRCMessageTransfer
2562  *
2563  * @details
2564  *
2565  *    Function : BuildAndSendULRRCMessageTransfer
2566  *
2567  *    Functionality: Constructs the UL RRC Message Transfer and sends
2568  *                   it to the CU through SCTP.
2569  *
2570  * @params[in]
2571  *
2572  * @return ROK     - success
2573  *         RFAILED - failure
2574  *
2575  * ****************************************************************/
2576 uint8_t BuildAndSendULRRCMessageTransfer(DuUeCb  ueCb, uint8_t lcId, \
2577       uint16_t msgLen, uint8_t *rrcMsg)
2578 {
2579    uint8_t   elementCnt =0;
2580    uint8_t   idx1 =0;
2581    uint8_t   idx =0;
2582    F1AP_PDU_t                   *f1apMsg = NULLP;
2583    ULRRCMessageTransfer_t       *ulRRCMsg = NULLP;
2584    asn_enc_rval_t               encRetVal;        /* Encoder return value */
2585    uint8_t ret =RFAILED;
2586
2587    memset(&encRetVal, 0, sizeof(asn_enc_rval_t));
2588
2589    while(true)
2590    {
2591       DU_LOG("\n INFO   -->  F1AP : Building UL RRC Message Transfer Message\n");
2592
2593       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
2594       if(f1apMsg == NULLP)
2595       {
2596          DU_LOG(" ERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
2597          break;
2598       }
2599       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
2600       DU_ALLOC(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
2601       if(f1apMsg->choice.initiatingMessage == NULLP)
2602       {
2603          DU_LOG(" ERROR  -->  F1AP : Memory allocation for      F1AP-PDU failed");
2604          break;
2605       }
2606       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_ULRRCMessageTransfer;
2607       f1apMsg->choice.initiatingMessage->criticality = Criticality_ignore;
2608       f1apMsg->choice.initiatingMessage->value.present = \
2609                                                          InitiatingMessage__value_PR_ULRRCMessageTransfer;
2610       ulRRCMsg =
2611          &f1apMsg->choice.initiatingMessage->value.choice.ULRRCMessageTransfer;
2612       elementCnt = 4;
2613       ulRRCMsg->protocolIEs.list.count = elementCnt;
2614       ulRRCMsg->protocolIEs.list.size = \
2615                                         elementCnt * sizeof(ULRRCMessageTransferIEs_t *);
2616
2617       /* Initialize the F1Setup members */
2618       DU_ALLOC(ulRRCMsg->protocolIEs.list.array, ulRRCMsg->protocolIEs.list.size);
2619       if(ulRRCMsg->protocolIEs.list.array == NULLP)
2620       {
2621          DU_LOG(" ERROR  -->  F1AP : Memory allocation for UL RRC MessageTransferIEs failed");
2622          break;
2623       }
2624       for(idx=0; idx<elementCnt; idx++)
2625       {
2626          DU_ALLOC(ulRRCMsg->protocolIEs.list.array[idx],sizeof(ULRRCMessageTransferIEs_t));
2627          if(ulRRCMsg->protocolIEs.list.array[idx] == NULLP)
2628          {
2629             break;
2630          }
2631       }
2632
2633       idx1 = 0;
2634
2635       /*GNB CU UE F1AP ID*/
2636       ulRRCMsg->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
2637       ulRRCMsg->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
2638       ulRRCMsg->protocolIEs.list.array[idx1]->value.present = \
2639                                                               ULRRCMessageTransferIEs__value_PR_GNB_CU_UE_F1AP_ID;
2640       ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.GNB_CU_UE_F1AP_ID = ueCb.gnbCuUeF1apId;
2641
2642       /*GNB DU UE F1AP ID*/
2643       idx1++;
2644       ulRRCMsg->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
2645       ulRRCMsg->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
2646       ulRRCMsg->protocolIEs.list.array[idx1]->value.present = \
2647                                                               ULRRCMessageTransferIEs__value_PR_GNB_DU_UE_F1AP_ID;
2648       ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.GNB_DU_UE_F1AP_ID = ueCb.gnbDuUeF1apId;
2649
2650       /*SRBID*/
2651       idx1++;
2652       ulRRCMsg->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_SRBID;
2653       ulRRCMsg->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
2654       ulRRCMsg->protocolIEs.list.array[idx1]->value.present = \
2655                                                               ULRRCMessageTransferIEs__value_PR_SRBID;
2656       ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.SRBID = lcId;
2657
2658       /*RRCContainer*/
2659       idx1++;
2660       ulRRCMsg->protocolIEs.list.array[idx1]->id  = ProtocolIE_ID_id_RRCContainer;
2661       ulRRCMsg->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
2662       ulRRCMsg->protocolIEs.list.array[idx1]->value.present = \
2663                                                               ULRRCMessageTransferIEs__value_PR_RRCContainer;
2664       ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.size = msgLen;
2665       DU_ALLOC(ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.buf,
2666             ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.size)
2667       if(!ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.buf)
2668       {
2669          DU_LOG(" ERROR  -->  F1AP : Memory allocation for BuildAndSendULRRCMessageTransfer failed");
2670          break;
2671       }
2672       memset(ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.buf, 0, msgLen);
2673       memcpy(ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.buf, \
2674             rrcMsg, ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.size);
2675
2676       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
2677
2678       /* Encode the F1SetupRequest type as APER */
2679       memset(encBuf, 0, ENC_BUF_MAX_LEN);
2680       encBufSize = 0;
2681       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
2682             encBuf);
2683       /* Encode results */
2684       if(encRetVal.encoded == ENCODE_FAIL)
2685       {
2686          DU_LOG( "\nERROR  -->  F1AP : Could not encode ULRRCMessageTransfer structure (at %s)\n",\
2687                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
2688          break;
2689       }
2690       else
2691       {
2692          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for ULRRCMessageTransfer\n");
2693          for(int i=0; i< encBufSize; i++)
2694          {
2695             printf("%x",encBuf[i]);
2696          }
2697       }
2698
2699       /* Sending  msg  */
2700       if(SendF1APMsg(DU_APP_MEM_REGION,DU_POOL) !=      ROK)
2701       {
2702          DU_LOG("\nERROR  -->   F1AP : Sending  UL RRC Message Transfer Failed");
2703          break;
2704       }
2705       ret = ROK;
2706       break;
2707    }
2708    FreeULRRCMessageTransfer(f1apMsg);
2709
2710    return ret;
2711 }/* End of BuildAndSendULRRCMessageTransfer*/
2712
2713 /*******************************************************************
2714  *
2715  * @brief Builds tag config
2716  *
2717  * @details
2718  *
2719  *    Function : BuildTagConfig
2720  *
2721  *    Functionality: Builds tag config in MacCellGroupConfig
2722  *
2723  * @params[in] TAG_Config *tag_Config
2724  *
2725  * @return ROK     - success
2726  *         RFAILED - failure
2727  *
2728  * ****************************************************************/
2729 uint8_t BuildTagConfig(struct TAG_Config *tagConfig)
2730 {
2731    struct TAG_Config__tag_ToAddModList *tagList;
2732    uint8_t                     idx, elementCnt;
2733
2734    tagConfig->tag_ToReleaseList = NULLP;
2735    tagConfig->tag_ToAddModList = NULLP;
2736    DU_ALLOC(tagConfig->tag_ToAddModList, sizeof(struct TAG_Config__tag_ToAddModList));
2737    if(!tagConfig->tag_ToAddModList)
2738    {
2739       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildTagConfig");
2740       return RFAILED;
2741    }
2742
2743    elementCnt = 1; //ODU_VALUE_ONE;
2744    tagList = tagConfig->tag_ToAddModList;
2745    tagList->list.count = elementCnt;
2746    tagList->list.size  =  elementCnt * sizeof(struct TAG *);
2747
2748    tagList->list.array = NULLP;
2749    DU_ALLOC(tagList->list.array, tagList->list.size);
2750    if(!tagList->list.array)
2751    {
2752       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildTagConfig");
2753       return RFAILED;
2754    }
2755
2756    for(idx=0; idx<tagList->list.count; idx++)
2757    {
2758       tagList->list.array[idx] = NULLP;
2759       DU_ALLOC(tagList->list.array[idx], sizeof(struct TAG));
2760       if(!tagList->list.array[idx])
2761       {
2762          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildTagConfig");
2763          return RFAILED;
2764       }
2765    }
2766
2767    idx = 0;
2768    tagList->list.array[idx]->tag_Id = TAG_ID;
2769    tagList->list.array[idx]->timeAlignmentTimer = TIME_ALIGNMENT_TMR;
2770
2771    return ROK;
2772 }
2773
2774 /*******************************************************************
2775  *
2776  * @brief Builds PHR Config
2777  *
2778  * @details
2779  *
2780  *    Function : BuildPhrConfig
2781  *
2782  *    Functionality: Builds phrConfig in MacCellGroupConfig
2783  *
2784  * @params[in] PHR Config *
2785  *
2786  * @return ROK     - success
2787  *         RFAILED - failure
2788  *
2789  * ****************************************************************/
2790 uint8_t BuildPhrConfig(struct MAC_CellGroupConfig__phr_Config *phrConfig)
2791 {
2792
2793    phrConfig->present = MAC_CellGroupConfig__phr_Config_PR_setup;
2794    phrConfig->choice.setup = NULLP;
2795    DU_ALLOC(phrConfig->choice.setup, sizeof(struct PHR_Config));
2796    if(!phrConfig->choice.setup)
2797    {
2798       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildPhrConfig");
2799       return RFAILED;
2800    }
2801
2802    phrConfig->choice.setup->phr_PeriodicTimer        = PHR_PERIODIC_TMR;
2803    phrConfig->choice.setup->phr_ProhibitTimer        = PHR_PROHIBHIT_TMR;
2804    phrConfig->choice.setup->phr_Tx_PowerFactorChange = PHR_PWR_FACTOR_CHANGE;
2805    phrConfig->choice.setup->multiplePHR              = false;
2806    phrConfig->choice.setup->dummy                    = false;
2807    phrConfig->choice.setup->phr_Type2OtherCell       = false;
2808    phrConfig->choice.setup->phr_ModeOtherCG          = PHR_MODE_OTHER_CG;
2809
2810    return ROK;
2811 }
2812
2813 /*******************************************************************
2814  *
2815  * @brief Builds BSR Config
2816  *
2817  * @details
2818  *
2819  *    Function : BuildBsrConfig
2820  *
2821  *    Functionality: Builds BuildBsrConfig in MacCellGroupConfig
2822  *
2823  * @params[in] BSR_Config *bsrConfig
2824  *
2825  * @return ROK     - success
2826  *         RFAILED - failure
2827  *
2828  * ****************************************************************/
2829 uint8_t BuildBsrConfig(struct BSR_Config *bsrConfig)
2830 {
2831    bsrConfig->periodicBSR_Timer = PERIODIC_BSR_TMR;
2832    bsrConfig->retxBSR_Timer     = RETX_BSR_TMR;
2833    bsrConfig->logicalChannelSR_DelayTimer = NULLP;
2834
2835    return ROK;
2836 }
2837
2838 /*******************************************************************
2839  *
2840  * @brief Builds scheduling request config
2841  *
2842  * @details
2843  *
2844  *    Function : BuildSchedulingReqConfig
2845  *
2846  *    Functionality: Builds BuildSchedulingReqConfig in MacCellGroupConfig
2847  *
2848  * @params[in] SchedulingRequestConfig *schedulingRequestConfig
2849  *
2850  * @return ROK     - success
2851  *         RFAILED - failure
2852  *
2853  * ****************************************************************/
2854 uint8_t BuildSchedulingReqConfig(struct SchedulingRequestConfig *schedulingRequestConfig)
2855 {
2856    struct SchedulingRequestConfig__schedulingRequestToAddModList *schReqList;
2857    uint8_t                     idx, elementCnt;
2858
2859    schedulingRequestConfig->schedulingRequestToAddModList = NULLP;
2860    DU_ALLOC(schedulingRequestConfig->schedulingRequestToAddModList,
2861          sizeof(struct SchedulingRequestConfig__schedulingRequestToAddModList));
2862    if(!schedulingRequestConfig->schedulingRequestToAddModList)
2863    {
2864       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSchedulingReqConfig");
2865       return RFAILED;
2866    }
2867
2868    elementCnt = 1; //ODU_VALUE_ONE;
2869    schReqList = schedulingRequestConfig->schedulingRequestToAddModList;
2870    schReqList->list.count = elementCnt;
2871    schReqList->list.size  = elementCnt * sizeof(struct SchedulingRequestToAddMod *);
2872
2873    schReqList->list.array = NULLP;
2874    DU_ALLOC(schReqList->list.array, schReqList->list.size);
2875    if(!schReqList->list.array)
2876    {
2877       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSchedulingReqConfig");
2878       return RFAILED;
2879    }
2880
2881    for(idx=0;idx<schReqList->list.count; idx++)
2882    {
2883       schReqList->list.array[idx] = NULLP;
2884       DU_ALLOC(schReqList->list.array[idx], sizeof(struct SchedulingRequestToAddMod));
2885       if(!schReqList->list.array[idx])
2886       {
2887          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSchedulingReqConfig");
2888          return RFAILED;
2889       }
2890    }
2891
2892    idx = 0;
2893    schReqList->list.array[idx]->schedulingRequestId = SCH_REQ_ID;
2894
2895    schReqList->list.array[idx]->sr_ProhibitTimer = NULLP;
2896    DU_ALLOC(schReqList->list.array[idx]->sr_ProhibitTimer, sizeof(long));
2897    if(!schReqList->list.array[idx]->sr_ProhibitTimer)
2898    {
2899       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSchedulingReqConfig");
2900       return RFAILED;
2901    }
2902    *(schReqList->list.array[idx]->sr_ProhibitTimer) = SR_PROHIBIT_TMR;
2903    schReqList->list.array[idx]->sr_TransMax = SR_TRANS_MAX;
2904    schedulingRequestConfig->schedulingRequestToReleaseList = NULLP;
2905
2906    return ROK;
2907 }
2908
2909 /*******************************************************************
2910  *
2911  * @brief Builds RLC Config
2912  *
2913  * @details
2914  *
2915  *    Function : BuildRlcConfig
2916  *
2917  *    Functionality: Builds RLC Config in BuildRlcBearerToAddModList
2918  *
2919  * @params[in] RLC_Config *rlcConfig
2920  *
2921  * @return ROK     - success
2922  *         RFAILED - failure
2923  *
2924  * ****************************************************************/
2925 uint8_t BuildRlcConfig(struct RLC_Config *rlcConfig)
2926 {
2927
2928    rlcConfig->present = RLC_Config_PR_am;
2929
2930    rlcConfig->choice.am = NULLP;
2931    DU_ALLOC(rlcConfig->choice.am, sizeof(struct RLC_Config__am));
2932    if(!rlcConfig->choice.am)
2933    {
2934       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfig");
2935       return RFAILED;
2936    }
2937
2938    /* UL */
2939    rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength = NULLP;
2940    DU_ALLOC(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
2941    if(!rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength)
2942    {
2943       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfig");
2944       return RFAILED;
2945    }
2946    *(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength) = SN_FIELD_LEN;
2947    rlcConfig->choice.am->ul_AM_RLC.t_PollRetransmit  = T_POLL_RETRANSMIT;
2948    rlcConfig->choice.am->ul_AM_RLC.pollPDU           = POLL_PDU;
2949    rlcConfig->choice.am->ul_AM_RLC.pollByte          = POLL_BYTE;
2950    rlcConfig->choice.am->ul_AM_RLC.maxRetxThreshold  = MAX_RETX_THRESHOLD;
2951
2952    /* DL */
2953    rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength = NULLP;
2954    DU_ALLOC(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
2955    if(!rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength)
2956    {
2957       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfig");
2958       return RFAILED;
2959    }
2960    *(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength) = SN_FIELD_LEN;
2961    rlcConfig->choice.am->dl_AM_RLC.t_Reassembly      = T_REASSEMBLY;
2962    rlcConfig->choice.am->dl_AM_RLC.t_StatusProhibit  = T_STATUS_PROHIBHIT;
2963
2964    return ROK;
2965 }
2966
2967 /*******************************************************************
2968  *
2969  * @brief Builds MAC LC Config
2970  *
2971  * @details
2972  *
2973  *    Function : BuildMacLCConfig
2974  *
2975  *    Functionality: Builds MAC LC Config in BuildRlcBearerToAddModList
2976  *
2977  * @params[in] struct LogicalChannelConfig macLcConfig
2978  *
2979  * @return ROK     - success
2980  *         RFAILED - failure
2981  *
2982  * ****************************************************************/
2983 uint8_t BuildMacLCConfig(struct LogicalChannelConfig *macLcConfig)
2984 {
2985
2986    macLcConfig->ul_SpecificParameters = NULLP;
2987    DU_ALLOC(macLcConfig->ul_SpecificParameters, sizeof(struct LogicalChannelConfig__ul_SpecificParameters));
2988    if(!macLcConfig->ul_SpecificParameters)
2989    {
2990       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacLCConfig");
2991       return RFAILED;
2992    }
2993
2994    macLcConfig->ul_SpecificParameters->priority = MAC_LC_PRIORITY;
2995    macLcConfig->ul_SpecificParameters->prioritisedBitRate =     PRIORTISIED_BIT_RATE;
2996    macLcConfig->ul_SpecificParameters->bucketSizeDuration =     BUCKET_SIZE_DURATION;
2997    macLcConfig->ul_SpecificParameters->allowedServingCells = NULLP;
2998    macLcConfig->ul_SpecificParameters->allowedSCS_List = NULLP;
2999    macLcConfig->ul_SpecificParameters->maxPUSCH_Duration = NULLP;
3000    macLcConfig->ul_SpecificParameters->configuredGrantType1Allowed = NULLP;
3001
3002    macLcConfig->ul_SpecificParameters->logicalChannelGroup = NULLP;
3003    DU_ALLOC(macLcConfig->ul_SpecificParameters->logicalChannelGroup,    sizeof(long));
3004    if(!macLcConfig->ul_SpecificParameters->logicalChannelGroup)
3005    {
3006       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacLCConfig");
3007       return RFAILED;
3008    }
3009    *(macLcConfig->ul_SpecificParameters->logicalChannelGroup) = LC_GRP;
3010
3011    macLcConfig->ul_SpecificParameters->schedulingRequestID = NULLP;
3012    DU_ALLOC(macLcConfig->ul_SpecificParameters->schedulingRequestID,    sizeof(SchedulingRequestId_t));
3013    if(!macLcConfig->ul_SpecificParameters->schedulingRequestID)
3014    {
3015       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacLCConfig");
3016       return RFAILED;
3017    }
3018    *(macLcConfig->ul_SpecificParameters->schedulingRequestID) = SCH_REQ_ID;
3019
3020    macLcConfig->ul_SpecificParameters->logicalChannelSR_Mask = false;
3021    macLcConfig->ul_SpecificParameters->logicalChannelSR_DelayTimerApplied = false;
3022    macLcConfig->ul_SpecificParameters->bitRateQueryProhibitTimer = NULLP;
3023
3024    return ROK;
3025 }
3026
3027 /*******************************************************************
3028  *
3029  * @brief Builds RLC Bearer to Add/Mod list
3030  *
3031  * @details
3032  *
3033  *    Function :BuildRlcBearerToAddModList
3034  *
3035  *    Functionality: Builds RLC Bearer to Add/Mod list in DuToCuRrcContainer
3036  *
3037  * @params[in] rlc_BearerToAddModList
3038  *
3039  * @return ROK     - success
3040  *         RFAILED - failure
3041  *
3042  * ****************************************************************/
3043 uint8_t BuildRlcBearerToAddModList(struct CellGroupConfigRrc__rlc_BearerToAddModList *rlcBearerList)
3044 {
3045    uint8_t                     idx, elementCnt;
3046
3047    elementCnt = 1;
3048    rlcBearerList->list.count = elementCnt;
3049    rlcBearerList->list.size  = elementCnt * sizeof(struct RLC_BearerConfig *);
3050
3051    rlcBearerList->list.array = NULLP;
3052    DU_ALLOC(rlcBearerList->list.array, rlcBearerList->list.size);
3053    if(!rlcBearerList->list.array)
3054    {
3055       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
3056       return RFAILED;
3057    }
3058
3059    for(idx=0; idx<rlcBearerList->list.count; idx++)
3060    {
3061       rlcBearerList->list.array[idx] = NULLP;
3062       DU_ALLOC(rlcBearerList->list.array[idx], sizeof(struct RLC_BearerConfig));
3063       if(!rlcBearerList->list.array[idx])
3064       {
3065          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
3066          return RFAILED;
3067       }
3068    }
3069
3070    idx = 0;
3071    rlcBearerList->list.array[idx]->logicalChannelIdentity = SRB1_LCID;
3072
3073    DU_ALLOC(rlcBearerList->list.array[idx]->servedRadioBearer, \
3074       sizeof(struct RLC_BearerConfig__servedRadioBearer));
3075    if(!rlcBearerList->list.array[idx]->servedRadioBearer)
3076    {
3077       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
3078       return RFAILED;
3079    }
3080
3081    rlcBearerList->list.array[idx]->servedRadioBearer->present = \
3082       RLC_BearerConfig__servedRadioBearer_PR_srb_Identity;
3083    rlcBearerList->list.array[idx]->servedRadioBearer->choice.srb_Identity = \
3084       SRB1_LCID;
3085
3086    rlcBearerList->list.array[idx]->reestablishRLC = NULLP;
3087    rlcBearerList->list.array[idx]->rlc_Config = NULLP;
3088    DU_ALLOC(rlcBearerList->list.array[idx]->rlc_Config, sizeof(struct RLC_Config));
3089    if(!rlcBearerList->list.array[idx]->rlc_Config)
3090    {
3091       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
3092       return RFAILED;
3093    }
3094
3095    if(BuildRlcConfig(rlcBearerList->list.array[idx]->rlc_Config) != ROK)
3096    {
3097       DU_LOG("\nERROR  -->  F1AP : BuildRlcConfig failed");
3098       return RFAILED;
3099    }
3100
3101    rlcBearerList->list.array[idx]->mac_LogicalChannelConfig = NULLP;
3102    DU_ALLOC(rlcBearerList->list.array[idx]->mac_LogicalChannelConfig, \
3103       sizeof(struct LogicalChannelConfig));
3104    if(!rlcBearerList->list.array[idx]->mac_LogicalChannelConfig)
3105    {
3106       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
3107       return RFAILED;
3108    }
3109
3110    if(BuildMacLCConfig(rlcBearerList->list.array[idx]->mac_LogicalChannelConfig) != ROK)
3111    {
3112       DU_LOG("\nERROR  -->  F1AP : BuildMacLCConfig failed");
3113       return RFAILED;
3114    }
3115
3116    return ROK;
3117 }
3118
3119 /*******************************************************************
3120  *
3121  * @brief Build Control resource set to add/modify list
3122  *
3123  * @details
3124  *
3125  *    Function : BuildControlRSetToAddModList
3126  *
3127  *    Functionality: Build Control resource set to add/modify list
3128  *
3129  * @params[in]
3130  * struct PDCCH_Config__controlResourceSetToAddModList *controlRSetList
3131  *
3132  * @return ROK     - success
3133  *         RFAILED - failure
3134  *
3135  * ****************************************************************/
3136    uint8_t BuildControlRSetToAddModList
3137 (
3138  struct PDCCH_Config__controlResourceSetToAddModList *controlRSetList
3139  )
3140 {
3141    uint8_t idx;
3142    uint8_t elementCnt;
3143    uint8_t numBytes, bitsUnused;
3144    struct ControlResourceSet *controlRSet;
3145    uint8_t freqDomainResource[FREQ_DOM_RSRC_SIZE] = {0};
3146    uint8_t coreset0EndPrb, coreset1StartPrb, coreset1NumPrb;
3147
3148
3149    elementCnt = 1;
3150    controlRSetList->list.count = elementCnt;
3151    controlRSetList->list.size = \
3152                                 elementCnt * sizeof(struct ControlResourceSet *);
3153
3154    controlRSetList->list.array = NULLP;
3155    DU_ALLOC(controlRSetList->list.array, controlRSetList->list.size);
3156    if(!controlRSetList->list.array)
3157    {
3158       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3159       return RFAILED;
3160    }
3161
3162    for(idx = 0; idx < elementCnt; idx++)
3163    {
3164       controlRSetList->list.array[idx] = NULLP;
3165       DU_ALLOC(controlRSetList->list.array[idx], sizeof(struct ControlResourceSet));
3166       if(!controlRSetList->list.array[idx])
3167       {
3168          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3169          return RFAILED;
3170       }
3171    }
3172
3173    idx=0;
3174    controlRSet = controlRSetList->list.array[idx];
3175
3176    controlRSet->controlResourceSetId = PDCCH_CTRL_RSRC_SET_ONE_ID;
3177
3178    /* size 6 bytes
3179     * 3 LSBs unsued
3180     * Bit string stored ff0000000000
3181     */
3182    numBytes = 6;
3183    bitsUnused = 3;
3184    controlRSet->frequencyDomainResources.size = numBytes * sizeof(uint8_t);
3185
3186    controlRSet->frequencyDomainResources.buf = NULLP;
3187    DU_ALLOC(controlRSet->frequencyDomainResources.buf, \
3188          controlRSet->frequencyDomainResources.size);
3189    if(!controlRSet->frequencyDomainResources.buf)
3190    {
3191       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3192       return RFAILED;
3193    }
3194
3195    memset(controlRSet->frequencyDomainResources.buf, 0, FREQ_DOM_RSRC_SIZE);
3196    coreset0EndPrb = CORESET0_END_PRB;
3197    coreset1StartPrb = coreset0EndPrb + 6;
3198    coreset1NumPrb = CORESET1_NUM_PRB;
3199    /* calculate the PRBs */
3200    freqDomRscAllocType0(((coreset1StartPrb)/6), (coreset1NumPrb/6), freqDomainResource);
3201    memcpy(controlRSet->frequencyDomainResources.buf, freqDomainResource, FREQ_DOM_RSRC_SIZE);
3202    controlRSet->frequencyDomainResources.bits_unused = bitsUnused;
3203
3204    controlRSet->duration = PDCCH_CTRL_RSRC_SET_ONE_DURATION;
3205    controlRSet->cce_REG_MappingType.present = \
3206                                               ControlResourceSet__cce_REG_MappingType_PR_nonInterleaved;
3207
3208    controlRSet->precoderGranularity = PDCCH_CTRL_RSRC_SET_ONE_PRECOD_GRANULARITY;
3209    controlRSet->tci_StatesPDCCH_ToAddList = NULLP;
3210    controlRSet->tci_StatesPDCCH_ToReleaseList = NULLP;
3211    controlRSet->tci_PresentInDCI = NULLP;
3212 #if 0
3213    uint8_t tciStateIdx;
3214
3215    DU_ALLOC(controlRset->tci_StatesPDCCH_ToAddList, \
3216          sizeof(struct ControlResourceSet__tci_StatesPDCCH_ToAddList));
3217    if(!controlRset->tci_StatesPDCCH_ToAddList)
3218    {
3219       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3220       return RFAILED;
3221    }
3222
3223    elementCnt = 1;
3224    controlRset->tci_StatesPDCCH_ToAddList->list.count = elementCnt;
3225    controlRset->tci_StatesPDCCH_ToAddList->list.size = elementCnt * sizeof(TCI_StateId_t *);
3226    DU_ALLOC(controlRset->tci_StatesPDCCH_ToAddList->list.array, \
3227          controlRset->tci_StatesPDCCH_ToAddList->list.size)
3228       if(!controlRset->tci_StatesPDCCH_ToAddList->list.array)
3229       {
3230          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3231          return RFAILED;
3232       }
3233
3234    for(tciStateIdx = 0; tciStateIdx <elementCntl; tciStateIdx++)
3235    {
3236       DU_ALLOC(controlRset->tci_StatesPDCCH_ToAddList->list.array[tciStateIdx], sizeof(TCI_StateId_t));
3237       if(!controlRset->tci_StatesPDCCH_ToAddList->list.array[tciStateIdx])
3238       {
3239          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3240          return RFAILED;
3241       }
3242    }
3243
3244    tciStateIdx = 0;
3245    /* TODO */
3246    *(controlRset->tci_StatesPDCCH_ToAddList->list.array[tciStateIdx]);
3247
3248    DU_ALLOC(controlRset->tci_PresentInDCI, sizeof(long));
3249    if(!controlRset->tci_PresentInDCI)
3250    {
3251       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3252       return RFAILED;
3253    }
3254    /* TODO */
3255    *(controlRset->tci_PresentInDCI);
3256 #endif
3257
3258    controlRSet->pdcch_DMRS_ScramblingID = NULLP;
3259    DU_ALLOC(controlRSet->pdcch_DMRS_ScramblingID, sizeof(long));
3260    if(!controlRSet->pdcch_DMRS_ScramblingID)
3261    {
3262       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3263       return RFAILED;
3264    }
3265    *(controlRSet->pdcch_DMRS_ScramblingID) = SCRAMBLING_ID;
3266
3267    return ROK;
3268 } /* End BuildControlRSetToAddModList */
3269
3270 /*******************************************************************
3271  *
3272  * @brief Build search space to add/modify list
3273  *
3274  * @details
3275  *
3276  *    Function : BuildSearchSpcToAddModList
3277  *
3278  *    Functionality: Build search space to add/modify list
3279  *
3280  * @params[in]
3281  * @return ROK     - success
3282  *         RFAILED - failure
3283  *
3284  * ****************************************************************/
3285    uint8_t BuildSearchSpcToAddModList
3286 (
3287  struct PDCCH_Config__searchSpacesToAddModList *searchSpcList
3288  )
3289 {
3290    uint8_t idx;
3291    uint8_t numBytes;
3292    uint8_t byteIdx;
3293    uint8_t bitsUnused;
3294    uint8_t elementCnt;
3295    struct SearchSpace *searchSpc;
3296
3297    elementCnt = 1;
3298    searchSpcList->list.count = elementCnt;
3299    searchSpcList->list.size = elementCnt * sizeof(struct SearchSpace *);
3300
3301    searchSpcList->list.array = NULLP;
3302    DU_ALLOC(searchSpcList->list.array, searchSpcList->list.size);
3303    if(!searchSpcList->list.array)
3304    {
3305       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3306       return RFAILED;
3307    }
3308
3309    for(idx = 0; idx < elementCnt; idx++)
3310    {
3311       searchSpcList->list.array[idx] = NULLP;
3312       DU_ALLOC(searchSpcList->list.array[idx], sizeof(struct SearchSpace));
3313       if(!searchSpcList->list.array[idx])
3314       {
3315          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3316          return RFAILED;
3317       }
3318    }
3319
3320    idx = 0;
3321    searchSpc = searchSpcList->list.array[idx];
3322
3323    searchSpc->searchSpaceId = PDCCH_SRCH_SPC_TWO_ID;
3324
3325    searchSpc->controlResourceSetId = NULLP;
3326    DU_ALLOC(searchSpc->controlResourceSetId, sizeof(ControlResourceSetId_t));
3327    if(!searchSpc->controlResourceSetId)
3328    {
3329       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3330       return RFAILED;
3331    }
3332    *(searchSpc->controlResourceSetId) = PDCCH_CTRL_RSRC_SET_ONE_ID;
3333
3334    searchSpc->monitoringSlotPeriodicityAndOffset = NULLP;
3335    DU_ALLOC(searchSpc->monitoringSlotPeriodicityAndOffset, \
3336          sizeof(struct SearchSpace__monitoringSlotPeriodicityAndOffset));
3337    if(!searchSpc->monitoringSlotPeriodicityAndOffset)
3338    {
3339       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3340       return RFAILED;
3341    }
3342    searchSpc->monitoringSlotPeriodicityAndOffset->present = \
3343                                                             SearchSpace__monitoringSlotPeriodicityAndOffset_PR_sl1;
3344
3345    searchSpc->duration = NULLP;
3346    searchSpc->monitoringSymbolsWithinSlot = NULLP;
3347    DU_ALLOC(searchSpc->monitoringSymbolsWithinSlot, sizeof(BIT_STRING_t));
3348    if(!searchSpc->monitoringSymbolsWithinSlot)
3349    {
3350       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3351       return RFAILED;
3352    }
3353
3354    /* Values taken from reference logs :
3355     * size 2 bytes
3356     * 2 LSBs unsued
3357     * Bit string stores 8000
3358     */
3359    numBytes = 2;
3360    bitsUnused = 2;
3361
3362    searchSpc->monitoringSymbolsWithinSlot->size = numBytes * sizeof(uint8_t);
3363    searchSpc->monitoringSymbolsWithinSlot->buf = NULLP;
3364    DU_ALLOC(searchSpc->monitoringSymbolsWithinSlot->buf, \
3365          searchSpc->monitoringSymbolsWithinSlot->size);
3366    if(!searchSpc->monitoringSymbolsWithinSlot->buf)
3367    {
3368       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3369       return RFAILED;
3370    }
3371
3372    byteIdx = 0;
3373    searchSpc->monitoringSymbolsWithinSlot->buf[byteIdx++] = \
3374                                                             PDCCH_SYMBOL_WITHIN_SLOT /* setting MSB to 128 i.e. 0x80 */;
3375    searchSpc->monitoringSymbolsWithinSlot->buf[byteIdx++] = 0;
3376    searchSpc->monitoringSymbolsWithinSlot->bits_unused = bitsUnused;
3377
3378    searchSpc->nrofCandidates = NULLP;
3379    DU_ALLOC(searchSpc->nrofCandidates, sizeof(struct SearchSpace__nrofCandidates));
3380    if(!searchSpc->nrofCandidates)
3381    {
3382       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3383       return RFAILED;
3384    }
3385
3386    searchSpc->nrofCandidates->aggregationLevel1 = \
3387                                                   PDCCH_SRCH_SPC_TWO_AGG_LVL1_CANDIDATE;
3388    searchSpc->nrofCandidates->aggregationLevel2 = \
3389                                                   PDCCH_SRCH_SPC_TWO_AGG_LVL2_CANDIDATE;
3390    searchSpc->nrofCandidates->aggregationLevel4 = \
3391                                                   PDCCH_SRCH_SPC_TWO_AGG_LVL4_CANDIDATE;
3392    searchSpc->nrofCandidates->aggregationLevel8 = \
3393                                                   PDCCH_SRCH_SPC_TWO_AGG_LVL8_CANDIDATE;
3394    searchSpc->nrofCandidates->aggregationLevel16 = \
3395                                                    PDCCH_SRCH_SPC_TWO_AGG_LVL16_CANDIDATE;
3396
3397    searchSpc->searchSpaceType = NULLP;
3398    DU_ALLOC(searchSpc->searchSpaceType, sizeof(struct SearchSpace__searchSpaceType));
3399    if(!searchSpc->searchSpaceType)
3400    {
3401       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3402       return RFAILED;
3403    }
3404
3405    searchSpc->searchSpaceType->present = SearchSpace__searchSpaceType_PR_ue_Specific;
3406
3407    searchSpc->searchSpaceType->choice.ue_Specific = NULLP;
3408    DU_ALLOC(searchSpc->searchSpaceType->choice.ue_Specific, \
3409          sizeof(struct SearchSpace__searchSpaceType__ue_Specific));
3410    if(!searchSpc->searchSpaceType->choice.ue_Specific)
3411    {
3412       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3413       return RFAILED;
3414    }
3415    searchSpc->searchSpaceType->choice.ue_Specific->dci_Formats = \
3416                                                                  PDCCH_SRCH_SPC_TWO_UE_SPEC_DCI_FORMAT;
3417
3418    return ROK;
3419 }/* End BuildSearchSpcToAddModList */
3420
3421 /*******************************************************************
3422  *
3423  * @brief Builds BWP DL dedicated PDCCH config
3424  *
3425  * @details
3426  *
3427  *    Function : BuildBWPDlDedPdcchCfg
3428  *
3429  *    Functionality: Builds BWP DL dedicated PDCCH config
3430  *
3431  * @params[in] struct PDCCH_Config *pdcchCfg
3432  *
3433  * @return ROK     - success
3434  *         RFAILED - failure
3435  *
3436  * ****************************************************************/
3437 uint8_t BuildBWPDlDedPdcchCfg(struct PDCCH_Config *pdcchCfg)
3438 {
3439    pdcchCfg->controlResourceSetToAddModList = NULLP;
3440    DU_ALLOC(pdcchCfg->controlResourceSetToAddModList, \
3441          sizeof(struct PDCCH_Config__controlResourceSetToAddModList));
3442    if(!pdcchCfg->controlResourceSetToAddModList)
3443    {
3444       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdcchCfg");
3445       return RFAILED;
3446    }
3447
3448    if(BuildControlRSetToAddModList(pdcchCfg->controlResourceSetToAddModList) != ROK)
3449    {
3450       return RFAILED;
3451    }
3452
3453    pdcchCfg->controlResourceSetToReleaseList = NULLP;
3454
3455    pdcchCfg->searchSpacesToAddModList = NULLP;
3456    DU_ALLOC(pdcchCfg->searchSpacesToAddModList, \
3457          sizeof(struct PDCCH_Config__searchSpacesToAddModList));
3458    if(!pdcchCfg->searchSpacesToAddModList)
3459    {
3460       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdcchCfg");
3461       return RFAILED;
3462    }
3463
3464    if(BuildSearchSpcToAddModList(pdcchCfg->searchSpacesToAddModList) != ROK)
3465    {
3466       return RFAILED;
3467    }
3468
3469    pdcchCfg->searchSpacesToReleaseList = NULLP;
3470    pdcchCfg->downlinkPreemption = NULLP;
3471    pdcchCfg->tpc_PUSCH = NULLP;
3472    pdcchCfg->tpc_PUCCH = NULLP;
3473    pdcchCfg->tpc_SRS = NULLP;
3474
3475    return ROK;
3476 }
3477
3478 /*******************************************************************
3479  *
3480  * @brief Builds DMRS DL PDSCH Mapping type A
3481  *
3482  * @details
3483  *
3484  *    Function : BuildDMRSDLPdschMapTypeA
3485  *
3486  *    Functionality: Builds DMRS DL PDSCH Mapping type A
3487  *
3488  * @params[in]
3489  * struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA *dmrsDlCfg
3490  * @return ROK     - success
3491  *         RFAILED - failure
3492  *
3493  * ****************************************************************/
3494    uint8_t BuildDMRSDLPdschMapTypeA
3495 (
3496  struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA *dmrsDlCfg
3497  )
3498 {
3499    dmrsDlCfg->present = PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA_PR_setup;
3500    dmrsDlCfg->choice.setup = NULLP;
3501    DU_ALLOC(dmrsDlCfg->choice.setup, sizeof(struct DMRS_DownlinkConfig));
3502    if(!dmrsDlCfg->choice.setup)
3503    {
3504       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
3505       return RFAILED;
3506    }
3507
3508    dmrsDlCfg->choice.setup->dmrs_Type = NULLP;
3509    dmrsDlCfg->choice.setup->dmrs_AdditionalPosition = NULLP;
3510    DU_ALLOC(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition, sizeof(long));
3511    if(!dmrsDlCfg->choice.setup->dmrs_AdditionalPosition)
3512    {
3513       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSDLPdschMapTypeA");
3514       return RFAILED;
3515    }
3516    *(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition) = DMRS_ADDITIONAL_POS;
3517
3518    dmrsDlCfg->choice.setup->maxLength = NULLP;
3519    dmrsDlCfg->choice.setup->scramblingID0 = NULLP;
3520    dmrsDlCfg->choice.setup->scramblingID1 = NULLP;
3521    dmrsDlCfg->choice.setup->phaseTrackingRS = NULLP;
3522
3523    return ROK;
3524 }
3525
3526 /*******************************************************************
3527  *
3528  * @brief Builds TCI states to add/modify list
3529  *
3530  * @details
3531  *
3532  *    Function : BuildTCIStatesToAddModList
3533  *
3534  *    Functionality:Builds TCI states to add/modify list
3535  *
3536  * @params[in]
3537  * struct PDSCH_Config__tci_StatesToAddModList *tciStatesList
3538  *
3539  * @return ROK     - success
3540  *         RFAILED - failure
3541  *
3542  * ****************************************************************/
3543 uint8_t BuildTCIStatesToAddModList(struct PDSCH_Config__tci_StatesToAddModList *tciStatesList)
3544 {
3545    return ROK;
3546 }
3547
3548 /*******************************************************************
3549  *
3550  * @brief Builds PDSCH time domain allocation list
3551  *
3552  * @details
3553  *
3554  *    Function : BuildPdschTimeDomAllocList
3555  *
3556  *    Functionality: Builds PDSCH time domain allocation list
3557  *
3558  * @params[in]
3559  * struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList
3560  *
3561  * @return ROK     - success
3562  *         RFAILED - failure
3563  *
3564  * ****************************************************************/
3565    uint8_t BuildPdschTimeDomAllocList
3566 (
3567  struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList
3568  )
3569 {
3570    uint8_t idx;
3571    uint8_t elementCnt;
3572    struct PDSCH_TimeDomainResourceAllocation *timeDomAlloc;
3573
3574    timeDomAllocList->present = \
3575                                PDSCH_Config__pdsch_TimeDomainAllocationList_PR_setup;
3576
3577    timeDomAllocList->choice.setup = NULLP;
3578    DU_ALLOC(timeDomAllocList->choice.setup, \
3579          sizeof(struct PDSCH_TimeDomainResourceAllocationList));
3580    if(!timeDomAllocList->choice.setup)
3581    {
3582       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
3583       return RFAILED;
3584    }
3585
3586    elementCnt = 1;
3587    timeDomAllocList->choice.setup->list.count = elementCnt;
3588    timeDomAllocList->choice.setup->list.size = \
3589                                                elementCnt * sizeof(struct PDSCH_TimeDomainResourceAllocation *);
3590
3591    timeDomAllocList->choice.setup->list.array = NULLP;
3592    DU_ALLOC(timeDomAllocList->choice.setup->list.array, \
3593          timeDomAllocList->choice.setup->list.size);
3594    if(!timeDomAllocList->choice.setup->list.array)
3595    {
3596       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
3597       return RFAILED;
3598    }
3599
3600    for(idx = 0; idx < elementCnt; idx++)
3601    {
3602       timeDomAllocList->choice.setup->list.array[idx] = NULLP;
3603       DU_ALLOC(timeDomAllocList->choice.setup->list.array[idx], \
3604             sizeof(struct PDSCH_TimeDomainResourceAllocation));
3605       if(!timeDomAllocList->choice.setup->list.array[idx])
3606       {
3607          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
3608          return RFAILED;
3609       }
3610    }
3611
3612    idx = 0;
3613    timeDomAlloc = timeDomAllocList->choice.setup->list.array[idx];
3614
3615    timeDomAlloc->k0 = NULLP;
3616    timeDomAlloc->mappingType = PDSCH_MAPPING_TYPE_A;
3617    timeDomAlloc->startSymbolAndLength = \
3618                                         calcSliv(PDSCH_START_SYMBOL, PDSCH_LENGTH_SYMBOL);
3619
3620    return ROK;
3621 }
3622
3623 /*******************************************************************
3624  *
3625  * @brief Builds PDSCH PRB Bundling type
3626  *
3627  * @details
3628  *
3629  *    Function : BuildPdschPrbBundlingType
3630  *
3631  *    Functionality: Builds PDSCH PRB Bundling type
3632  *
3633  * @params[in]
3634  * struct PDSCH_Config__prb_BundlingType *prbBndlType
3635  *
3636  * @return ROK     - success
3637  *         RFAILED - failure
3638  *
3639  * ****************************************************************/
3640    uint8_t BuildPdschPrbBundlingType
3641 (
3642  struct PDSCH_Config__prb_BundlingType *prbBndlType
3643  )
3644 {
3645    prbBndlType->present = PDSCH_Config__prb_BundlingType_PR_staticBundling;
3646
3647    prbBndlType->choice.staticBundling = NULLP;
3648    DU_ALLOC(prbBndlType->choice.staticBundling, \
3649          sizeof(struct PDSCH_Config__prb_BundlingType__staticBundling));
3650    if(!prbBndlType->choice.staticBundling)
3651    {
3652       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschPrbBundlingType");
3653       return RFAILED;
3654    }
3655    prbBndlType->choice.staticBundling->bundleSize = NULLP;
3656
3657    return ROK;
3658 }
3659
3660 /*******************************************************************
3661  *
3662  * @brief Builds BWP DL dedicated PDSCH config
3663  *
3664  * @details
3665  *
3666  *    Function : BuildBWPDlDedPdschCfg
3667  *
3668  *    Functionality: Builds BWP DL dedicated PDSCH config
3669  *
3670  * @params[in] struct PDSCH_Config *pdschCfg
3671  *
3672  * @return ROK     - success
3673  *         RFAILED - failure
3674  *
3675  * ****************************************************************/
3676 uint8_t BuildBWPDlDedPdschCfg(struct PDSCH_Config *pdschCfg)
3677 {
3678    pdschCfg->dataScramblingIdentityPDSCH = NULLP;
3679
3680    pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA = NULLP;
3681    DU_ALLOC(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA, \
3682          sizeof(struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA));
3683    if(!pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA)
3684    {
3685       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
3686       return RFAILED;
3687    }
3688
3689    if(BuildDMRSDLPdschMapTypeA(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA) != ROK)
3690    {
3691       return RFAILED;
3692    }
3693
3694    pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeB = NULLP;
3695    pdschCfg->tci_StatesToAddModList = NULLP;
3696    pdschCfg->tci_StatesToReleaseList = NULLP;
3697    pdschCfg->vrb_ToPRB_Interleaver = NULLP;
3698 #if 0
3699    DU_ALLOC(pdschCfg->tci_StatesToAddModList, sizeof(struct PDSCH_Config__tci_StatesToAddModList));
3700    if(!pdschCfg->tci_StatesToAddModList)
3701    {
3702       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
3703       return RFAILED;
3704    }
3705    if(BuildTCIStatesToAddModList(pdschCfg->tci_StatesToAddModList) != ROK)
3706    {
3707       return RFAILED;
3708    }
3709 #endif
3710
3711    pdschCfg->resourceAllocation = RES_ALLOC_TYPE;
3712
3713    pdschCfg->pdsch_TimeDomainAllocationList = NULLP;
3714    DU_ALLOC(pdschCfg->pdsch_TimeDomainAllocationList, \
3715          sizeof(struct PDSCH_Config__pdsch_TimeDomainAllocationList));
3716    if(!pdschCfg->pdsch_TimeDomainAllocationList)
3717    {
3718       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
3719       return RFAILED;
3720    }
3721
3722    if(BuildPdschTimeDomAllocList(pdschCfg->pdsch_TimeDomainAllocationList) != ROK)
3723    {
3724       return RFAILED;
3725    }
3726
3727    pdschCfg->pdsch_AggregationFactor = NULLP;
3728    pdschCfg->rateMatchPatternToAddModList = NULLP;
3729    pdschCfg->rateMatchPatternToReleaseList = NULLP;
3730    pdschCfg->rateMatchPatternGroup1 = NULLP;
3731    pdschCfg->rateMatchPatternGroup2 = NULLP;
3732    pdschCfg->rbg_Size = PDSCH_RBG_SIZE;
3733    pdschCfg->mcs_Table = NULLP;
3734
3735    pdschCfg->maxNrofCodeWordsScheduledByDCI = NULLP;
3736    DU_ALLOC(pdschCfg->maxNrofCodeWordsScheduledByDCI, sizeof(long));
3737    if(!pdschCfg->maxNrofCodeWordsScheduledByDCI)
3738    {
3739       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
3740       return RFAILED;
3741    }
3742    *(pdschCfg->maxNrofCodeWordsScheduledByDCI) = PDSCH_MAX_CODEWORD_SCH_BY_DCI;
3743
3744    if(BuildPdschPrbBundlingType(&pdschCfg->prb_BundlingType) != ROK)
3745    {
3746       return RFAILED;
3747    }
3748
3749    pdschCfg->zp_CSI_RS_ResourceToAddModList = NULLP;
3750    pdschCfg->zp_CSI_RS_ResourceToReleaseList = NULLP;
3751    pdschCfg->aperiodic_ZP_CSI_RS_ResourceSetsToAddModList = NULLP;
3752    pdschCfg->aperiodic_ZP_CSI_RS_ResourceSetsToReleaseList = NULLP;
3753    pdschCfg->sp_ZP_CSI_RS_ResourceSetsToAddModList = NULLP;
3754    pdschCfg->sp_ZP_CSI_RS_ResourceSetsToReleaseList = NULLP;
3755    pdschCfg->p_ZP_CSI_RS_ResourceSet = NULLP;
3756
3757    return ROK;
3758 }
3759
3760 /*******************************************************************
3761  *
3762  * @brief Builds intitial DL BWP
3763  * @details
3764  *
3765  *    Function : BuildInitialDlBWP
3766  *
3767  *    Functionality: Builds intitial DL BWP in spCellCfgDed
3768  *
3769  * @params[in] BWP_DownlinkDedicated_t *dlBwp
3770  *
3771  * @return ROK     - success
3772  *         RFAILED - failure
3773  *
3774  * ****************************************************************/
3775 uint8_t BuildInitialDlBWP(BWP_DownlinkDedicated_t *dlBwp)
3776 {
3777    dlBwp->pdcch_Config = NULLP;
3778    DU_ALLOC(dlBwp->pdcch_Config, sizeof(struct BWP_DownlinkDedicated__pdcch_Config));
3779    if(!dlBwp->pdcch_Config)
3780    {
3781       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failure in BuildInitialDlBWP");
3782       return RFAILED;
3783    }
3784    dlBwp->pdcch_Config->present = BWP_DownlinkDedicated__pdcch_Config_PR_setup;
3785
3786    dlBwp->pdcch_Config->choice.setup = NULLP;
3787    DU_ALLOC(dlBwp->pdcch_Config->choice.setup, sizeof(struct PDCCH_Config));
3788    if(!dlBwp->pdcch_Config->choice.setup)
3789    {
3790       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failure in BuildInitialDlBWP");
3791       return RFAILED;
3792    }
3793    if(BuildBWPDlDedPdcchCfg(dlBwp->pdcch_Config->choice.setup) != ROK)
3794    {
3795       return RFAILED;
3796    }
3797
3798    dlBwp->pdsch_Config = NULLP;
3799    DU_ALLOC(dlBwp->pdsch_Config, sizeof(struct BWP_DownlinkDedicated__pdsch_Config));
3800    if(!dlBwp->pdsch_Config)
3801    {
3802       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failure in BuildInitialDlBWP");
3803       return RFAILED;
3804    }
3805    dlBwp->pdsch_Config->present = BWP_DownlinkDedicated__pdsch_Config_PR_setup;
3806
3807    dlBwp->pdsch_Config->choice.setup = NULLP;
3808    DU_ALLOC(dlBwp->pdsch_Config->choice.setup, sizeof(struct PDSCH_Config));
3809    if(!dlBwp->pdsch_Config->choice.setup)
3810    {
3811       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failure in BuildInitialDlBWP");
3812       return RFAILED;
3813    }
3814
3815    if(BuildBWPDlDedPdschCfg(dlBwp->pdsch_Config->choice.setup) != ROK)
3816    {
3817       return RFAILED;
3818    }
3819
3820    dlBwp->sps_Config = NULLP;
3821    dlBwp->radioLinkMonitoringConfig = NULLP;
3822    return ROK;
3823 }
3824
3825 /*******************************************************************
3826  *
3827  * @brief Builds DMRS UL Pusch Mapping type A
3828  *
3829  * @details
3830  *
3831  *    Function : BuildDMRSULPuschMapTypeA
3832  *
3833  *    Functionality: Builds DMRS UL Pusch Mapping type A
3834  *
3835  * @params[in]
3836  *    struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA *dmrsUlCfg
3837  * @return ROK     - success
3838  *         RFAILED - failure
3839  *
3840  * ****************************************************************/
3841    uint8_t BuildDMRSULPuschMapTypeA
3842 (
3843  struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA *dmrsUlCfg
3844  )
3845 {
3846    dmrsUlCfg->present = PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA_PR_setup;
3847    dmrsUlCfg->choice.setup= NULLP;
3848    DU_ALLOC(dmrsUlCfg->choice.setup, sizeof(DMRS_UplinkConfig_t));
3849    if(!dmrsUlCfg->choice.setup)
3850    {
3851       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
3852       return RFAILED;
3853    }
3854
3855    dmrsUlCfg->choice.setup->dmrs_Type = NULLP;
3856    dmrsUlCfg->choice.setup->dmrs_AdditionalPosition = NULLP;
3857    DU_ALLOC(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition, sizeof(long));
3858    if(!dmrsUlCfg->choice.setup->dmrs_AdditionalPosition)
3859    {
3860       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
3861       return RFAILED;
3862    }
3863    *(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition) = DMRS_ADDITIONAL_POS;
3864
3865    dmrsUlCfg->choice.setup->phaseTrackingRS = NULLP;
3866    dmrsUlCfg->choice.setup->maxLength = NULLP;
3867    dmrsUlCfg->choice.setup->transformPrecodingDisabled = NULLP;
3868    DU_ALLOC(dmrsUlCfg->choice.setup->transformPrecodingDisabled, \
3869          sizeof(struct DMRS_UplinkConfig__transformPrecodingDisabled));
3870    if(!dmrsUlCfg->choice.setup->transformPrecodingDisabled)
3871    {
3872       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
3873       return RFAILED;
3874    }
3875
3876    dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0 = NULLP;
3877    DU_ALLOC(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0,\
3878          sizeof(long));
3879    if(!dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0)
3880    {
3881       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
3882       return RFAILED;
3883    }
3884    *(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0) = SCRAMBLING_ID;
3885
3886    dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID1 = NULLP;
3887    dmrsUlCfg->choice.setup->transformPrecodingEnabled = NULLP;
3888    return ROK;
3889 }
3890
3891 /*******************************************************************
3892  *
3893  * @brief Build PUSCH time domain allocation list
3894  *
3895  * @details
3896  *
3897  *    Function : BuildPuschTimeDomAllocList
3898  *
3899  *    Functionality: Build PUSCH time domain allocation list
3900  *
3901  * @params[in]
3902  * struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList
3903  *
3904  * @return ROK     - success
3905  *         RFAILED - failure
3906  *
3907  * ****************************************************************/
3908    uint8_t BuildPuschTimeDomAllocList
3909 (
3910  struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList
3911  )
3912 {
3913    uint8_t idx;
3914    uint8_t elementCnt;
3915    PUSCH_TimeDomainResourceAllocation_t  *timeDomAlloc;
3916
3917    timeDomAllocList->present = PUSCH_Config__pusch_TimeDomainAllocationList_PR_setup;
3918    timeDomAllocList->choice.setup = NULLP;
3919    DU_ALLOC(timeDomAllocList->choice.setup, \
3920          sizeof(struct PUSCH_TimeDomainResourceAllocationList));
3921    if(!timeDomAllocList->choice.setup)
3922    {
3923       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
3924       return RFAILED;
3925    }
3926
3927    elementCnt = 1;
3928    timeDomAllocList->choice.setup->list.count = elementCnt;
3929    timeDomAllocList->choice.setup->list.size = \
3930                                                elementCnt * sizeof(PUSCH_TimeDomainResourceAllocation_t *);
3931    timeDomAllocList->choice.setup->list.array = NULLP;
3932    DU_ALLOC(timeDomAllocList->choice.setup->list.array, \
3933          timeDomAllocList->choice.setup->list.size);
3934    if(!timeDomAllocList->choice.setup->list.array)
3935    {
3936       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
3937       return RFAILED;
3938    }
3939
3940    for(idx = 0; idx < elementCnt; idx++)
3941    {
3942       timeDomAllocList->choice.setup->list.array[idx] = NULLP;
3943       DU_ALLOC(timeDomAllocList->choice.setup->list.array[idx],\
3944             sizeof(PUSCH_TimeDomainResourceAllocation_t));
3945       if(!timeDomAllocList->choice.setup->list.array[idx])
3946       {
3947          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
3948          return RFAILED;
3949       }
3950    }
3951
3952    idx = 0;
3953    timeDomAlloc = timeDomAllocList->choice.setup->list.array[idx];
3954    DU_ALLOC(timeDomAlloc->k2, sizeof(long));
3955    if(!timeDomAlloc->k2)
3956    {
3957       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
3958       return RFAILED;
3959    }
3960    *(timeDomAlloc->k2) = PUSCH_K2;
3961    timeDomAlloc->mappingType = PUSCH_MAPPING_TYPE_A;
3962    timeDomAlloc->startSymbolAndLength = calcSliv(PUSCH_START_SYMBOL, PUSCH_LENGTH_SYMBOL);
3963    return ROK;
3964 }
3965
3966 /*******************************************************************
3967  *
3968  * @brief Builds BWP UL dedicated PUSCH Config
3969  *
3970  * @details
3971  *
3972  *    Function : BuildBWPUlDedPuschCfg
3973  *
3974  *    Functionality:
3975  *      Builds BWP UL dedicated PUSCH Config
3976  *
3977  * @params[in] : PUSCH_Config_t *puschCfg
3978  *
3979  * @return ROK     - success
3980  *         RFAILED - failure
3981  *
3982  * ****************************************************************/
3983 uint8_t BuildBWPUlDedPuschCfg(PUSCH_Config_t *puschCfg)
3984 {
3985    puschCfg->dataScramblingIdentityPUSCH = NULLP;
3986    DU_ALLOC(puschCfg->dataScramblingIdentityPUSCH, sizeof(long));
3987    if(!puschCfg->dataScramblingIdentityPUSCH)
3988    {
3989       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
3990       return RFAILED;
3991    }
3992    *(puschCfg->dataScramblingIdentityPUSCH) = SCRAMBLING_ID;
3993
3994    puschCfg->txConfig = NULLP;
3995    puschCfg->dmrs_UplinkForPUSCH_MappingTypeA = NULLP;
3996    DU_ALLOC(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA, \
3997          sizeof(struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA));
3998    if(!puschCfg->dmrs_UplinkForPUSCH_MappingTypeA)
3999    {
4000       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
4001       return RFAILED;
4002    }
4003
4004    if(BuildDMRSULPuschMapTypeA(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA) != ROK)
4005    {
4006       return RFAILED;
4007    }
4008
4009    puschCfg->dmrs_UplinkForPUSCH_MappingTypeB = NULLP;
4010    puschCfg->pusch_PowerControl = NULLP;
4011    puschCfg->frequencyHopping = NULLP;
4012    puschCfg->frequencyHoppingOffsetLists = NULLP;
4013    puschCfg->resourceAllocation = RES_ALLOC_TYPE;
4014
4015    puschCfg->pusch_TimeDomainAllocationList = NULLP;
4016    DU_ALLOC(puschCfg->pusch_TimeDomainAllocationList, \
4017          sizeof(struct PUSCH_Config__pusch_TimeDomainAllocationList));
4018    if(!puschCfg->pusch_TimeDomainAllocationList)
4019    {
4020       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
4021       return RFAILED;
4022    }
4023
4024    if(BuildPuschTimeDomAllocList(puschCfg->pusch_TimeDomainAllocationList) != ROK)
4025    {
4026       return RFAILED;
4027    }
4028
4029    puschCfg->pusch_AggregationFactor = NULLP;
4030    puschCfg->mcs_Table = NULLP;
4031    puschCfg->mcs_TableTransformPrecoder = NULLP;
4032    puschCfg->transformPrecoder = NULLP;
4033    DU_ALLOC(puschCfg->transformPrecoder, sizeof(long));
4034    if(!puschCfg->transformPrecoder)
4035    {
4036       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
4037       return RFAILED;
4038    }
4039    *(puschCfg->transformPrecoder) = PUSCH_TRANSFORM_PRECODER;
4040
4041    puschCfg->codebookSubset = NULLP;
4042    puschCfg->maxRank = NULLP;
4043    puschCfg->rbg_Size = NULLP;
4044    puschCfg->uci_OnPUSCH = NULLP;
4045    puschCfg->tp_pi2BPSK = NULLP;
4046
4047    return ROK;
4048 }
4049
4050 /*******************************************************************
4051  *
4052  * @brief Fills SRS resource to add/modify list
4053  *
4054  * @details
4055  *
4056  *    Function : BuildSrsRsrcAddModList
4057  *
4058  *    Functionality: Fills SRS resource to add/modify list
4059  *
4060  * @params[in]
4061  * @return ROK     - success
4062  *         RFAILED - failure
4063  *
4064  * ****************************************************************/
4065 uint8_t BuildSrsRsrcAddModList(struct SRS_Config__srs_ResourceToAddModList *resourceList)
4066 {
4067    uint8_t   elementCnt;
4068    uint8_t   rsrcIdx;
4069
4070    elementCnt = 1;
4071    resourceList->list.count = elementCnt;
4072    resourceList->list.size = elementCnt * sizeof(SRS_Resource_t *);
4073    resourceList->list.array = NULLP;
4074    DU_ALLOC(resourceList->list.array, resourceList->list.size);
4075    if(!resourceList->list.array)
4076    {
4077       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcAddModList");
4078       return RFAILED;
4079    }
4080
4081    for(rsrcIdx = 0; rsrcIdx < resourceList->list.count; rsrcIdx++)
4082    {
4083       DU_ALLOC(resourceList->list.array[rsrcIdx], sizeof(SRS_Resource_t));
4084       if(!resourceList->list.array[rsrcIdx])
4085       {
4086          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcAddModList");
4087          return RFAILED;
4088       }
4089    }
4090
4091    rsrcIdx = 0;
4092    resourceList->list.array[rsrcIdx]->srs_ResourceId = SRS_RSRC_ID;
4093    resourceList->list.array[rsrcIdx]->nrofSRS_Ports = SRS_Resource__nrofSRS_Ports_port1;
4094    resourceList->list.array[rsrcIdx]->transmissionComb.present = SRS_Resource__transmissionComb_PR_n2;
4095
4096    resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2 = NULLP;
4097    DU_ALLOC(resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2, \
4098          sizeof(struct SRS_Resource__transmissionComb__n2));
4099    if(!resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2)
4100    {
4101       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcAddModList");
4102       return RFAILED;
4103    }
4104    resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2->combOffset_n2\
4105       = SRS_COMB_OFFSET_N2;
4106    resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2->cyclicShift_n2\
4107       = SRS_CYCLIC_SHIFT_N2;
4108
4109    resourceList->list.array[rsrcIdx]->resourceMapping.startPosition = \
4110                                                                       PUSCH_START_SYMBOL;
4111    resourceList->list.array[rsrcIdx]->resourceMapping.nrofSymbols =  \
4112                                                                      SRS_Resource__resourceMapping__nrofSymbols_n1;
4113    resourceList->list.array[rsrcIdx]->resourceMapping.repetitionFactor = \
4114                                                                          SRS_Resource__resourceMapping__repetitionFactor_n1;
4115
4116    resourceList->list.array[rsrcIdx]->freqDomainPosition = SRS_FREQ_DOM_POS;
4117    resourceList->list.array[rsrcIdx]->freqDomainShift = SRS_FREQ_DOM_SHIFT;
4118    resourceList->list.array[rsrcIdx]->freqHopping.c_SRS = C_SRS;
4119    resourceList->list.array[rsrcIdx]->freqHopping.b_SRS = B_SRS;
4120    resourceList->list.array[rsrcIdx]->freqHopping.b_hop = B_HOP;
4121    resourceList->list.array[rsrcIdx]->groupOrSequenceHopping = \
4122                                                                SRS_Resource__groupOrSequenceHopping_neither;
4123
4124    /* Setting resource type to aperiodic for intergration purposes */
4125    resourceList->list.array[rsrcIdx]->resourceType.present = \
4126                                                              SRS_Resource__resourceType_PR_aperiodic;
4127    resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic = NULLP;
4128    DU_ALLOC(resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic,
4129          sizeof(struct SRS_Resource__resourceType__aperiodic));
4130    if(!resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic)
4131    {
4132       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcAddModList");
4133       return RFAILED;
4134    }
4135    resourceList->list.array[rsrcIdx]->sequenceId = SRS_SEQ_ID;
4136
4137    return ROK;
4138 }
4139
4140 /*******************************************************************
4141  *
4142  * @brief Build SRS resource set Add/mod list
4143  *
4144  * @details
4145  *
4146  *    Function : BuildSrsRsrcSetAddModList
4147  *
4148  *    Functionality: Build SRS resource set Add/mod list
4149  *
4150  * @params[in]
4151  * @return ROK     - success
4152  *         RFAILED - failure
4153  *
4154  * ****************************************************************/
4155    uint8_t BuildSrsRsrcSetAddModList
4156 (
4157  struct SRS_Config__srs_ResourceSetToAddModList *rsrcSetList
4158  )
4159 {
4160    uint8_t  elementCnt;
4161    uint8_t  rSetIdx;
4162    uint8_t  rsrcIdx;
4163    struct SRS_ResourceSet__srs_ResourceIdList *rsrcIdList;
4164
4165    elementCnt = 1;
4166    rsrcSetList->list.count = elementCnt;
4167    rsrcSetList->list.size = elementCnt * sizeof(SRS_ResourceSet_t *);
4168    rsrcSetList->list.array = NULLP;
4169    DU_ALLOC(rsrcSetList->list.array, rsrcSetList->list.size);
4170    if(!rsrcSetList->list.array)
4171    {
4172       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
4173       return RFAILED;
4174    }
4175
4176    for(rSetIdx = 0; rSetIdx < rsrcSetList->list.count; rSetIdx++)
4177    {
4178       DU_ALLOC(rsrcSetList->list.array[rSetIdx], sizeof(SRS_ResourceSet_t));
4179       if(!rsrcSetList->list.array[rSetIdx])
4180       {
4181          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
4182          return RFAILED;
4183       }
4184    }
4185
4186    rSetIdx = 0;
4187    rsrcSetList->list.array[rSetIdx]->srs_ResourceSetId = SRS_RSET_ID;
4188
4189    /* Fill Resource Id list in resource set */
4190    rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList = NULLP;
4191    DU_ALLOC(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList,\
4192          sizeof(struct SRS_ResourceSet__srs_ResourceIdList));
4193    if(!rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList)
4194    {
4195       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
4196       return RFAILED;
4197    }
4198
4199    elementCnt = 1;
4200    rsrcIdList = rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList;
4201    rsrcIdList->list.count = elementCnt;
4202    rsrcIdList->list.size = elementCnt * sizeof(SRS_ResourceId_t *);
4203    rsrcIdList->list.array = NULLP;
4204    DU_ALLOC(rsrcIdList->list.array, rsrcIdList->list.size);
4205    if(!rsrcIdList->list.array)
4206    {
4207       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
4208       return RFAILED;
4209    }
4210
4211    for(rsrcIdx = 0; rsrcIdx < rsrcIdList->list.count; rsrcIdx++)
4212    {
4213       DU_ALLOC(rsrcIdList->list.array[rsrcIdx], sizeof(SRS_ResourceId_t));
4214       if(!rsrcIdList->list.array[rsrcIdx])
4215       {
4216          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
4217          return RFAILED;
4218       }
4219    }
4220
4221    rsrcIdx = 0;
4222    *rsrcIdList->list.array[rsrcIdx] = SRS_RSRC_ID;
4223
4224    /* Fill resource type */
4225    rsrcSetList->list.array[rSetIdx]->resourceType.present = \
4226                                                             SRS_ResourceSet__resourceType_PR_aperiodic;
4227
4228    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic = NULLP;
4229    DU_ALLOC(rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic, \
4230          sizeof(struct SRS_ResourceSet__resourceType__aperiodic));
4231    if(!rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic)
4232    {
4233       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
4234       return RFAILED;
4235    }
4236    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic->aperiodicSRS_ResourceTrigger \
4237       = APERIODIC_SRS_RESRC_TRIGGER;
4238
4239    /* TODO : Fill values for below IEs as expected by Viavi */
4240    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic->csi_RS = NULLP;
4241    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic->slotOffset = NULLP;
4242
4243
4244    rsrcSetList->list.array[rSetIdx]->usage = SRS_ResourceSet__usage_codebook;
4245    rsrcSetList->list.array[rSetIdx]->alpha = NULLP;
4246    rsrcSetList->list.array[rSetIdx]->p0 = NULLP;
4247    rsrcSetList->list.array[rSetIdx]->pathlossReferenceRS = NULLP;
4248    rsrcSetList->list.array[rSetIdx]->srs_PowerControlAdjustmentStates = NULLP;
4249
4250    return ROK;
4251 }
4252
4253 /*******************************************************************
4254  *
4255  * @brief Builds BWP UL dedicated SRS Config
4256  *
4257  * @details
4258  *
4259  *    Function : BuildBWPUlDedSrsCfg
4260  *
4261  *    Functionality: Builds BWP UL dedicated SRS Config
4262  *
4263  * @params[in] SRS Config
4264  * @return ROK     - success
4265  *         RFAILED - failure
4266  *
4267  * ****************************************************************/
4268 uint8_t BuildBWPUlDedSrsCfg(SRS_Config_t *srsCfg)
4269 {
4270    srsCfg->srs_ResourceSetToReleaseList = NULLP;
4271    srsCfg->srs_ResourceSetToAddModList = NULLP;
4272    DU_ALLOC(srsCfg->srs_ResourceSetToAddModList, \
4273          sizeof(struct SRS_Config__srs_ResourceSetToAddModList));
4274    if(!srsCfg->srs_ResourceSetToAddModList)
4275    {
4276       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedSrsCfg");
4277       return RFAILED;
4278    }
4279    if(BuildSrsRsrcSetAddModList(srsCfg->srs_ResourceSetToAddModList) != ROK)
4280    {
4281       return RFAILED;
4282    }
4283
4284    srsCfg->srs_ResourceToReleaseList = NULLP;
4285
4286    /* Resource to Add/Modify list */
4287    srsCfg->srs_ResourceToAddModList = NULLP;
4288    DU_ALLOC(srsCfg->srs_ResourceToAddModList, \
4289          sizeof(struct SRS_Config__srs_ResourceToAddModList));
4290    if(!srsCfg->srs_ResourceToAddModList)
4291    {
4292       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedSrsCfg");
4293       return RFAILED;
4294    }
4295
4296    if(BuildSrsRsrcAddModList(srsCfg->srs_ResourceToAddModList) != ROK)
4297    {
4298       return RFAILED;
4299    }
4300
4301    srsCfg->tpc_Accumulation = NULLP;
4302
4303    return ROK;
4304 }
4305
4306
4307
4308 /*******************************************************************
4309  *
4310  * @brief Builds Pusch Serving cell Config
4311  *
4312  * @details
4313  *
4314  *    Function : BuildPuschSrvCellCfg
4315  *
4316  *    Functionality: Builds Pusch Serving cell Config
4317  *
4318  * @params[in] struct UplinkConfig__pusch_ServingCellConfig *puschCfg
4319  *
4320  * @return ROK     - success
4321  *         RFAILED - failure
4322  *
4323  * ****************************************************************/
4324 uint8_t BuildPuschSrvCellCfg(struct UplinkConfig__pusch_ServingCellConfig *puschCfg)
4325 {
4326    puschCfg->present = UplinkConfig__pusch_ServingCellConfig_PR_setup;
4327    puschCfg->choice.setup = NULLP;
4328    DU_ALLOC(puschCfg->choice.setup, sizeof(struct PUSCH_ServingCellConfig));
4329    if(!puschCfg->choice.setup)
4330    {
4331       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
4332       return RFAILED;
4333    }
4334
4335    puschCfg->choice.setup->codeBlockGroupTransmission = NULLP;
4336    puschCfg->choice.setup->rateMatching = NULLP;
4337    puschCfg->choice.setup->xOverhead = NULLP;
4338    puschCfg->choice.setup->ext1 = NULLP;
4339    DU_ALLOC(puschCfg->choice.setup->ext1, sizeof(struct PUSCH_ServingCellConfig__ext1));
4340    if(!puschCfg->choice.setup->ext1)
4341    {
4342       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
4343       return RFAILED;
4344    }
4345
4346    puschCfg->choice.setup->ext1->maxMIMO_Layers = NULLP;
4347    DU_ALLOC(puschCfg->choice.setup->ext1->maxMIMO_Layers, sizeof(long));
4348    if(!puschCfg->choice.setup->ext1->maxMIMO_Layers)
4349    {
4350       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
4351       return RFAILED;
4352    }
4353    *(puschCfg->choice.setup->ext1->maxMIMO_Layers) = PUSCH_MAX_MIMO_LAYERS;
4354
4355    puschCfg->choice.setup->ext1->processingType2Enabled= NULLP;
4356    DU_ALLOC(puschCfg->choice.setup->ext1->processingType2Enabled,sizeof(BOOLEAN_t));
4357    if(!puschCfg->choice.setup->ext1->processingType2Enabled)
4358    {
4359       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
4360       return RFAILED;
4361    }
4362    *(puschCfg->choice.setup->ext1->processingType2Enabled) = PUSCH_PROCESS_TYPE2_ENABLED;
4363    return ROK;
4364 }
4365
4366 /*******************************************************************
4367  *
4368  * @brief Builds inital UL BWP
4369  *
4370  * @details
4371  *
4372  *    Function : BuildInitialUlBWP
4373  *
4374  *    Functionality: Builds initial UL BWP
4375  *
4376  * @params[in] BWP_UplinkDedicated_t *ulBwp
4377  * @return ROK     - success
4378  *         RFAILED - failure
4379  *
4380  * ****************************************************************/
4381 uint8_t BuildInitialUlBWP(BWP_UplinkDedicated_t *ulBwp)
4382 {
4383    ulBwp->pucch_Config = NULLP;
4384
4385    /* Fill BWP UL dedicated PUSCH config */
4386    ulBwp->pusch_Config = NULLP;
4387    DU_ALLOC(ulBwp->pusch_Config, sizeof(struct BWP_UplinkDedicated__pusch_Config));
4388    if(!ulBwp->pusch_Config)
4389    {
4390       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
4391       return RFAILED;
4392    }
4393
4394    ulBwp->pusch_Config->present = BWP_UplinkDedicated__pusch_Config_PR_setup;
4395    ulBwp->pusch_Config->choice.setup = NULLP;
4396    DU_ALLOC(ulBwp->pusch_Config->choice.setup, sizeof(PUSCH_Config_t));
4397    if(!ulBwp->pusch_Config->choice.setup)
4398    {
4399       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
4400       return RFAILED;
4401    }
4402
4403    if(BuildBWPUlDedPuschCfg(ulBwp->pusch_Config->choice.setup) != ROK)
4404    {
4405       return RFAILED;
4406    }
4407
4408    ulBwp->configuredGrantConfig = NULLP;
4409
4410    /* Fill BPW UL dedicated SRS config */
4411    ulBwp->srs_Config = NULLP;
4412    DU_ALLOC(ulBwp->srs_Config, sizeof(struct BWP_UplinkDedicated__srs_Config));
4413    if(!ulBwp->srs_Config)
4414    {
4415       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
4416       return RFAILED;
4417    }
4418
4419    ulBwp->srs_Config->present = BWP_UplinkDedicated__srs_Config_PR_setup;
4420    ulBwp->srs_Config->choice.setup = NULLP;
4421    DU_ALLOC(ulBwp->srs_Config->choice.setup, sizeof(SRS_Config_t));
4422    if(!ulBwp->srs_Config->choice.setup)
4423    {
4424       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
4425       return RFAILED;
4426    }
4427
4428    if(BuildBWPUlDedSrsCfg(ulBwp->srs_Config->choice.setup) != ROK)
4429    {
4430       return RFAILED;
4431    }
4432
4433    ulBwp->beamFailureRecoveryConfig = NULLP;
4434
4435    return ROK;
4436 }
4437
4438 /*******************************************************************
4439  *
4440  * @brief Builds UL config
4441  * @details
4442  *
4443  *    Function : BuildUlCfg
4444  *
4445  *    Functionality: Builds UL config in spCellCfgDed
4446  *
4447  * @params[in] UplinkConfig_t *ulCfg
4448  *
4449  * @return ROK     - success
4450  *         RFAILED - failure
4451  *
4452  * ****************************************************************/
4453 uint8_t BuildUlCfg(UplinkConfig_t *ulCfg)
4454 {
4455    ulCfg->initialUplinkBWP = NULLP;
4456    DU_ALLOC(ulCfg->initialUplinkBWP, sizeof(BWP_UplinkDedicated_t));
4457    if(!ulCfg->initialUplinkBWP)
4458    {
4459       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failed in BuildUlCfg");
4460       return RFAILED;
4461    }
4462
4463    if(BuildInitialUlBWP(ulCfg->initialUplinkBWP) != ROK)
4464    {
4465       return RFAILED;
4466    }
4467
4468    ulCfg->uplinkBWP_ToReleaseList = NULLP;
4469    ulCfg->uplinkBWP_ToAddModList = NULLP;
4470    ulCfg->firstActiveUplinkBWP_Id = NULLP;
4471    DU_ALLOC(ulCfg->firstActiveUplinkBWP_Id, sizeof(BWP_Id_t));
4472    if(!ulCfg->firstActiveUplinkBWP_Id)
4473    {
4474       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failed in BuildUlCfg");
4475       return RFAILED;
4476    }
4477    *(ulCfg->firstActiveUplinkBWP_Id) = ACTIVE_UL_BWP_ID;
4478
4479    ulCfg->pusch_ServingCellConfig = NULLP;
4480    DU_ALLOC(ulCfg->pusch_ServingCellConfig, \
4481          sizeof(struct UplinkConfig__pusch_ServingCellConfig));
4482    if(!ulCfg->pusch_ServingCellConfig)
4483    {
4484       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failed in BuildUlCfg");
4485       return RFAILED;
4486    }
4487
4488    if(BuildPuschSrvCellCfg(ulCfg->pusch_ServingCellConfig) != ROK)
4489    {
4490       return RFAILED;
4491    }
4492
4493    ulCfg->carrierSwitching = NULLP;
4494    ulCfg->ext1 = NULLP;
4495    return ROK;
4496 }
4497
4498 /*******************************************************************
4499  *
4500  * @brief Builds PDSCH serving cell config
4501  * @details
4502  *
4503  *    Function : BuildPdschSrvCellCfg
4504  *
4505  *    Functionality: Builds PDSCH serving cell config in spCellCfgDed
4506  *
4507  * @params[in] struct ServingCellConfig__pdsch_ServingCellConfig *pdschCfg
4508  *
4509  * @return ROK     - success
4510  *         RFAILED - failure
4511  *
4512  * ****************************************************************/
4513 uint8_t BuildPdschSrvCellCfg(struct ServingCellConfig__pdsch_ServingCellConfig *pdschCfg)
4514 {
4515    pdschCfg->present =  ServingCellConfig__pdsch_ServingCellConfig_PR_setup;
4516    pdschCfg->choice.setup = NULLP;
4517    DU_ALLOC(pdschCfg->choice.setup, sizeof( struct PDSCH_ServingCellConfig));
4518    if(!pdschCfg->choice.setup)
4519    {
4520       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschSrvCellCfg");
4521       return RFAILED;
4522    }
4523
4524    pdschCfg->choice.setup->codeBlockGroupTransmission = NULLP;
4525    pdschCfg->choice.setup->xOverhead = NULLP;
4526    pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH = NULLP;
4527    DU_ALLOC(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH, sizeof(long));
4528    if(!pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH)
4529    {
4530       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschSrvCellCfg");
4531       return RFAILED;
4532    }
4533    *(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH)= PDSCH_NUM_HARQ_PROC;
4534    pdschCfg->choice.setup->pucch_Cell = NULLP;
4535    pdschCfg->choice.setup->ext1 = NULLP;
4536
4537    return ROK;
4538 }
4539
4540 /*******************************************************************
4541  *
4542  * @brief Builds CSI Meas config
4543  * @details
4544  *
4545  *    Function : BuildCsiMeasCfg
4546  *
4547  *    Functionality: Builds CSI Meas config in spCellCfgDed
4548  *
4549  * @params[in] struct ServingCellConfig__csi_MeasConfig *csiMeasCfg
4550  *
4551  * @return ROK     - success
4552  *         RFAILED - failure
4553  *
4554  * ****************************************************************/
4555 uint8_t BuildCsiMeasCfg(struct ServingCellConfig__csi_MeasConfig *csiMeasCfg)
4556 {
4557
4558    return ROK;
4559 }
4560
4561 /*******************************************************************
4562  *
4563  * @brief Builds Spcell config dedicated
4564  * @details
4565  *
4566  *    Function : BuildSpCellCfgDed
4567  *
4568  *    Functionality: Builds sp cell config dedicated in spCellCfg
4569  *
4570  * @params[in] ServingCellConfig_t srvCellCfg
4571  *
4572  * @return ROK     - success
4573  *         RFAILED - failure
4574  *
4575  * ****************************************************************/
4576 uint8_t BuildSpCellCfgDed(ServingCellConfig_t *srvCellCfg)
4577 {
4578    srvCellCfg->tdd_UL_DL_ConfigurationDedicated = NULLP;
4579    DU_ALLOC(srvCellCfg->tdd_UL_DL_ConfigurationDedicated, sizeof(TDD_UL_DL_ConfigDedicated_t));
4580    if(!srvCellCfg->tdd_UL_DL_ConfigurationDedicated)
4581    {
4582       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
4583       return RFAILED;
4584    }
4585
4586    srvCellCfg->initialDownlinkBWP = NULLP;
4587    DU_ALLOC(srvCellCfg->initialDownlinkBWP, sizeof(BWP_DownlinkDedicated_t));
4588    if(!srvCellCfg->initialDownlinkBWP)
4589    {
4590       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
4591       return RFAILED;
4592    }
4593
4594    if(BuildInitialDlBWP(srvCellCfg->initialDownlinkBWP) != ROK)
4595    {
4596       DU_LOG("\nERROR  -->  F1AP : BuildInitialDlBWP failed");
4597       return RFAILED;
4598    }
4599    srvCellCfg->downlinkBWP_ToReleaseList = NULLP;
4600    srvCellCfg->downlinkBWP_ToAddModList = NULLP;
4601
4602    srvCellCfg->firstActiveDownlinkBWP_Id = NULLP;
4603    DU_ALLOC(srvCellCfg->firstActiveDownlinkBWP_Id, sizeof(long));
4604    if(!srvCellCfg->firstActiveDownlinkBWP_Id)
4605    {
4606       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
4607       return RFAILED;
4608    }
4609    *(srvCellCfg->firstActiveDownlinkBWP_Id) = ACTIVE_DL_BWP_ID;
4610
4611    srvCellCfg->bwp_InactivityTimer = NULLP;
4612
4613    srvCellCfg->defaultDownlinkBWP_Id = NULLP;
4614    DU_ALLOC(srvCellCfg->defaultDownlinkBWP_Id, sizeof(long));
4615    if(!srvCellCfg->defaultDownlinkBWP_Id)
4616    {
4617       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
4618       return RFAILED;
4619    }
4620    *(srvCellCfg->defaultDownlinkBWP_Id) = ACTIVE_DL_BWP_ID;
4621
4622    srvCellCfg->uplinkConfig = NULLP;
4623    DU_ALLOC(srvCellCfg->uplinkConfig, sizeof(UplinkConfig_t));
4624    if(!srvCellCfg->uplinkConfig)
4625    {
4626       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
4627       return RFAILED;
4628    }
4629
4630    if(BuildUlCfg(srvCellCfg->uplinkConfig) != ROK)
4631    {
4632       DU_LOG("\nERROR  -->  F1AP : BuildUlCfg failed");
4633       return RFAILED;
4634    }
4635    srvCellCfg->supplementaryUplink = NULLP;
4636    srvCellCfg->pdcch_ServingCellConfig = NULLP;
4637
4638    srvCellCfg->pdsch_ServingCellConfig = NULLP;
4639    DU_ALLOC(srvCellCfg->pdsch_ServingCellConfig, sizeof(struct  ServingCellConfig__pdsch_ServingCellConfig));
4640    if(!srvCellCfg->pdsch_ServingCellConfig)
4641    {
4642       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
4643       return RFAILED;
4644    }
4645
4646    if(BuildPdschSrvCellCfg(srvCellCfg->pdsch_ServingCellConfig) != ROK)
4647    {
4648       DU_LOG("\nERROR  -->  F1AP : BuildPdschSrvCellCfg failed");
4649       return RFAILED;
4650    }
4651
4652    srvCellCfg->csi_MeasConfig = NULLP;
4653 #if 0
4654    DU_ALLOC(srvCellCfg->csi_MeasConfig, sizeof(struct   ServingCellConfig__csi_MeasConfig))
4655       if(!srvCellCfg->csi_MeasConfig)
4656       {
4657          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
4658          return RFAILED;
4659       }
4660
4661    if(BuildCsiMeasCfg(srvCellCfg->csi_MeasConfig) != ROK)
4662    {
4663       DU_LOG("\nF1AP : BuildCsiMeasCfg failed");
4664       return RFAILED;
4665    }
4666 #endif
4667    srvCellCfg->sCellDeactivationTimer = NULLP;
4668    srvCellCfg->crossCarrierSchedulingConfig = NULLP;
4669    srvCellCfg->tag_Id = TAG_ID;
4670    srvCellCfg->dummy = NULLP;
4671    srvCellCfg->pathlossReferenceLinking = NULLP;
4672    srvCellCfg->servingCellMO = NULLP;
4673    srvCellCfg->ext1 = NULLP;
4674
4675    return ROK;
4676 }
4677 /*******************************************************************
4678  *
4679  * @brief Builds Spcell config
4680  *
4681  * @details
4682  *
4683  *    Function : BuildSpCellCfg
4684  *
4685  *    Functionality: Builds sp cell config in DuToCuRrcContainer
4686  *
4687  * @params[in] SpCellConfig_t spCellCfg
4688  *
4689  * @return ROK     - success
4690  *         RFAILED - failure
4691  *
4692  * ****************************************************************/
4693 uint8_t BuildSpCellCfg(SpCellConfig_t *spCellCfg)
4694 {
4695
4696    spCellCfg->servCellIndex = NULLP;
4697    DU_ALLOC(spCellCfg->servCellIndex, sizeof(long));
4698    if(!spCellCfg->servCellIndex)
4699    {
4700       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfg");
4701       return RFAILED;
4702    }
4703    *(spCellCfg->servCellIndex) = SERV_CELL_IDX;
4704
4705    spCellCfg->reconfigurationWithSync = NULLP;
4706    spCellCfg->rlf_TimersAndConstants = NULLP;
4707    spCellCfg->rlmInSyncOutOfSyncThreshold = NULLP;
4708    DU_ALLOC(spCellCfg->rlmInSyncOutOfSyncThreshold, sizeof(long));
4709    if(!spCellCfg->rlmInSyncOutOfSyncThreshold)
4710    {
4711       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfg");
4712       return RFAILED;
4713    }
4714    *(spCellCfg->rlmInSyncOutOfSyncThreshold) = RLM_SYNC_OUT_SYNC_THRESHOLD;
4715
4716    spCellCfg->spCellConfigDedicated = NULLP;
4717    DU_ALLOC(spCellCfg->spCellConfigDedicated, sizeof(ServingCellConfig_t));
4718    if(!spCellCfg->spCellConfigDedicated)
4719    {
4720       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfg");
4721       return RFAILED;
4722    }
4723    if(BuildSpCellCfgDed(spCellCfg->spCellConfigDedicated) != ROK)
4724    {
4725       DU_LOG("\nERROR  -->  F1AP : BuildSpCellCfgDed failed");
4726       return RFAILED;
4727    }
4728    return ROK;
4729 }
4730 /*******************************************************************
4731  *
4732  * @brief Builds Phy cell group config
4733  *
4734  * @details
4735  *
4736  *    Function : BuildPhyCellGrpCfg
4737  *
4738  *    Functionality: Builds Phy cell group config in DuToCuRrcContainer
4739  *
4740  * @params[in] PhysicalCellGroupConfig_t *phyCellGrpCfg
4741  *
4742  * @return ROK     - success
4743  *         RFAILED - failure
4744  *
4745  * ****************************************************************/
4746 uint8_t BuildPhyCellGrpCfg(PhysicalCellGroupConfig_t *phyCellGrpCfg)
4747 {
4748    phyCellGrpCfg->harq_ACK_SpatialBundlingPUCCH = NULLP;
4749    phyCellGrpCfg->harq_ACK_SpatialBundlingPUSCH = NULLP;
4750
4751    phyCellGrpCfg->p_NR_FR1 = NULLP;
4752    DU_ALLOC(phyCellGrpCfg->p_NR_FR1, sizeof(long));
4753    if(!phyCellGrpCfg->p_NR_FR1)
4754    {
4755       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildPhyCellGrpCfg");
4756       return RFAILED;
4757    }
4758    *(phyCellGrpCfg->p_NR_FR1)             = P_NR_FR1;
4759    phyCellGrpCfg->pdsch_HARQ_ACK_Codebook = PDSCH_HARQ_ACK_CODEBOOK;
4760    phyCellGrpCfg->tpc_SRS_RNTI = NULLP;
4761    phyCellGrpCfg->tpc_PUCCH_RNTI = NULLP;
4762    phyCellGrpCfg->tpc_PUSCH_RNTI = NULLP;
4763    phyCellGrpCfg->sp_CSI_RNTI = NULLP;
4764    phyCellGrpCfg->cs_RNTI = NULLP;
4765    phyCellGrpCfg->ext1 = NULLP;
4766    phyCellGrpCfg->ext2 = NULLP;
4767
4768    return ROK;
4769 }
4770 /*******************************************************************
4771  *
4772  * @brief Builds Mac cell group config
4773  *
4774  * @details
4775  *
4776  *    Function : BuildMacCellGrpCfg
4777  *
4778  *    Functionality: Builds Mac cell group config in DuToCuRrcContainer
4779  *
4780  * @params[in] MAC_CellGroupConfig_t *macCellGrpCfg
4781  *
4782  * @return ROK     - success
4783  *         RFAILED - failure
4784  *
4785  * ****************************************************************/
4786 uint8_t BuildMacCellGrpCfg(MAC_CellGroupConfig_t *macCellGrpCfg)
4787 {
4788    macCellGrpCfg->drx_Config = NULLP;
4789    macCellGrpCfg->schedulingRequestConfig = NULLP;
4790    DU_ALLOC(macCellGrpCfg->schedulingRequestConfig, sizeof(struct SchedulingRequestConfig));
4791    if(!macCellGrpCfg->schedulingRequestConfig)
4792    {
4793       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacCellGrpCfg");
4794       return RFAILED;
4795    }
4796
4797    if(BuildSchedulingReqConfig(macCellGrpCfg->schedulingRequestConfig) != ROK)
4798    {
4799       DU_LOG("\nERROR  -->  F1AP : BuildSchedulingReqConfig failed");
4800       return RFAILED;
4801    }
4802
4803    macCellGrpCfg->bsr_Config = NULLP;
4804    DU_ALLOC(macCellGrpCfg->bsr_Config, sizeof(struct BSR_Config));
4805    if(!macCellGrpCfg->bsr_Config)
4806    {
4807       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacCellGrpCfg");
4808       return RFAILED;
4809    }
4810
4811    if(BuildBsrConfig(macCellGrpCfg->bsr_Config) != ROK)
4812    {
4813       DU_LOG("\nERROR  -->  F1AP : BuildBsrConfig failed");
4814       return RFAILED;
4815    }
4816
4817    macCellGrpCfg->tag_Config = NULLP;
4818    DU_ALLOC(macCellGrpCfg->tag_Config, sizeof(struct TAG_Config));
4819    if(!macCellGrpCfg->tag_Config)
4820    {
4821       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacCellGrpCfg");
4822       return RFAILED;
4823    }
4824
4825    if(BuildTagConfig(macCellGrpCfg->tag_Config) != ROK)
4826    {
4827       DU_LOG("\nERROR  -->  F1AP : BuildTagConfig failed");
4828       return RFAILED;
4829    }
4830
4831    macCellGrpCfg->phr_Config = NULLP;
4832    DU_ALLOC(macCellGrpCfg->phr_Config, sizeof(struct MAC_CellGroupConfig__phr_Config));
4833    if(!macCellGrpCfg->phr_Config)
4834    {
4835       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacCellGrpCfg");
4836       return RFAILED;
4837    }
4838
4839    if(BuildPhrConfig(macCellGrpCfg->phr_Config) != ROK)
4840    {
4841       DU_LOG("\nERROR  -->  F1AP : BuildPhrConfig failed");
4842       return RFAILED;
4843    }
4844
4845    macCellGrpCfg->skipUplinkTxDynamic = false;
4846    macCellGrpCfg->ext1 = NULLP;
4847
4848    return ROK;
4849 }
4850 /*******************************************************************
4851  *
4852  * @brief Frees memeory allocated for SearchSpcToAddModList
4853  *
4854  * @details
4855  *
4856  *    Function : FreeSearchSpcToAddModList
4857  *
4858  *    Functionality: Deallocating memory of SearchSpcToAddModList
4859  *
4860  * @params[in] struct PDCCH_Config__searchSpacesToAddModList *searchSpcList
4861  *
4862  * @return void
4863  *
4864  4221 * ****************************************************************/
4865 void FreeSearchSpcToAddModList(struct PDCCH_Config__searchSpacesToAddModList *searchSpcList)
4866 {
4867    uint8_t idx1=0;
4868    uint8_t idx2=0;
4869    struct  SearchSpace *searchSpc=NULLP;
4870
4871    if(searchSpcList->list.array)
4872    {
4873       if(searchSpcList->list.array[idx2])
4874       {
4875          searchSpc = searchSpcList->list.array[idx2];
4876          if(searchSpc->controlResourceSetId)
4877          {
4878             if(searchSpc->monitoringSlotPeriodicityAndOffset)
4879             {
4880                if(searchSpc->monitoringSymbolsWithinSlot)
4881                {
4882                   if(searchSpc->monitoringSymbolsWithinSlot->buf)
4883                   {
4884                      if(searchSpc->nrofCandidates)
4885                      {
4886                         if(searchSpc->searchSpaceType)
4887                         {
4888                            DU_FREE(searchSpc->searchSpaceType->choice.ue_Specific,\
4889                                  sizeof(struct SearchSpace__searchSpaceType__ue_Specific));
4890                            DU_FREE(searchSpc->searchSpaceType, sizeof(struct
4891                                     SearchSpace__searchSpaceType));
4892                         }
4893                         DU_FREE(searchSpc->nrofCandidates,
4894                               sizeof(struct SearchSpace__nrofCandidates));
4895                      }
4896                      DU_FREE(searchSpc->monitoringSymbolsWithinSlot->buf, \
4897                            searchSpc->monitoringSymbolsWithinSlot->size);
4898                   }
4899                   DU_FREE(searchSpc->monitoringSymbolsWithinSlot,
4900                         sizeof(BIT_STRING_t));
4901                }
4902                DU_FREE(searchSpc->monitoringSlotPeriodicityAndOffset, \
4903                      sizeof(struct SearchSpace__monitoringSlotPeriodicityAndOffset));
4904             }
4905             DU_FREE(searchSpc->controlResourceSetId,
4906                   sizeof(ControlResourceSetId_t));
4907          }
4908       }
4909       for(idx1 = 0; idx1 < searchSpcList->list.count; idx1++)
4910       {
4911          DU_FREE(searchSpcList->list.array[idx1],
4912                sizeof(struct SearchSpace));
4913       }
4914       DU_FREE(searchSpcList->list.array,searchSpcList->list.size);
4915    }
4916 }
4917 /*******************************************************************
4918  *
4919  * @brief Frees memory allocated for PdschTimeDomAllocList
4920  *
4921  * @details
4922  *
4923  *    Function : FreePdschTimeDomAllocList
4924  *
4925  *    Functionality: Deallocating memory of PdschTimeDomAllocList
4926  *
4927  * @params[in] struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList
4928  *
4929  * @return void
4930  *
4931  4221 * ****************************************************************/
4932 void FreePdschTimeDomAllocList( struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList)
4933 {
4934    uint8_t idx1=0;
4935
4936    if(timeDomAllocList->choice.setup)
4937    {
4938       if(timeDomAllocList->choice.setup->list.array)
4939       {
4940          for(idx1 = 0; idx1 <timeDomAllocList->choice.setup->list.count ; idx1++)
4941          {
4942             DU_FREE(timeDomAllocList->choice.setup->list.array[idx1],
4943                   sizeof(struct PDSCH_TimeDomainResourceAllocation));
4944          }
4945          DU_FREE(timeDomAllocList->choice.setup->list.array, \
4946                timeDomAllocList->choice.setup->list.size);
4947       }
4948       DU_FREE(timeDomAllocList->choice.setup,\
4949             sizeof(struct PDSCH_TimeDomainResourceAllocationList));
4950    }
4951 }
4952 /*******************************************************************
4953  *
4954  * @brief Frees memory allocated for PuschTimeDomAllocList
4955  *
4956  *@details
4957  *
4958  *    Function : FreePuschTimeDomAllocList
4959  *
4960  *    Functionality: Deallocating memory of PuschTimeDomAllocList
4961  *
4962  * @params[in] PUSCH_Config_t *puschCfg
4963  *
4964  * @return void
4965  *
4966  * ****************************************************************/
4967 void FreePuschTimeDomAllocList(PUSCH_Config_t *puschCfg)
4968 {
4969    uint8_t idx1=0;
4970    uint8_t idx2=0;
4971    struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList_t=NULLP;
4972
4973    if(puschCfg->pusch_TimeDomainAllocationList)
4974    {
4975       timeDomAllocList_t=puschCfg->pusch_TimeDomainAllocationList;
4976       if(timeDomAllocList_t->choice.setup)
4977       {
4978          if(timeDomAllocList_t->choice.setup->list.array)
4979          {
4980             DU_FREE(timeDomAllocList_t->choice.setup->list.array[idx2]->k2, sizeof(long));
4981             for(idx1 = 0; idx1<timeDomAllocList_t->choice.setup->list.count; idx1++)
4982             {
4983                DU_FREE(timeDomAllocList_t->choice.setup->list.array[idx1],\
4984                      sizeof(PUSCH_TimeDomainResourceAllocation_t));
4985             }
4986             DU_FREE(timeDomAllocList_t->choice.setup->list.array, \
4987                   timeDomAllocList_t->choice.setup->list.size);
4988          }
4989          DU_FREE(timeDomAllocList_t->choice.setup, \
4990                sizeof(struct PUSCH_TimeDomainResourceAllocationList));
4991       }
4992       DU_FREE(puschCfg->transformPrecoder, sizeof(long));
4993       DU_FREE(puschCfg->pusch_TimeDomainAllocationList, \
4994             sizeof(struct PUSCH_Config__pusch_TimeDomainAllocationList));
4995    }
4996
4997 }
4998 /*******************************************************************
4999  *
5000  * @brief Frees memory allocated for InitialUlBWP
5001  *
5002  * @details
5003  *
5004  *    Function : FreeInitialUlBWP
5005  *
5006  *    Functionality: Deallocating memory of InitialUlBWP
5007  *
5008  * @params[in] BWP_UplinkDedicated_t *ulBwp
5009  *
5010  * @return void
5011  *
5012  * ****************************************************************/
5013 void FreeInitialUlBWP(BWP_UplinkDedicated_t *ulBwp)
5014 {
5015    uint8_t  rSetIdx, rsrcIdx;
5016    SRS_Config_t   *srsCfg = NULLP;
5017    PUSCH_Config_t *puschCfg = NULLP;
5018    struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA *dmrsUlCfg = NULLP;
5019    struct SRS_Config__srs_ResourceSetToAddModList *rsrcSetList = NULLP;
5020    struct SRS_ResourceSet__srs_ResourceIdList *rsrcIdList = NULLP;
5021    struct SRS_Config__srs_ResourceToAddModList *resourceList = NULLP;
5022
5023    if(ulBwp->pusch_Config)
5024    {
5025       if(ulBwp->pusch_Config->choice.setup)
5026       {
5027          puschCfg=ulBwp->pusch_Config->choice.setup;
5028          if(puschCfg->dataScramblingIdentityPUSCH)
5029          {
5030             if(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA)
5031             {
5032                FreePuschTimeDomAllocList(puschCfg);
5033                dmrsUlCfg=puschCfg->dmrs_UplinkForPUSCH_MappingTypeA;
5034                if(dmrsUlCfg->choice.setup)
5035                {
5036                   if(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition)
5037                   {
5038                      if(dmrsUlCfg->choice.setup->transformPrecodingDisabled)
5039                      {
5040                         DU_FREE(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0,\
5041                               sizeof(long));
5042                         DU_FREE(dmrsUlCfg->choice.setup->transformPrecodingDisabled,
5043                               sizeof(struct DMRS_UplinkConfig__transformPrecodingDisabled));
5044                      }
5045                      DU_FREE(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition,
5046                            sizeof(long));
5047                   }
5048                   DU_FREE(dmrsUlCfg->choice.setup,sizeof(DMRS_UplinkConfig_t));
5049                }
5050                DU_FREE(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA, \
5051                      sizeof(struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA));
5052             }
5053             DU_FREE(puschCfg->dataScramblingIdentityPUSCH, sizeof(long));
5054          }
5055          DU_FREE(ulBwp->pusch_Config->choice.setup, sizeof(PUSCH_Config_t));
5056       }
5057       DU_FREE(ulBwp->pusch_Config, sizeof(struct BWP_UplinkDedicated__pusch_Config));
5058
5059       /* Free SRS-Config */
5060       if(ulBwp->srs_Config)
5061       {
5062          if(ulBwp->srs_Config->choice.setup)
5063          {
5064             srsCfg = ulBwp->srs_Config->choice.setup;
5065
5066             /* Free Resource Set to add/mod list */
5067             if(srsCfg->srs_ResourceSetToAddModList)
5068             {
5069                rsrcSetList = srsCfg->srs_ResourceSetToAddModList;
5070                if(rsrcSetList->list.array)
5071                {
5072                   rSetIdx = 0;
5073
5074                   /* Free SRS resource Id list in this SRS resource set */
5075                   if(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList)
5076                   {
5077                      rsrcIdList = rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList;
5078
5079                      if(rsrcIdList->list.array)
5080                      {
5081                         for(rsrcIdx = 0; rsrcIdx < rsrcIdList->list.count; rsrcIdx++)
5082                         {
5083                            DU_FREE(rsrcIdList->list.array[rsrcIdx], sizeof(SRS_ResourceId_t));
5084                         }
5085                         DU_FREE(rsrcIdList->list.array, rsrcIdList->list.size);
5086                      }
5087                      DU_FREE(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList,\
5088                            sizeof(struct SRS_ResourceSet__srs_ResourceIdList));
5089                   }
5090
5091                   /* Free resource type info for this SRS resource set */
5092                   DU_FREE(rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic, \
5093                         sizeof(struct SRS_ResourceSet__resourceType__aperiodic));
5094
5095                   /* Free memory for each resource set */
5096                   for(rSetIdx = 0; rSetIdx < rsrcSetList->list.count; rSetIdx++)
5097                   {
5098                      DU_FREE(rsrcSetList->list.array[rSetIdx], sizeof(SRS_ResourceSet_t));
5099                   }
5100                   DU_FREE(rsrcSetList->list.array, rsrcSetList->list.size);
5101                }
5102                DU_FREE(srsCfg->srs_ResourceSetToAddModList, \
5103                      sizeof(struct SRS_Config__srs_ResourceSetToAddModList));
5104             }
5105
5106             /* Free resource to add/modd list */
5107             if(srsCfg->srs_ResourceToAddModList)
5108             {
5109                resourceList = srsCfg->srs_ResourceToAddModList;
5110                if(resourceList->list.array)
5111                {
5112                   rsrcIdx = 0;
5113                   DU_FREE(resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2,\
5114                         sizeof(struct SRS_Resource__transmissionComb__n2));
5115                   DU_FREE(resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic,\
5116                         sizeof(struct SRS_Resource__resourceType__aperiodic));
5117
5118                   for(rsrcIdx = 0; rsrcIdx < resourceList->list.count; rsrcIdx++)
5119                   {
5120                      DU_FREE(resourceList->list.array[rsrcIdx], sizeof(SRS_Resource_t));
5121                   }
5122                   DU_FREE(resourceList->list.array, resourceList->list.size);
5123                }
5124                DU_FREE(srsCfg->srs_ResourceToAddModList, \
5125                      sizeof(struct SRS_Config__srs_ResourceToAddModList));
5126             }
5127
5128             DU_FREE(ulBwp->srs_Config->choice.setup, sizeof(SRS_Config_t));
5129          }
5130          DU_FREE(ulBwp->srs_Config, sizeof(struct BWP_UplinkDedicated__srs_Config));
5131       }
5132    }
5133 }
5134 /*******************************************************************
5135  *
5136  * @brief Frees memory allocated for initialUplinkBWP
5137  *
5138  * @details
5139  *
5140  *    Function : FreeinitialUplinkBWP
5141  *
5142  *    Functionality: Deallocating memory of initialUplinkBWP
5143  *
5144  * @params[in] UplinkConfig_t *ulCfg
5145  *
5146  * @return void
5147  *
5148  *
5149  * ****************************************************************/
5150 void FreeinitialUplinkBWP(UplinkConfig_t *ulCfg)
5151 {
5152    BWP_UplinkDedicated_t *ulBwp=NULLP;
5153    struct UplinkConfig__pusch_ServingCellConfig *puschCfg=NULLP;
5154
5155    if(ulCfg->initialUplinkBWP)
5156    {
5157       ulBwp=ulCfg->initialUplinkBWP;
5158       if(ulCfg->firstActiveUplinkBWP_Id)
5159       {
5160          if(ulCfg->pusch_ServingCellConfig)
5161          {
5162             puschCfg=ulCfg->pusch_ServingCellConfig;
5163             if(puschCfg->choice.setup)
5164             {
5165                if(puschCfg->choice.setup->ext1)
5166                {
5167                   DU_FREE(puschCfg->choice.setup->ext1->\
5168                         processingType2Enabled,sizeof(BOOLEAN_t));
5169                   DU_FREE(puschCfg->choice.setup->ext1->\
5170                         maxMIMO_Layers,sizeof(long));
5171                   DU_FREE(puschCfg->choice.setup->ext1, \
5172                         sizeof(struct PUSCH_ServingCellConfig__ext1));
5173                }
5174                DU_FREE(puschCfg->choice.setup, sizeof(struct PUSCH_ServingCellConfig));
5175             }
5176             DU_FREE(ulCfg->pusch_ServingCellConfig, sizeof(struct UplinkConfig__pusch_ServingCellConfig));
5177          }
5178          DU_FREE(ulCfg->firstActiveUplinkBWP_Id, sizeof(BWP_Id_t));
5179       }
5180       FreeInitialUlBWP(ulBwp);
5181       DU_FREE(ulCfg->initialUplinkBWP, sizeof(BWP_UplinkDedicated_t));
5182    }
5183 }
5184 /*******************************************************************
5185  *
5186  * @brief Frees emmory allocated for BWPDlDedPdschCfg
5187  *
5188  * @details
5189  *
5190  *    Function : FreeBWPDlDedPdschCfg
5191  *
5192  *    Functionality: Deallocating memory of BWPDlDedPdschCfg
5193  *
5194  * @params[in] BWP_DownlinkDedicated_t *dlBwp
5195  *
5196  * @return void
5197  *
5198  *
5199  * ****************************************************************/
5200 void FreeBWPDlDedPdschCfg(BWP_DownlinkDedicated_t *dlBwp)
5201 {
5202    struct PDSCH_Config *pdschCfg=NULLP;
5203    struct PDSCH_Config__prb_BundlingType *prbBndlType=NULLP;
5204    struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList=NULLP;
5205    struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA *dmrsDlCfg=NULLP;
5206
5207    if(dlBwp->pdsch_Config->choice.setup)
5208    {
5209       pdschCfg=dlBwp->pdsch_Config->choice.setup;
5210       if(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA)
5211       {
5212          if(pdschCfg->pdsch_TimeDomainAllocationList)
5213          {
5214             timeDomAllocList=pdschCfg->pdsch_TimeDomainAllocationList;
5215             if(pdschCfg->maxNrofCodeWordsScheduledByDCI)
5216             {
5217                prbBndlType=&pdschCfg->prb_BundlingType;
5218                DU_FREE(prbBndlType->choice.staticBundling,\
5219                      sizeof(struct PDSCH_Config__prb_BundlingType__staticBundling));
5220                DU_FREE(pdschCfg->maxNrofCodeWordsScheduledByDCI, sizeof(long));
5221             }
5222             FreePdschTimeDomAllocList(timeDomAllocList);
5223             DU_FREE(pdschCfg->pdsch_TimeDomainAllocationList, \
5224                   sizeof(struct PDSCH_Config__pdsch_TimeDomainAllocationList));
5225          }
5226          dmrsDlCfg=pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA;
5227          if(dmrsDlCfg->choice.setup)
5228          {
5229             DU_FREE(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition,
5230                   sizeof(long));
5231             DU_FREE(dmrsDlCfg->choice.setup, sizeof(struct DMRS_DownlinkConfig));
5232          }
5233          DU_FREE(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA, \
5234                sizeof(struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA));
5235       }
5236       DU_FREE(dlBwp->pdsch_Config->choice.setup, sizeof(struct PDSCH_Config));
5237    }
5238 }
5239 /*******************************************************************
5240  *
5241  * @brief Frees emmory allocated for BWPDlDedPdcchCfg
5242  *
5243  * @details
5244  *
5245  *    Function : FreeBWPDlDedPdcchCfg
5246  *
5247  *    Functionality: Deallocating memory of BWPDlDedPdcchCfg
5248  *
5249  * @params[in] BWP_DownlinkDedicated_t *dlBwp
5250  *
5251  * @return void
5252  *
5253  *
5254  * ****************************************************************/
5255 void FreeBWPDlDedPdcchCfg(BWP_DownlinkDedicated_t *dlBwp)
5256 {
5257    uint8_t idx1=0;
5258    uint8_t idx2=0;
5259    struct PDCCH_Config *pdcchCfg=NULLP;
5260    struct ControlResourceSet *controlRSet=NULLP;
5261    struct PDCCH_Config__controlResourceSetToAddModList *controlRSetList=NULLP;
5262
5263    if(dlBwp->pdcch_Config->choice.setup)
5264    {
5265       pdcchCfg=dlBwp->pdcch_Config->choice.setup;
5266       if(pdcchCfg->controlResourceSetToAddModList)
5267       {
5268          controlRSetList = pdcchCfg->controlResourceSetToAddModList;
5269          if(controlRSetList->list.array)
5270          {
5271             controlRSet = controlRSetList->list.array[idx2];
5272             if(controlRSet)
5273             {
5274                if(controlRSet->frequencyDomainResources.buf)
5275                {
5276                   if(controlRSet->pdcch_DMRS_ScramblingID)
5277                   {
5278                      if(pdcchCfg->searchSpacesToAddModList)
5279                      {
5280                         FreeSearchSpcToAddModList(pdcchCfg->searchSpacesToAddModList);
5281                         DU_FREE(pdcchCfg->searchSpacesToAddModList, \
5282                               sizeof(struct PDCCH_Config__searchSpacesToAddModList));
5283                      }
5284                      DU_FREE(controlRSet->pdcch_DMRS_ScramblingID, sizeof(long));
5285                   }
5286                   DU_FREE(controlRSet->frequencyDomainResources.buf, \
5287                         controlRSet->frequencyDomainResources.size);
5288                }
5289             }
5290             for(idx1 = 0; idx1 <controlRSetList->list.count; idx1++)
5291             {
5292                DU_FREE(controlRSetList->list.array[idx1], sizeof(struct ControlResourceSet));
5293             }
5294             DU_FREE(controlRSetList->list.array, controlRSetList->list.size);
5295          }
5296          DU_FREE(pdcchCfg->controlResourceSetToAddModList, \
5297                sizeof(struct PDCCH_Config__controlResourceSetToAddModList));
5298       }
5299       DU_FREE(dlBwp->pdcch_Config->choice.setup, sizeof(struct PDCCH_Config));
5300    }
5301 }
5302
5303 /*******************************************************************
5304  *
5305  * @brief Frees emmory allocated for DUToCURRCContainer
5306  *
5307  * @details
5308  *
5309  *    Function : FreeMemDuToCuRrcCont
5310  *
5311  *    Functionality: Deallocating memory of DuToCuRrcContainer
5312  *
5313  * @params[in] DuToCuRRCContainer, DuToCuRRCContainer
5314  *
5315  * @return ROK     - success
5316  *         RFAILED - failure
5317  *
5318  * ****************************************************************/
5319 uint8_t FreeMemDuToCuRrcCont(CellGroupConfigRrc_t *cellGrpCfg)
5320 {
5321    uint8_t idx=0;
5322    SpCellConfig_t *spCellCfg=NULLP;
5323    ServingCellConfig_t *srvCellCfg=NULLP;
5324    BWP_DownlinkDedicated_t *dlBwp=NULLP;
5325    MAC_CellGroupConfig_t *macCellGrpCfg=NULLP;
5326    PhysicalCellGroupConfig_t *phyCellGrpCfg=NULLP;
5327    struct CellGroupConfigRrc__rlc_BearerToAddModList *rlcBearerList=NULLP;
5328    struct RLC_Config *rlcConfig=NULLP;
5329    struct LogicalChannelConfig *macLcConfig=NULLP;
5330    struct SchedulingRequestConfig *schedulingRequestConfig=NULLP;
5331    struct SchedulingRequestConfig__schedulingRequestToAddModList *schReqList=NULLP;
5332    struct TAG_Config *tagConfig=NULLP;
5333    struct TAG_Config__tag_ToAddModList *tagList=NULLP;
5334    struct MAC_CellGroupConfig__phr_Config *phrConfig=NULLP;
5335    struct ServingCellConfig__pdsch_ServingCellConfig *pdschCfg=NULLP;
5336
5337    rlcBearerList = cellGrpCfg->rlc_BearerToAddModList;
5338    if(rlcBearerList)
5339    {
5340       if(rlcBearerList->list.array)
5341       {
5342          for(idx=0; idx<rlcBearerList->list.count; idx++)
5343          {
5344             if(rlcBearerList->list.array[idx])
5345             {
5346                rlcConfig   = rlcBearerList->list.array[idx]->rlc_Config;
5347                macLcConfig = rlcBearerList->list.array[idx]->mac_LogicalChannelConfig;
5348                if(rlcConfig)
5349                {
5350                   if(rlcConfig->choice.am)
5351                   {
5352                      DU_FREE(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
5353                      DU_FREE(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
5354                      DU_FREE(rlcConfig->choice.am, sizeof(struct RLC_Config__am));
5355                   }
5356                   DU_FREE(rlcConfig, sizeof(struct RLC_Config));
5357                }
5358                DU_FREE(rlcBearerList->list.array[idx]->servedRadioBearer, sizeof(struct RLC_BearerConfig__servedRadioBearer));
5359                if(macLcConfig)
5360                {
5361                   if(macLcConfig->ul_SpecificParameters)
5362                   {
5363                      DU_FREE(macLcConfig->ul_SpecificParameters->schedulingRequestID,   sizeof(SchedulingRequestId_t));
5364                      DU_FREE(macLcConfig->ul_SpecificParameters->logicalChannelGroup,   sizeof(long));
5365                      DU_FREE(macLcConfig->ul_SpecificParameters, sizeof(struct LogicalChannelConfig__ul_SpecificParameters));
5366                   }
5367                   DU_FREE(rlcBearerList->list.array[idx]->mac_LogicalChannelConfig, sizeof(struct LogicalChannelConfig));
5368                }
5369                DU_FREE(rlcBearerList->list.array[idx], sizeof(struct RLC_BearerConfig));
5370             }
5371          }
5372          DU_FREE(rlcBearerList->list.array, rlcBearerList->list.size);
5373       }
5374       DU_FREE(cellGrpCfg->rlc_BearerToAddModList, sizeof(struct CellGroupConfigRrc__rlc_BearerToAddModList));
5375    }
5376
5377    macCellGrpCfg = cellGrpCfg->mac_CellGroupConfig;
5378    if(macCellGrpCfg)
5379    {
5380       schedulingRequestConfig = macCellGrpCfg->schedulingRequestConfig;
5381       if(schedulingRequestConfig)
5382       {
5383          schReqList = schedulingRequestConfig->schedulingRequestToAddModList;
5384          if(schReqList)
5385          {
5386             if(schReqList->list.array)
5387             {
5388                for(idx=0;idx<schReqList->list.count; idx++)
5389                {
5390                   if(schReqList->list.array[idx])
5391                   {
5392                      DU_FREE(schReqList->list.array[idx]->sr_ProhibitTimer, sizeof(long));
5393                      DU_FREE(schReqList->list.array[idx], sizeof(struct SchedulingRequestToAddMod));
5394                   }
5395                }
5396                DU_FREE(schReqList->list.array, schReqList->list.size);
5397             }
5398             DU_FREE(schedulingRequestConfig->schedulingRequestToAddModList,\
5399                   sizeof(struct SchedulingRequestConfig__schedulingRequestToAddModList));    }
5400             DU_FREE(macCellGrpCfg->schedulingRequestConfig, sizeof(struct SchedulingRequestConfig));
5401       }
5402       if(macCellGrpCfg->bsr_Config)
5403       {
5404          DU_FREE(macCellGrpCfg->bsr_Config, sizeof(struct BSR_Config));
5405       }
5406       tagConfig = macCellGrpCfg->tag_Config;
5407       if(tagConfig)
5408       {
5409          tagList = tagConfig->tag_ToAddModList;
5410          if(tagList)
5411          {
5412             if(tagList->list.array)
5413             {
5414                for(idx=0; idx<tagList->list.count; idx++)
5415                {
5416                   DU_FREE(tagList->list.array[idx], sizeof(struct TAG));
5417                }
5418                DU_FREE(tagList->list.array, tagList->list.size);
5419             }
5420             DU_FREE(tagConfig->tag_ToAddModList, sizeof(struct TAG_Config__tag_ToAddModList));
5421          }
5422          DU_FREE(tagConfig, sizeof(struct TAG_Config));
5423       }
5424
5425       phrConfig = macCellGrpCfg->phr_Config;
5426       if(phrConfig)
5427       {
5428          DU_FREE(phrConfig->choice.setup, sizeof(struct PHR_Config));
5429          DU_FREE(phrConfig, sizeof(struct MAC_CellGroupConfig__phr_Config));
5430       }
5431
5432       DU_FREE(macCellGrpCfg, sizeof(MAC_CellGroupConfig_t));
5433    }
5434
5435    phyCellGrpCfg = cellGrpCfg->physicalCellGroupConfig;
5436    if(phyCellGrpCfg)
5437    {
5438       DU_FREE(phyCellGrpCfg->p_NR_FR1, sizeof(long));
5439       DU_FREE(phyCellGrpCfg, sizeof(PhysicalCellGroupConfig_t));
5440    }
5441
5442    spCellCfg = cellGrpCfg->spCellConfig;
5443    if(spCellCfg)
5444    {
5445       if(spCellCfg->servCellIndex)
5446       {
5447          if(spCellCfg->rlmInSyncOutOfSyncThreshold)
5448          {
5449             if(spCellCfg->spCellConfigDedicated)
5450             {
5451                srvCellCfg = spCellCfg->spCellConfigDedicated;
5452                if(srvCellCfg->tdd_UL_DL_ConfigurationDedicated)
5453                {
5454                   if(srvCellCfg->initialDownlinkBWP)
5455                   {
5456                      dlBwp = srvCellCfg->initialDownlinkBWP;
5457                      if(srvCellCfg->firstActiveDownlinkBWP_Id)
5458                      {
5459                         if(srvCellCfg->defaultDownlinkBWP_Id)
5460                         {
5461                            if(srvCellCfg->uplinkConfig)
5462                            {
5463                               if(srvCellCfg->pdsch_ServingCellConfig)
5464                               {
5465                                  pdschCfg= srvCellCfg->pdsch_ServingCellConfig;
5466                                  if(pdschCfg->choice.setup)
5467                                  {
5468                                     DU_FREE(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH,sizeof(long));
5469                                     DU_FREE(pdschCfg->choice.setup, sizeof( struct PDSCH_ServingCellConfig));
5470                                  }
5471                                  DU_FREE(srvCellCfg->pdsch_ServingCellConfig, sizeof(struct
5472                                        ServingCellConfig__pdsch_ServingCellConfig));
5473                               }
5474                               FreeinitialUplinkBWP(srvCellCfg->uplinkConfig);
5475                               DU_FREE(srvCellCfg->uplinkConfig, sizeof(UplinkConfig_t));
5476                            }
5477                            DU_FREE(srvCellCfg->defaultDownlinkBWP_Id, sizeof(long));
5478                         }
5479                         DU_FREE(srvCellCfg->firstActiveDownlinkBWP_Id, sizeof(long));
5480                      }
5481                      if(dlBwp->pdcch_Config)
5482                      {
5483                         if(dlBwp->pdsch_Config)
5484                         {
5485                            FreeBWPDlDedPdschCfg(dlBwp);
5486                            DU_FREE(dlBwp->pdsch_Config, sizeof(struct BWP_DownlinkDedicated__pdsch_Config));
5487                         }
5488                         FreeBWPDlDedPdcchCfg(dlBwp);
5489                         DU_FREE(dlBwp->pdcch_Config, sizeof(struct BWP_DownlinkDedicated__pdcch_Config));
5490                     }
5491                     DU_FREE(srvCellCfg->initialDownlinkBWP, sizeof(BWP_DownlinkDedicated_t));
5492                   }
5493                   DU_FREE(srvCellCfg->tdd_UL_DL_ConfigurationDedicated, sizeof(TDD_UL_DL_ConfigDedicated_t));
5494                }
5495                DU_FREE(spCellCfg->spCellConfigDedicated, sizeof(ServingCellConfig_t));
5496             }
5497             DU_FREE(spCellCfg->rlmInSyncOutOfSyncThreshold, sizeof(long));
5498          }
5499          DU_FREE(spCellCfg->servCellIndex, sizeof(long));
5500       }
5501       DU_FREE(spCellCfg,sizeof(SpCellConfig_t));
5502    }
5503    return ROK;
5504 }
5505 /*******************************************************************
5506  *
5507  * @brief Builds DU To CU RRC Container
5508  *
5509  * @details
5510  *
5511  *    Function : BuildDuToCuRrcContainer
5512  *
5513  *    Functionality: Builds DuToCuRrcContainer
5514  *
5515  * @params[in] idx, index in F1AP msg
5516  *             DuToCuRRCContainer, DuToCuRRCContainer
5517  *
5518  * @return ROK     - success
5519  *         RFAILED - failure
5520  *
5521  * ****************************************************************/
5522 uint8_t BuildDuToCuRrcContainer(DUtoCURRCContainer_t *duToCuRrcContainer)
5523 {
5524    uint8_t  ret = ROK;
5525    CellGroupConfigRrc_t  cellGrpCfg;
5526    asn_enc_rval_t        encRetVal;
5527    memset(&cellGrpCfg, 0, sizeof(CellGroupConfigRrc_t));
5528    memset(&encRetVal, 0, sizeof(asn_enc_rval_t));
5529
5530    while(true)
5531    {
5532       cellGrpCfg.cellGroupId = CELL_GRP_ID;
5533
5534       cellGrpCfg.rlc_BearerToAddModList = NULLP;
5535       DU_ALLOC(cellGrpCfg.rlc_BearerToAddModList, sizeof(struct CellGroupConfigRrc__rlc_BearerToAddModList));
5536       if(!cellGrpCfg.rlc_BearerToAddModList)
5537       {
5538          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildDuToCuRrcContainer");
5539          ret = RFAILED;
5540          break;
5541       }
5542       if(BuildRlcBearerToAddModList(cellGrpCfg.rlc_BearerToAddModList) != ROK)
5543       {
5544          DU_LOG("\nERROR  -->  F1AP : BuildRlcBearerToAddModList failed");
5545          ret = RFAILED;
5546          break;
5547       }
5548
5549       cellGrpCfg.rlc_BearerToReleaseList = NULLP;
5550       cellGrpCfg.mac_CellGroupConfig = NULLP;
5551       DU_ALLOC(cellGrpCfg.mac_CellGroupConfig, sizeof(MAC_CellGroupConfig_t));
5552       if(!cellGrpCfg.mac_CellGroupConfig)
5553       {
5554          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildDuToCuRrcContainer");
5555          ret = RFAILED;
5556          break;
5557       }
5558       if(BuildMacCellGrpCfg(cellGrpCfg.mac_CellGroupConfig) != ROK)
5559       {
5560          DU_LOG("\nERROR  -->  F1AP : BuildMacCellGrpCfg failed");
5561          ret = RFAILED;
5562          break;
5563       }
5564
5565       cellGrpCfg.physicalCellGroupConfig = NULLP;
5566       DU_ALLOC(cellGrpCfg.physicalCellGroupConfig, sizeof(PhysicalCellGroupConfig_t));
5567       if(!cellGrpCfg.physicalCellGroupConfig)
5568       {
5569          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildDuToCuRrcContainer");
5570          ret = RFAILED;
5571          break;
5572       }
5573       if(BuildPhyCellGrpCfg(cellGrpCfg.physicalCellGroupConfig) != ROK)
5574       {
5575          DU_LOG("\nERROR  -->  F1AP : BuildPhyCellGrpCfg failed");
5576          ret = RFAILED;
5577          break;
5578       }
5579
5580       cellGrpCfg.spCellConfig = NULLP;
5581       DU_ALLOC(cellGrpCfg.spCellConfig, sizeof(SpCellConfig_t));
5582       if(!cellGrpCfg.spCellConfig)
5583       {
5584          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildDuToCuRrcContainer");
5585          ret = RFAILED;
5586          break;
5587       }
5588       if(BuildSpCellCfg(cellGrpCfg.spCellConfig) != ROK)
5589       {
5590          DU_LOG("\nERROR  -->  F1AP : BuildSpCellCfg failed");
5591          ret = RFAILED;
5592          break;
5593       }
5594
5595       cellGrpCfg.sCellToAddModList = NULLP;
5596       cellGrpCfg.sCellToReleaseList = NULLP;
5597       cellGrpCfg.ext1 = NULLP;
5598
5599       /* encode cellGrpCfg into duToCuRrcContainer */
5600       xer_fprint(stdout, &asn_DEF_CellGroupConfigRrc, &cellGrpCfg);
5601       memset(encBuf, 0, ENC_BUF_MAX_LEN);
5602       encBufSize = 0;
5603       encRetVal = aper_encode(&asn_DEF_CellGroupConfigRrc, 0, &cellGrpCfg, PrepFinalEncBuf, encBuf);
5604       /* Encode results */
5605       if(encRetVal.encoded == ENCODE_FAIL)
5606       {
5607          DU_LOG( "\nERROR  --> F1AP : Could not encode DuToCuRrcContainer (at %s)\n",\
5608                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
5609          ret = RFAILED;
5610          break;
5611       }
5612       else
5613       {
5614          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for DuToCuRrcContainer\n");
5615          for(int i=0; i< encBufSize; i++)
5616          {
5617             printf("%x",encBuf[i]);
5618          }
5619       }
5620
5621       duToCuRrcContainer->size = encBufSize;
5622       DU_ALLOC(duToCuRrcContainer->buf, duToCuRrcContainer->size);
5623       if(!duToCuRrcContainer->buf)
5624       {
5625          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDuToCuRrcContainer");
5626          ret = RFAILED;
5627          break;
5628       }
5629       if(ret == ROK)
5630       {
5631          memcpy(duToCuRrcContainer->buf, encBuf, duToCuRrcContainer->size);
5632       }
5633       break;
5634    }
5635    FreeMemDuToCuRrcCont(&cellGrpCfg);
5636    return ret;
5637 }
5638
5639 /*******************************************************************
5640  *
5641  * @brief Free memory allocated in InitialULRRCMessage
5642  *
5643  * @details
5644  *
5645  *    Function : freeInitUlRrcMsgTransfer
5646  *
5647  *    Functionality: Free memory allocated in InitialULRRCMessage
5648  *
5649  * @params[in]F1AP_PDU_t  *f1apMsg)
5650  *
5651  * @return ROK     - success
5652  *         RFAILED - failure
5653  *
5654  * ****************************************************************/
5655
5656 uint8_t freeInitUlRrcMsgTransfer(F1AP_PDU_t  *f1apMsg)
5657 {
5658    uint8_t ieIdx, arrIdx;
5659    InitialULRRCMessageTransfer_t *initULRRCMsg=NULLP;
5660
5661    if(f1apMsg)
5662    {
5663       if(f1apMsg->choice.initiatingMessage)
5664       {
5665          initULRRCMsg = &f1apMsg->choice.initiatingMessage->value.\
5666             choice.InitialULRRCMessageTransfer;
5667          if(initULRRCMsg->protocolIEs.list.array)
5668          {
5669             for(ieIdx = 0; ieIdx < initULRRCMsg->protocolIEs.list.count; ieIdx++)
5670             {
5671                switch(initULRRCMsg->protocolIEs.list.array[ieIdx]->id)
5672                {
5673                   case ProtocolIE_ID_id_NRCGI:
5674                   {
5675                      if(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.pLMN_Identity.buf)
5676                      {
5677                         if(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.nRCellIdentity.buf)
5678                         {
5679                            DU_FREE(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.nRCellIdentity.buf,\
5680                            initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.nRCellIdentity.size);
5681                         }
5682                         DU_FREE(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.pLMN_Identity.buf,\
5683                         initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.pLMN_Identity.size);
5684                      }
5685                      break;
5686                   }
5687                   case ProtocolIE_ID_id_RRCContainer:
5688                   {
5689                      if(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf)
5690                      {
5691                         DU_FREE(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf,\
5692                         initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.size);
5693                      }
5694                      break;
5695                   }
5696                   case ProtocolIE_ID_id_DUtoCURRCContainer:
5697                   {
5698                      if(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.DUtoCURRCContainer.buf)
5699                      {
5700                         DU_FREE(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.DUtoCURRCContainer.buf,
5701                         initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.DUtoCURRCContainer.size);
5702                      }
5703                      break;
5704                   }
5705                   default:
5706                      break;
5707                }
5708              }
5709              for(arrIdx = 0; arrIdx < ieIdx; arrIdx++)
5710              {
5711                 if(initULRRCMsg->protocolIEs.list.array[arrIdx])
5712                 {
5713                    DU_FREE(initULRRCMsg->protocolIEs.list.array[arrIdx],\
5714                       sizeof(InitialULRRCMessageTransferIEs_t));
5715                 }
5716              }
5717              DU_FREE(initULRRCMsg->protocolIEs.list.array, initULRRCMsg->protocolIEs.list.size);
5718           }
5719          DU_FREE(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
5720       }
5721       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
5722    }
5723    else
5724    {
5725       DU_LOG("\nERROR  -->  DU_APP : Recevied F1ap Pdu is null at freeInitUlRrcMsgTransfer()");
5726       return RFAILED;
5727    }
5728    return ROK;
5729 }
5730
5731 /*******************************************************************
5732  *
5733  * @brief Builds and sends the InitialULRRCMessage
5734  *
5735  * @details
5736  *
5737  *    Function : BuildAndSendInitialRrcMsgTransfer
5738  *
5739  *    Functionality: Constructs the Initial UL RRC Message Transfer and sends
5740  *                   it to the CU through SCTP.
5741  *
5742  * @params[in]
5743  *
5744  * @return ROK     - success
5745  *         RFAILED - failure
5746  *
5747  * ****************************************************************/
5748 uint8_t BuildAndSendInitialRrcMsgTransfer(uint32_t gnbDuUeF1apId, uint16_t crnti,
5749       uint16_t rrcContSize, uint8_t *rrcContainer)
5750 {
5751    uint8_t   ret;
5752    uint8_t   elementCnt;
5753    uint8_t   ieIdx;
5754    asn_enc_rval_t  encRetVal;
5755    F1AP_PDU_t  *f1apMsg = NULLP;
5756    InitialULRRCMessageTransfer_t *initULRRCMsg = NULLP;
5757    memset(&encRetVal, 0, sizeof(asn_enc_rval_t));
5758
5759    while(true)
5760    {
5761       DU_LOG("\n INFO   -->  F1AP : Building RRC Setup Request\n");
5762       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
5763       if(f1apMsg == NULLP)
5764       {
5765          DU_LOG(" ERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
5766          break;
5767       }
5768       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
5769       DU_ALLOC(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
5770       if(f1apMsg->choice.initiatingMessage == NULLP)
5771       {
5772          DU_LOG(" ERROR  -->  F1AP : Memory allocation for  F1AP-PDU failed");
5773          break;
5774       }
5775       f1apMsg->choice.initiatingMessage->procedureCode =\
5776                                                         ProcedureCode_id_InitialULRRCMessageTransfer;
5777       f1apMsg->choice.initiatingMessage->criticality = Criticality_ignore;
5778       f1apMsg->choice.initiatingMessage->value.present = \
5779                                                          InitiatingMessage__value_PR_InitialULRRCMessageTransfer;
5780       initULRRCMsg =\
5781                     &f1apMsg->choice.initiatingMessage->value.choice.InitialULRRCMessageTransfer;
5782       elementCnt = 5;
5783       initULRRCMsg->protocolIEs.list.count = elementCnt;
5784       initULRRCMsg->protocolIEs.list.size = \
5785                                             elementCnt * sizeof(InitialULRRCMessageTransferIEs_t *);
5786       /* Initialize the F1Setup members */
5787       DU_ALLOC(initULRRCMsg->protocolIEs.list.array,initULRRCMsg->protocolIEs.list.size);
5788       if(initULRRCMsg->protocolIEs.list.array == NULLP)
5789       {
5790          DU_LOG(" ERROR  -->  F1AP : Memory allocation for\
5791                RRCSetupRequestMessageTransferIEs failed");
5792          break;
5793       }
5794       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
5795       {
5796          DU_ALLOC(initULRRCMsg->protocolIEs.list.array[ieIdx],\
5797                sizeof(InitialULRRCMessageTransferIEs_t));
5798          if(initULRRCMsg->protocolIEs.list.array[ieIdx] == NULLP)
5799          {
5800             break;
5801          }
5802       }
5803       ieIdx = 0;
5804       /*GNB DU UE F1AP ID*/
5805       initULRRCMsg->protocolIEs.list.array[ieIdx]->id  = \
5806                                                         ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
5807       initULRRCMsg->protocolIEs.list.array[ieIdx]->criticality  = Criticality_reject;
5808       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.present = \
5809                                                                   InitialULRRCMessageTransferIEs__value_PR_GNB_DU_UE_F1AP_ID;
5810       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID = gnbDuUeF1apId;
5811
5812
5813       /*NRCGI*/
5814       ieIdx++;
5815       initULRRCMsg->protocolIEs.list.array[ieIdx]->id  = \
5816                                                         ProtocolIE_ID_id_NRCGI;
5817       initULRRCMsg->protocolIEs.list.array[ieIdx]->criticality  =Criticality_reject;
5818       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.present = \
5819                                                                   InitialULRRCMessageTransferIEs__value_PR_NRCGI;
5820
5821       ret =\
5822            BuildNrcgi(&initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI);
5823       if(ret!=ROK)
5824       {
5825          break;
5826       }
5827
5828       /*CRNTI*/
5829       ieIdx++;
5830       initULRRCMsg->protocolIEs.list.array[ieIdx]->id  = \
5831                                                         ProtocolIE_ID_id_C_RNTI;
5832       initULRRCMsg->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
5833       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.present =\
5834                                                                  InitialULRRCMessageTransferIEs__value_PR_C_RNTI;
5835       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.C_RNTI = crnti;
5836
5837       /*RRCContainer*/
5838       ieIdx++;
5839       initULRRCMsg->protocolIEs.list.array[ieIdx]->id  = \
5840                                                         ProtocolIE_ID_id_RRCContainer;
5841       initULRRCMsg->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
5842       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.present =\
5843                                                                  InitialULRRCMessageTransferIEs__value_PR_RRCContainer;
5844
5845       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.size = rrcContSize;
5846       DU_ALLOC(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf,
5847             initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.size)
5848       if(!initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf)
5849       {
5850          DU_LOG(" ERROR  -->  F1AP : Memory allocation for RRCSetupRequestMessageTransferIEs failed");
5851          break;
5852
5853       }
5854       memcpy(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf, rrcContainer,
5855             initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.size);
5856
5857
5858       /*DUtoCURRCContainer*/
5859       ieIdx++;
5860       initULRRCMsg->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_DUtoCURRCContainer;
5861       initULRRCMsg->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
5862       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.present =\
5863                                                                  InitialULRRCMessageTransferIEs__value_PR_DUtoCURRCContainer;
5864
5865       ret = BuildDuToCuRrcContainer(&initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.DUtoCURRCContainer);
5866       if(ret != ROK)
5867       {
5868          break;
5869       }
5870
5871       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
5872
5873       /* Encode the F1SetupRequest type as APER */
5874       memset(encBuf, 0, ENC_BUF_MAX_LEN);
5875       encBufSize = 0;
5876       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
5877       /* Encode results */
5878       if(encRetVal.encoded == ENCODE_FAIL)
5879       {
5880          DU_LOG( "\nERROR  --> F1AP : Could not encode Initial UL RRC Message Transfer\
5881                structure (at %s)\n",encRetVal.failed_type ? \
5882                encRetVal.failed_type->name : "unknown");
5883          ret = RFAILED;
5884          break;
5885       }
5886       else
5887       {
5888
5889          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for Initial UL RRC\
5890                Message transfer\n");
5891          for(int i=0; i< encBufSize; i++)
5892          {
5893             printf("%x",encBuf[i]);
5894          }
5895       }
5896       /* Sending  msg  */
5897       if(SendF1APMsg(DU_APP_MEM_REGION,DU_POOL) != ROK)
5898       {
5899          DU_LOG("\nERROR  -->  F1AP : Sending Initial UL RRC Message Transfer Failed");
5900          ret = RFAILED;
5901          break;
5902       }
5903       break;
5904    }
5905    freeInitUlRrcMsgTransfer(f1apMsg);
5906    return ret;
5907 }/* End of BuildAndSendInitialRrcMsgTransfer*/
5908
5909 /*****  UE SETUP REQUEST *****/
5910
5911 /*******************************************************************
5912  *
5913  * @brief Free Qos And Snssai Drb Info
5914  *
5915  * @details
5916  *
5917  *    Function : freeDrbQosAndSnssaiInfo
5918  *
5919  *    Functionality: Free Qos And Snssai Drb Info
5920  *
5921  * @params[in] LcCfg *lcCfg,
5922  * @return void
5923  *
5924  * ****************************************************************/
5925 void freeDrbQosAndSnssaiInfo(LcCfg *lcCfg)
5926 {
5927    if(lcCfg->snssai)
5928    {
5929       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->snssai, sizeof(Snssai));
5930    }
5931    if(lcCfg->drbQos)
5932    {
5933       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->drbQos, sizeof(DrbQosInfo));
5934    }
5935 }
5936
5937 /******************************************************************
5938 *
5939 * @brief Function to delete the RLC Lc cfg from UE APP DB
5940 *
5941 * @details
5942 *
5943 *  Function : freeRlcLcCfg
5944 *
5945 *  Functionality: Function to delete the RLC Lc cfg from UE APP DB
5946 *
5947 *
5948  *****************************************************************/
5949
5950 void freeRlcLcCfg(RlcBearerCfg *lcCfg)
5951 {
5952    switch(lcCfg->rlcMode)
5953    {
5954       case RLC_AM :
5955       {
5956          if(lcCfg->u.amCfg)
5957          {
5958             DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->u.amCfg, sizeof(AmBearerCfg));
5959             lcCfg->u.amCfg = NULLP;
5960          }
5961          break;
5962       }
5963       case RLC_UM_BI_DIRECTIONAL :
5964       {
5965          if(lcCfg->u.umBiDirCfg)
5966          {
5967             DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->u.umBiDirCfg, sizeof(UmBiDirBearerCfg));
5968             lcCfg->u.umBiDirCfg = NULLP;
5969          }
5970          break;
5971       }
5972       case RLC_UM_UNI_DIRECTIONAL_UL :
5973       {
5974          if(lcCfg->u.umUniDirUlCfg)
5975          {
5976             DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->u.umUniDirUlCfg, sizeof(UmUniDirUlBearerCfg));
5977             lcCfg->u.umUniDirUlCfg = NULLP;
5978          }
5979          break;
5980
5981       }
5982       case RLC_UM_UNI_DIRECTIONAL_DL :
5983       {
5984          if(lcCfg->u.umUniDirDlCfg)
5985          {
5986             DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->u.umUniDirDlCfg, sizeof(UmUniDirDlBearerCfg));
5987             lcCfg->u.umUniDirDlCfg = NULLP;
5988          }
5989          break;
5990       }
5991       default:
5992          DU_LOG("\nERROR  -->  DU_APP: Invalid Rlc Mode %d at freeRlcLcCfg()", lcCfg->rlcMode);
5993          break;
5994    }
5995    memset(lcCfg, 0, sizeof(LcCfg));
5996 }
5997 /*******************************************************************
5998  *
5999  * @brief Function to free MacLcCfg
6000  *
6001  * @details
6002  *
6003  *    Function : freeMacLcCfg
6004  *
6005  *    Functionality: Function to free MacLcCfg
6006  *
6007  * @params[in] LcCfg *lcCfg,
6008  * @return void
6009  *
6010  * ****************************************************************/
6011
6012 void  freeMacLcCfg(LcCfg *lcCfg)
6013 {
6014     /* Deleting DRBQOS */
6015    if(lcCfg->drbQos)
6016    {
6017       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->drbQos, sizeof(DrbQosInfo));
6018       lcCfg->drbQos = NULLP;
6019    }
6020    /* Deleting SNSSAI */
6021    if(lcCfg->snssai)
6022    {
6023       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->snssai, sizeof(Snssai));
6024       lcCfg->snssai = NULLP;
6025    }
6026    memset(lcCfg, 0, sizeof(LcCfg));
6027 }
6028 /*******************************************************************
6029  *
6030  * @brief Free UE NR Capability received in UE Context setup request
6031  *
6032  * @details
6033  *
6034  *    Function : freeAperDecodeUeNrCapability
6035  *
6036  *    Functionality:
6037  *       Free UE NR Capability received in UE Context setup request
6038  *
6039  * @params[in]
6040  * @return ROK     - success
6041  *         RFAILED - failure
6042  *
6043  * ****************************************************************/
6044 void freeAperDecodeUeNrCapability(void *ueNrCapability)
6045 {
6046    uint8_t arrIdx =0;
6047    FeatureSets_t *featureSets =NULLP;
6048    UE_NR_Capability_t *ueNrCap = (UE_NR_Capability_t *)ueNrCapability;
6049
6050    if(ueNrCap->rf_Parameters.supportedBandListNR.list.array)
6051    {
6052       for(arrIdx = 0; arrIdx < ueNrCap->rf_Parameters.supportedBandListNR.list.count; arrIdx++)
6053       {
6054          if(ueNrCap->rf_Parameters.supportedBandListNR.list.array[arrIdx])
6055             free(ueNrCap->rf_Parameters.supportedBandListNR.list.array[arrIdx]);
6056       }
6057       free(ueNrCap->rf_Parameters.supportedBandListNR.list.array);
6058    }
6059
6060    if(ueNrCap->featureSets)
6061    {
6062       featureSets = ueNrCap->featureSets;
6063       if(featureSets->featureSetsDownlinkPerCC)
6064       {
6065          if(featureSets->featureSetsDownlinkPerCC->list.array)
6066          {
6067             for(arrIdx = 0; arrIdx < featureSets->featureSetsDownlinkPerCC->list.count; arrIdx++)
6068             {
6069                if(featureSets->featureSetsDownlinkPerCC->list.array[arrIdx])
6070                {
6071                   if(featureSets->featureSetsDownlinkPerCC->list.array[arrIdx]->supportedModulationOrderDL)
6072                      free(featureSets->featureSetsDownlinkPerCC->list.array[arrIdx]->supportedModulationOrderDL);
6073                   free(featureSets->featureSetsDownlinkPerCC->list.array[arrIdx]);
6074                }
6075             }
6076             free(featureSets->featureSetsDownlinkPerCC->list.array);
6077          }
6078          free(featureSets->featureSetsDownlinkPerCC);
6079       }
6080       if(featureSets->featureSetsUplinkPerCC)
6081       {
6082          if(featureSets->featureSetsUplinkPerCC->list.array)
6083          {
6084             for(arrIdx = 0; arrIdx < featureSets->featureSetsUplinkPerCC->list.count; arrIdx++)
6085             {
6086                if(featureSets->featureSetsUplinkPerCC->list.array[arrIdx])
6087                {
6088                   if(featureSets->featureSetsUplinkPerCC->list.array[arrIdx]->supportedModulationOrderUL)
6089                      free(featureSets->featureSetsUplinkPerCC->list.array[arrIdx]->supportedModulationOrderUL);
6090                   free(featureSets->featureSetsUplinkPerCC->list.array[arrIdx]);
6091                }
6092             }
6093             free(featureSets->featureSetsUplinkPerCC->list.array);
6094          }
6095          free(featureSets->featureSetsUplinkPerCC);
6096       }
6097       free(ueNrCap->featureSets);
6098    }
6099 }
6100
6101 /*******************************************************************
6102 *
6103 * @brief Function to free PdcchSearchSpcToAddModList
6104          where memory allocated by aper_decoder
6105 *
6106 * @details
6107 *
6108 *    Function : freeAperDecodePdcchSearchSpcToAddModList
6109 *
6110 *    Functionality: Function to free PdcchSearchSpcToAddModList
6111 *
6112 * @params[in] struct PDCCH_Config__searchSpacesToAddModList *searchSpcList
6113 * @return void
6114 *
6115 * ****************************************************************/
6116
6117 void freeAperDecodePdcchSearchSpcToAddModList(struct PDCCH_Config__searchSpacesToAddModList *searchSpcList)
6118 {
6119    uint8_t searchSpcArrIdx=0;
6120    uint8_t searchSpcArrIdx1=0;
6121    struct  SearchSpace *searchSpc=NULLP;
6122
6123
6124    if(searchSpcList->list.array)
6125    {
6126       if(searchSpcList->list.array[searchSpcArrIdx1])
6127       {
6128          searchSpc = searchSpcList->list.array[searchSpcArrIdx1];
6129          if(searchSpc->controlResourceSetId)
6130          {
6131             if(searchSpc->monitoringSlotPeriodicityAndOffset)
6132             {
6133                if(searchSpc->monitoringSymbolsWithinSlot)
6134                {
6135                   if(searchSpc->monitoringSymbolsWithinSlot->buf)
6136                   {
6137                      if(searchSpc->nrofCandidates)
6138                      {
6139                         if(searchSpc->searchSpaceType)
6140                         {
6141                            free(searchSpc->searchSpaceType->choice.ue_Specific);
6142                            free(searchSpc->searchSpaceType);
6143                         }
6144                         free(searchSpc->nrofCandidates);
6145                      }
6146                      free(searchSpc->monitoringSymbolsWithinSlot->buf);
6147                   }
6148                   free(searchSpc->monitoringSymbolsWithinSlot);
6149                }
6150                free(searchSpc->monitoringSlotPeriodicityAndOffset);
6151             }
6152             free(searchSpc->controlResourceSetId);
6153          }
6154       }
6155       for(searchSpcArrIdx = 0; searchSpcArrIdx < searchSpcList->list.count; searchSpcArrIdx++)
6156       {
6157          free(searchSpcList->list.array[searchSpcArrIdx]);
6158       }
6159       free(searchSpcList->list.array);
6160    }
6161 }
6162 /*******************************************************************
6163 *
6164 * @brief Function for free part for the memory allocated by aper_decoder
6165 *
6166 * @details
6167 *
6168 *    Function : freeAperDecodeBWPDlDedPdcchConfig
6169 *
6170 *    Functionality: Function to free BWPDlDedPdcchConfig
6171 *
6172 * @params[in]
6173 * @return void
6174 *
6175 * ****************************************************************/
6176
6177
6178 void freeAperDecodeBWPDlDedPdcchConfig(BWP_DownlinkDedicated_t *dlBwp)
6179 {
6180    uint8_t arrIdx1=0;
6181    uint8_t arrIdx2=0;
6182    struct PDCCH_Config *pdcchCfg=NULLP;
6183    struct ControlResourceSet *controlRSet=NULLP;
6184    struct PDCCH_Config__controlResourceSetToAddModList *controlRSetList=NULLP;
6185
6186    if(dlBwp->pdcch_Config->choice.setup)
6187    {
6188       pdcchCfg=dlBwp->pdcch_Config->choice.setup;
6189       if(pdcchCfg->controlResourceSetToAddModList)
6190       {
6191          controlRSetList = pdcchCfg->controlResourceSetToAddModList;
6192          if(controlRSetList->list.array)
6193          {
6194             controlRSet = controlRSetList->list.array[arrIdx2];
6195             if(controlRSet)
6196             {
6197                if(controlRSet->frequencyDomainResources.buf)
6198                {
6199                   if(controlRSet->pdcch_DMRS_ScramblingID)
6200                   {
6201                      if(pdcchCfg->searchSpacesToAddModList)
6202                      {
6203                         freeAperDecodePdcchSearchSpcToAddModList(pdcchCfg->searchSpacesToAddModList);
6204                         free(pdcchCfg->searchSpacesToAddModList);
6205                      }
6206                      free(controlRSet->pdcch_DMRS_ScramblingID);
6207                   }
6208                   free(controlRSet->frequencyDomainResources.buf);
6209                }
6210             }
6211             for(arrIdx1 = 0; arrIdx1 <controlRSetList->list.count; arrIdx1++)
6212             {
6213                free(controlRSetList->list.array[arrIdx1]);
6214             }
6215             free(controlRSetList->list.array);
6216          }
6217          free(pdcchCfg->controlResourceSetToAddModList);
6218       }
6219       free(dlBwp->pdcch_Config->choice.setup);
6220    }
6221 }
6222 /*******************************************************************
6223 *
6224 * @brief Function to free PdschTimeDomAllocationList
6225 *     where the memory allocated by aper_decoder
6226 *
6227 * @details
6228 *
6229 *    Function : freeAperDecodePdschTimeDomAllocationList
6230 *
6231 *    Functionality: Function to free PdschTimeDomAllocationList
6232 *
6233 * @params[in] struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList
6234 * @return void
6235 *
6236 * ****************************************************************/
6237
6238
6239 void freeAperDecodePdschTimeDomAllocationList( struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList)
6240 {
6241    uint8_t arrIdx=0;
6242
6243    if(timeDomAllocList->choice.setup)
6244    {
6245       if(timeDomAllocList->choice.setup->list.array)
6246       {
6247          for(arrIdx = 0; arrIdx <timeDomAllocList->choice.setup->list.count ; arrIdx++)
6248          {
6249             free(timeDomAllocList->choice.setup->list.array[arrIdx]);
6250          }
6251          free(timeDomAllocList->choice.setup->list.array);
6252       }
6253       free(timeDomAllocList->choice.setup);
6254    }
6255 }
6256
6257 /*******************************************************************
6258 *
6259 * @brief Function to free BWPDlDedPdschConfig
6260 *        where the memory allocated by aper_decoder
6261 *
6262 * @details
6263 *
6264 *    Function : freeAperDecodeBWPDlDedPdschConfig
6265 *
6266 *    Functionality: Function to free BWPDlDedPdschConfig
6267 *
6268 * @params[in] BWP_DownlinkDedicated_t *dlBwp
6269 * @return void
6270 *
6271 * ****************************************************************/
6272
6273
6274 void freeAperDecodeBWPDlDedPdschConfig(BWP_DownlinkDedicated_t *dlBwp)
6275 {
6276    struct PDSCH_Config *pdschCfg=NULLP;
6277    struct PDSCH_Config__prb_BundlingType *prbBndlType=NULLP;
6278    struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList=NULLP;
6279    struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA *dmrsDlCfg=NULLP;
6280
6281    if(dlBwp->pdsch_Config->choice.setup)
6282    {
6283       pdschCfg=dlBwp->pdsch_Config->choice.setup;
6284       if(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA)
6285       {
6286          if(pdschCfg->pdsch_TimeDomainAllocationList)
6287          {
6288             timeDomAllocList=pdschCfg->pdsch_TimeDomainAllocationList;
6289             if(pdschCfg->maxNrofCodeWordsScheduledByDCI)
6290             {
6291                prbBndlType=&pdschCfg->prb_BundlingType;
6292                free(prbBndlType->choice.staticBundling);
6293                free(pdschCfg->maxNrofCodeWordsScheduledByDCI);
6294             }
6295             freeAperDecodePdschTimeDomAllocationList(timeDomAllocList);
6296             free(pdschCfg->pdsch_TimeDomainAllocationList);
6297          }
6298          dmrsDlCfg=pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA;
6299          if(dmrsDlCfg->choice.setup)
6300          {
6301             free(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition);
6302             free(dmrsDlCfg->choice.setup);
6303          }
6304          free(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA);
6305       }
6306       free(dlBwp->pdsch_Config->choice.setup);
6307    }
6308 }
6309 /*******************************************************************
6310 *
6311 * @brief Function to free PuschTimeDomAllocListCfg
6312                  where the memory allocated by aper_decoder
6313 *
6314 * @details
6315 *
6316 *    Function : freeAperDecodePuschTimeDomAllocListCfg
6317 *
6318 *    Functionality: Function to free PuschTimeDomAllocListCfg
6319 *
6320 * @params[in] PUSCH_Config_t *puschCfg
6321 * @return void
6322 *
6323 * ****************************************************************/
6324
6325
6326 void freeAperDecodePuschTimeDomAllocListCfg(PUSCH_Config_t *puschCfg)
6327 {
6328    uint8_t arrIdx=0;
6329    uint8_t arrIdx1=0;
6330    struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList_t=NULLP;
6331
6332    if(puschCfg->pusch_TimeDomainAllocationList)
6333    {
6334       timeDomAllocList_t=puschCfg->pusch_TimeDomainAllocationList;
6335       if(timeDomAllocList_t->choice.setup)
6336       {
6337          if(timeDomAllocList_t->choice.setup->list.array)
6338          {
6339             free(timeDomAllocList_t->choice.setup->list.array[arrIdx1]->k2);
6340             for(arrIdx = 0; arrIdx<timeDomAllocList_t->choice.setup->list.count; arrIdx++)
6341             {
6342                free(timeDomAllocList_t->choice.setup->list.array[arrIdx]);
6343             }
6344             free(timeDomAllocList_t->choice.setup->list.array);
6345          }
6346          free(timeDomAllocList_t->choice.setup);
6347       }
6348       free(puschCfg->transformPrecoder);
6349       free(puschCfg->pusch_TimeDomainAllocationList);
6350    }
6351 }
6352 /*******************************************************************
6353 *
6354 * @brief Function to free InitialUlBWPConfig where memory allocated by aper_decoder
6355 *
6356 * @details
6357 *
6358 *    Function : freeAperDecodeInitialUlBWPConfig
6359 *
6360 *    Functionality: Function to free InitialUlBWPConfig
6361 *
6362 * @params[in]  BWP_UplinkDedicated_t *ulBwp
6363 * @return void
6364 *
6365 * ****************************************************************/
6366
6367
6368 void freeAperDecodeInitialUlBWPConfig(BWP_UplinkDedicated_t *ulBwp)
6369 {
6370    uint8_t  rSetIdx =0;
6371    uint8_t  rsrcIdx =0;
6372    SRS_Config_t   *srsCfg = NULLP;
6373    PUSCH_Config_t *puschCfg = NULLP;
6374    struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA *dmrsUlCfg = NULLP;
6375    struct SRS_Config__srs_ResourceSetToAddModList *rsrcSetList = NULLP;
6376    struct SRS_ResourceSet__srs_ResourceIdList *rsrcIdList = NULLP;
6377    struct SRS_Config__srs_ResourceToAddModList *resourceList = NULLP;
6378
6379    if(ulBwp->pusch_Config)
6380    {
6381       if(ulBwp->pusch_Config->choice.setup)
6382       {
6383          puschCfg=ulBwp->pusch_Config->choice.setup;
6384          if(puschCfg->dataScramblingIdentityPUSCH)
6385          {
6386             if(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA)
6387             {
6388                freeAperDecodePuschTimeDomAllocListCfg(puschCfg);
6389                dmrsUlCfg=puschCfg->dmrs_UplinkForPUSCH_MappingTypeA;
6390                if(dmrsUlCfg->choice.setup)
6391                {
6392                   if(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition)
6393                   {
6394                      if(dmrsUlCfg->choice.setup->transformPrecodingDisabled)
6395                      {
6396                         free(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0);
6397                         free(dmrsUlCfg->choice.setup->transformPrecodingDisabled);
6398                      }
6399                      free(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition);
6400                   }
6401                   free(dmrsUlCfg->choice.setup);
6402                }
6403                free(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA);
6404             }
6405             free(puschCfg->dataScramblingIdentityPUSCH);
6406          }
6407          free(ulBwp->pusch_Config->choice.setup);
6408       }
6409       free(ulBwp->pusch_Config);
6410
6411       /* Free SRS-Config */
6412       if(ulBwp->srs_Config)
6413       {
6414          if(ulBwp->srs_Config->choice.setup)
6415          {
6416             srsCfg = ulBwp->srs_Config->choice.setup;
6417
6418             /* Free Resource Set to add/mod list */
6419             if(srsCfg->srs_ResourceSetToAddModList)
6420             {
6421                rsrcSetList = srsCfg->srs_ResourceSetToAddModList;
6422                if(rsrcSetList->list.array)
6423                {
6424                   rSetIdx = 0;
6425
6426                   /* Free SRS resource Id list in this SRS resource set */
6427                   if(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList)
6428                   {
6429                      rsrcIdList =
6430                         rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList;
6431
6432                      if(rsrcIdList->list.array)
6433                      {
6434                         for(rsrcIdx = 0; rsrcIdx < rsrcIdList->list.count;
6435                               rsrcIdx++)
6436                         {
6437                            free(rsrcIdList->list.array[rsrcIdx]);
6438                         }
6439                         free(rsrcIdList->list.array);
6440                      }
6441                      free(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList);
6442                   }
6443
6444                   /* Free resource type info for this SRS resource set */
6445
6446                   free(rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic);
6447
6448                   /* Free memory for each resource set */
6449                   for(rSetIdx = 0; rSetIdx < rsrcSetList->list.count; rSetIdx++)
6450                   {
6451                      free(rsrcSetList->list.array[rSetIdx]);
6452                   }
6453                   free(rsrcSetList->list.array);
6454                }
6455                free(srsCfg->srs_ResourceSetToAddModList);
6456             }
6457
6458             /* Free resource to add/modd list */
6459             if(srsCfg->srs_ResourceToAddModList)
6460             {
6461                resourceList = srsCfg->srs_ResourceToAddModList;
6462                if(resourceList->list.array)
6463                {
6464                   rsrcIdx = 0;
6465
6466                   free(resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2);
6467                   free(resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic);
6468
6469                   for(rsrcIdx = 0; rsrcIdx < resourceList->list.count; rsrcIdx++)
6470                   {
6471                      free(resourceList->list.array[rsrcIdx]);
6472                   }
6473                   free(resourceList->list.array);
6474                }
6475                free(srsCfg->srs_ResourceToAddModList);
6476             }
6477
6478             free(ulBwp->srs_Config->choice.setup);
6479          }
6480          free(ulBwp->srs_Config);
6481       }
6482    }
6483 }
6484 /*******************************************************************
6485 *
6486 * @brief Function to free initialUplinkBWPConfig where memory allocated by aper_decoder
6487 *
6488 * @details
6489 *
6490 *    Function : freeAperDecodeinitialUplinkBWPConfig
6491 *
6492 *    Functionality: Function to free initialUplinkBWPConfig
6493 *
6494 * @params[in] UplinkConfig_t *ulCfg
6495 * @return void
6496 *
6497 * ****************************************************************/
6498
6499
6500 void freeAperDecodeinitialUplinkBWPConfig(UplinkConfig_t *ulCfg)
6501 {
6502    BWP_UplinkDedicated_t *ulBwp=NULLP;
6503    struct UplinkConfig__pusch_ServingCellConfig *puschCfg=NULLP;
6504
6505    if(ulCfg->initialUplinkBWP)
6506    {
6507       ulBwp=ulCfg->initialUplinkBWP;
6508       if(ulCfg->firstActiveUplinkBWP_Id)
6509       {
6510          if(ulCfg->pusch_ServingCellConfig)
6511          {
6512             puschCfg=ulCfg->pusch_ServingCellConfig;
6513             if(puschCfg->choice.setup)
6514             {
6515                if(puschCfg->choice.setup->ext1)
6516                {
6517                   free(puschCfg->choice.setup->ext1->processingType2Enabled);
6518                   free(puschCfg->choice.setup->ext1->maxMIMO_Layers);
6519                   free(puschCfg->choice.setup->ext1);
6520                }
6521                free(puschCfg->choice.setup);
6522             }
6523             free(ulCfg->pusch_ServingCellConfig);
6524          }
6525          free(ulCfg->firstActiveUplinkBWP_Id);
6526       }
6527       freeAperDecodeInitialUlBWPConfig(ulBwp);
6528       free(ulCfg->initialUplinkBWP);
6529    }
6530 }
6531
6532 /*******************************************************************
6533  *
6534  * @brief Function to free DuUeCfg
6535  *
6536  * @details
6537  *
6538  *    Function : freeDuUeCfg
6539  *
6540  *    Functionality: Function to free DuUeCfg
6541  *
6542  * @params[in] DuUeCfg *ueCfg
6543  * @return void
6544  *
6545  * ****************************************************************/
6546 void freeDuUeCfg(DuUeCfg *ueCfg)
6547 {
6548    uint8_t lcIdx = 0;
6549    uint8_t arrIdx = 0;
6550    SpCellConfig_t *spCellCfg = NULLP;
6551    ServingCellConfig_t *srvCellCfg = NULLP;
6552    BWP_DownlinkDedicated_t *dlBwp = NULLP;
6553    MAC_CellGroupConfig_t *macCellGrpCfg = NULLP;
6554    PhysicalCellGroupConfig_t *phyCellGrpCfg = NULLP;
6555    struct CellGroupConfigRrc__rlc_BearerToAddModList *rlcBearerList = NULLP;
6556    struct RLC_Config *rlcConfig = NULLP;
6557    struct LogicalChannelConfig *macLcConfig = NULLP;
6558    struct SchedulingRequestConfig *schedulingRequestConfig = NULLP;
6559    struct SchedulingRequestConfig__schedulingRequestToAddModList *schReqList = NULLP;
6560    struct TAG_Config *tagConfig = NULLP;
6561    struct TAG_Config__tag_ToAddModList *tagList = NULLP;
6562    struct MAC_CellGroupConfig__phr_Config *phrConfig = NULLP;
6563    struct ServingCellConfig__pdsch_ServingCellConfig *pdschCfg = NULLP;
6564    CellGroupConfigRrc_t *cellGrpCfg = ueCfg->cellGrpCfg;
6565
6566    if(ueCfg->ueNrCapability)
6567    {
6568       freeAperDecodeUeNrCapability(ueCfg->ueNrCapability);
6569       DU_FREE(ueCfg->ueNrCapability, sizeof(UE_NR_Capability_t));
6570       ueCfg->ueNrCapability = NULLP;
6571    }
6572
6573    if(ueCfg->cellGrpCfg)
6574    {
6575
6576       rlcBearerList = cellGrpCfg->rlc_BearerToAddModList;
6577       if(rlcBearerList)
6578       {
6579          if(rlcBearerList->list.array)
6580          {
6581             for(arrIdx=0; arrIdx<rlcBearerList->list.count; arrIdx++)
6582             {
6583                if(rlcBearerList->list.array[arrIdx])
6584                {
6585                   rlcConfig   = rlcBearerList->list.array[arrIdx]->rlc_Config;
6586                   macLcConfig = rlcBearerList->list.array[arrIdx]->mac_LogicalChannelConfig;
6587
6588                   if(rlcBearerList->list.array[arrIdx]->servedRadioBearer)
6589                   {
6590                      free(rlcBearerList->list.array[arrIdx]->servedRadioBearer);
6591                   }
6592                   if(rlcConfig)
6593                   {
6594                      if(rlcConfig->choice.am)
6595                      {
6596                         free(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength);
6597                         free(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength);
6598                         free(rlcConfig->choice.am);
6599                      }
6600                      free(rlcBearerList->list.array[arrIdx]->rlc_Config);
6601                   }
6602                   if(macLcConfig)
6603                   {
6604                      if(macLcConfig->ul_SpecificParameters)
6605                      {
6606                         free(macLcConfig->ul_SpecificParameters->schedulingRequestID);
6607                         free(macLcConfig->ul_SpecificParameters->logicalChannelGroup);
6608                         free(macLcConfig->ul_SpecificParameters);
6609                      }
6610                      free(rlcBearerList->list.array[arrIdx]->mac_LogicalChannelConfig);
6611                   }
6612                   free(rlcBearerList->list.array[arrIdx]);
6613                }
6614             }
6615             free(rlcBearerList->list.array);
6616          }
6617          free(cellGrpCfg->rlc_BearerToAddModList);
6618       }
6619
6620       macCellGrpCfg = cellGrpCfg->mac_CellGroupConfig;
6621       if(macCellGrpCfg)
6622       {
6623          schedulingRequestConfig = macCellGrpCfg->schedulingRequestConfig;
6624          if(schedulingRequestConfig)
6625          {
6626             schReqList = schedulingRequestConfig->schedulingRequestToAddModList;
6627             if(schReqList)
6628             {
6629                if(schReqList->list.array)
6630                {
6631                   for(arrIdx=0;arrIdx<schReqList->list.count; arrIdx++)
6632                   {
6633                      if(schReqList->list.array[arrIdx])
6634                      {
6635                         free(schReqList->list.array[arrIdx]->sr_ProhibitTimer);
6636                         free(schReqList->list.array[arrIdx]);
6637                      }
6638                   }
6639                   free(schReqList->list.array);
6640                }
6641                free(schedulingRequestConfig->schedulingRequestToAddModList);
6642             }
6643             free(macCellGrpCfg->schedulingRequestConfig);
6644          }
6645          if(macCellGrpCfg->bsr_Config)
6646          {
6647             free(macCellGrpCfg->bsr_Config);
6648          }
6649          tagConfig = macCellGrpCfg->tag_Config;
6650          if(tagConfig)
6651          {
6652             tagList = tagConfig->tag_ToAddModList;
6653             if(tagList)
6654             {
6655                if(tagList->list.array)
6656                {
6657                   for(arrIdx=0; arrIdx<tagList->list.count; arrIdx++)
6658                   {
6659                      free(tagList->list.array[arrIdx]);
6660                   }
6661                   free(tagList->list.array);
6662                }
6663                free(tagConfig->tag_ToAddModList);
6664             }
6665             free(tagConfig);
6666          }
6667
6668          phrConfig = macCellGrpCfg->phr_Config;
6669          if(phrConfig)
6670          {
6671             free(phrConfig->choice.setup);
6672             free(phrConfig);
6673          }
6674
6675          free(macCellGrpCfg);
6676       }
6677
6678       phyCellGrpCfg = cellGrpCfg->physicalCellGroupConfig;
6679       if(phyCellGrpCfg)
6680       {
6681          free(phyCellGrpCfg->p_NR_FR1);
6682          free(phyCellGrpCfg);
6683       }
6684
6685       spCellCfg = cellGrpCfg->spCellConfig;
6686       if(spCellCfg)
6687       {
6688          if(spCellCfg->servCellIndex)
6689          {
6690             if(spCellCfg->rlmInSyncOutOfSyncThreshold)
6691             {
6692                if(spCellCfg->spCellConfigDedicated)
6693                {
6694                   srvCellCfg = spCellCfg->spCellConfigDedicated;
6695                   if(srvCellCfg->initialDownlinkBWP)
6696                   {
6697                      dlBwp = srvCellCfg->initialDownlinkBWP;
6698                      if(srvCellCfg->firstActiveDownlinkBWP_Id)
6699                      {
6700                         if(srvCellCfg->defaultDownlinkBWP_Id)
6701                         {
6702                            if(srvCellCfg->uplinkConfig)
6703                            {
6704
6705                               if(srvCellCfg->pdsch_ServingCellConfig)
6706                               {
6707                                  pdschCfg=
6708                                     srvCellCfg->pdsch_ServingCellConfig;
6709                                  if(pdschCfg->choice.setup)
6710                                  {
6711
6712                                     free(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH);
6713                                     free(pdschCfg->choice.setup);
6714                                  }
6715
6716                                  free(srvCellCfg->pdsch_ServingCellConfig);
6717                               }
6718
6719                               freeAperDecodeinitialUplinkBWPConfig(srvCellCfg->uplinkConfig);
6720                               free(srvCellCfg->uplinkConfig);
6721                            }
6722                            free(srvCellCfg->defaultDownlinkBWP_Id);
6723                         }
6724
6725                         free(srvCellCfg->firstActiveDownlinkBWP_Id);
6726                      }
6727                      if(dlBwp->pdcch_Config)
6728                      {
6729                         if(dlBwp->pdsch_Config)
6730                         {
6731                            freeAperDecodeBWPDlDedPdschConfig(dlBwp);
6732                            free(dlBwp->pdsch_Config);
6733                         }
6734                         freeAperDecodeBWPDlDedPdcchConfig(dlBwp);
6735                         free(dlBwp->pdcch_Config);
6736                      }
6737                      free(srvCellCfg->initialDownlinkBWP);
6738                   }
6739
6740                   free(spCellCfg->spCellConfigDedicated);
6741                }
6742                free(spCellCfg->rlmInSyncOutOfSyncThreshold);
6743             }
6744             free(spCellCfg->servCellIndex);
6745          }
6746          free(spCellCfg);
6747       }
6748       DU_FREE(ueCfg->cellGrpCfg, sizeof(CellGroupConfigRrc_t));
6749       ueCfg->cellGrpCfg = NULLP;
6750    }
6751    if(ueCfg->ambrCfg)
6752    {
6753       memset(ueCfg->ambrCfg, 0, sizeof(AmbrCfg));
6754       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, ueCfg->ambrCfg, sizeof(AmbrCfg));
6755    }
6756    for(lcIdx = 0; lcIdx < ueCfg->numRlcLcs; lcIdx++)
6757    {
6758       freeRlcLcCfg(&ueCfg->rlcLcCfg[lcIdx]);
6759    }
6760    for(lcIdx = 0; lcIdx < ueCfg->numMacLcs; lcIdx++)
6761    {
6762       freeMacLcCfg(&ueCfg->macLcCfg[lcIdx]);
6763    }
6764    for(lcIdx = 0; lcIdx < ueCfg->numDrb; lcIdx++)
6765    {
6766       DU_FREE(ueCfg->upTnlInfo[lcIdx].tnlCfg1, sizeof(GtpTnlCfg));
6767       memset(&ueCfg->upTnlInfo[lcIdx], 0, sizeof(UpTnlCfg));
6768    }
6769 }
6770
6771 /*******************************************************************
6772  *
6773  * @brief Function to free UecontextSetupDb
6774  *
6775  * @details
6776  *
6777  *    Function : freeF1UeDb
6778  *
6779  *    Functionality: Function to free UecontextSetupDb
6780  *
6781  * @params[in] UecontextSetupDb *
6782  * @return void
6783  *
6784  * ****************************************************************/
6785
6786 void freeF1UeDb(F1UeContextSetupDb *f1UeDb)
6787 {
6788
6789    if(f1UeDb->dlRrcMsg)
6790    {
6791       if(f1UeDb->dlRrcMsg->rrcMsgPdu)
6792       {
6793          DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL,\
6794             f1UeDb->dlRrcMsg->rrcMsgPdu, f1UeDb->dlRrcMsg->rrcMsgSize);
6795       }
6796       memset(f1UeDb->dlRrcMsg, 0, sizeof(F1DlRrcMsg));
6797    }
6798    freeDuUeCfg(&f1UeDb->duUeCfg);
6799    memset(f1UeDb, 0, sizeof(F1UeContextSetupDb));
6800    DU_FREE(f1UeDb, sizeof(F1UeContextSetupDb));
6801 }
6802
6803 /*******************************************************************
6804  *
6805  * @brief Function to build Am cfg Info
6806  *
6807  * @details
6808  *
6809  *    Function : extractRlcAmCfg
6810  *
6811  *    Functionality: Function to build Am cfg Info
6812  *
6813  * @params[in] AmBearerCfg *
6814  *             void *
6815  *
6816  * @return ROK/RFAILED
6817  *
6818  * ****************************************************************/
6819
6820 void extractRlcAmCfg(AmBearerCfg *amCfgToSet, struct RLC_Config__am *rlcAmCfg)
6821 {
6822    if(rlcAmCfg)
6823    {
6824       /* UL AM */
6825       if(rlcAmCfg->dl_AM_RLC.sn_FieldLength)
6826       {
6827          amCfgToSet->ulAmCfg.snLenUl = *(rlcAmCfg->dl_AM_RLC.sn_FieldLength);
6828          /*TODO: Check the timer value when sent by real CU */
6829          amCfgToSet->ulAmCfg.reAssemTmr = rlcAmCfg->dl_AM_RLC.t_Reassembly;
6830          amCfgToSet->ulAmCfg.statProhTmr = rlcAmCfg->dl_AM_RLC.t_StatusProhibit;
6831       }
6832
6833       /* DL AM */
6834       if(rlcAmCfg->ul_AM_RLC.sn_FieldLength)
6835       {
6836          amCfgToSet->dlAmCfg.snLenDl = *(rlcAmCfg->ul_AM_RLC.sn_FieldLength);
6837          amCfgToSet->dlAmCfg.pollRetxTmr = rlcAmCfg->ul_AM_RLC.t_PollRetransmit;
6838          amCfgToSet->dlAmCfg.pollPdu   = rlcAmCfg->ul_AM_RLC.pollPDU;
6839          amCfgToSet->dlAmCfg.pollByte  = rlcAmCfg->ul_AM_RLC.pollByte;
6840          amCfgToSet->dlAmCfg.maxRetxTh = rlcAmCfg->ul_AM_RLC.maxRetxThreshold;
6841       }
6842    }
6843 }
6844
6845 /*******************************************************************
6846  *
6847  * @brief Function to build Um Bi Info
6848  *
6849  * @details
6850  *
6851  *    Function : extractRlcUmBiCfg
6852  *
6853  *    Functionality: Function to build Um Bi Info
6854  *
6855  * @params[in] UmBiDirBearerCfg *
6856  *             void *
6857  *
6858  * @return ROK/RFAILED
6859  *
6860  * ****************************************************************/
6861
6862 void extractRlcUmBiCfg(UmBiDirBearerCfg *umBiCfgToSet, struct RLC_Config__um_Bi_Directional *rlcBiCfg)
6863 {
6864    if(rlcBiCfg)
6865    {
6866       /* UL UM BI DIR Cfg */
6867       if(rlcBiCfg->dl_UM_RLC.sn_FieldLength)
6868       {
6869          umBiCfgToSet->ulUmCfg.snLenUlUm  = *(rlcBiCfg->dl_UM_RLC.sn_FieldLength);
6870          umBiCfgToSet->ulUmCfg.reAssemTmr = rlcBiCfg->dl_UM_RLC.t_Reassembly;
6871       }
6872
6873       /* DL UM BI DIR Cfg */
6874       if(rlcBiCfg->ul_UM_RLC.sn_FieldLength)
6875          umBiCfgToSet->dlUmCfg.snLenDlUm  = *(rlcBiCfg->ul_UM_RLC.sn_FieldLength);
6876    }
6877 }
6878
6879 /*******************************************************************
6880  *
6881  * @brief Function to build Um Ul Info
6882  *
6883  * @details
6884  *
6885  *    Function : extractRlcUmUlCfg
6886  *
6887  *    Functionality: Function to build Um Ul Info
6888  *
6889  * @params[in] UmUniDirUlBearerCfg *
6890  *             void *
6891  *
6892  * @return ROK/RFAILED
6893  *
6894  * ****************************************************************/
6895
6896 void extractRlcUmUlCfg(UmUniDirUlBearerCfg *umUlCfgToSet, struct RLC_Config__um_Uni_Directional_DL *umUlCfg)
6897 {
6898    if(umUlCfg)
6899    {
6900       if(umUlCfg->dl_UM_RLC.sn_FieldLength)
6901       {
6902          umUlCfgToSet->ulUmCfg.snLenUlUm  = *(umUlCfg->dl_UM_RLC.sn_FieldLength);
6903          umUlCfgToSet->ulUmCfg.reAssemTmr = umUlCfg->dl_UM_RLC.t_Reassembly;
6904       }
6905    }
6906 }
6907
6908 /*******************************************************************
6909  *
6910  * @brief Function to build Um Uni Dl Info
6911  *
6912  * @details
6913  *
6914  *    Function : extractRlcUmDlCfg
6915  *
6916  *    Functionality: Function to build Um Uni Dl Info
6917  *
6918  * @params[in] UmUniDirDlBearerCfg *
6919  *             void *
6920  *
6921  * @return ROK/RFAILED
6922  *
6923  * ****************************************************************/
6924 void extractRlcUmDlCfg(UmUniDirDlBearerCfg *umDlCfgToSet, struct RLC_Config__um_Uni_Directional_UL *umDlCfg)
6925 {
6926    if(umDlCfg)
6927    {
6928       if(umDlCfg->ul_UM_RLC.sn_FieldLength)
6929          umDlCfgToSet->dlUmCfg.snLenDlUm  = *(umDlCfg->ul_UM_RLC.sn_FieldLength);
6930    }
6931 }
6932
6933 /*******************************************************************
6934  *
6935  * @brief Function to extractRlcModeCfg
6936  *
6937  * @details
6938  *
6939  *    Function : extractRlcModeCfg
6940  *
6941  *    Functionality: Function to extractRlcModeCfg
6942  *
6943  * @params[in] RLC_Config_t *
6944  *             RlcBearerCfg *
6945  *             void  *
6946  * @return ROK/RFAILED
6947  *
6948  * ****************************************************************/
6949 void extractRlcModeCfg(uint8_t rlcMode, RlcBearerCfg *rlcDbCfg, RLC_Config_t *lcCfg)
6950 {
6951    if(lcCfg)
6952    {
6953       switch(rlcMode)
6954       {
6955          case RLC_AM :
6956             {
6957                if(lcCfg->choice.am)
6958                {
6959                   DU_ALLOC_SHRABL_BUF(rlcDbCfg->u.amCfg, sizeof(AmBearerCfg));
6960                   if(rlcDbCfg->u.amCfg)
6961                      extractRlcAmCfg(rlcDbCfg->u.amCfg, lcCfg->choice.am);
6962                }
6963                break;
6964             }
6965          case RLC_UM_BI_DIRECTIONAL :
6966             {
6967                if(lcCfg->choice.um_Bi_Directional)
6968                {
6969                   DU_ALLOC_SHRABL_BUF(rlcDbCfg->u.umBiDirCfg, sizeof(UmBiDirBearerCfg));
6970                   if(rlcDbCfg->u.umBiDirCfg)
6971                      extractRlcUmBiCfg(rlcDbCfg->u.umBiDirCfg, lcCfg->choice.um_Bi_Directional);
6972                }
6973                break;
6974             }
6975          case RLC_UM_UNI_DIRECTIONAL_UL :
6976             {
6977                if(lcCfg->choice.um_Uni_Directional_DL)
6978                {
6979                   DU_ALLOC_SHRABL_BUF(rlcDbCfg->u.umUniDirUlCfg, sizeof(UmUniDirUlBearerCfg));
6980                   if(rlcDbCfg->u.umUniDirUlCfg)
6981                      extractRlcUmUlCfg(rlcDbCfg->u.umUniDirUlCfg, lcCfg->choice.um_Uni_Directional_DL);
6982                }
6983                break;
6984             }
6985          case RLC_UM_UNI_DIRECTIONAL_DL :
6986             {
6987                if(lcCfg->choice.um_Uni_Directional_UL)
6988                {
6989                   DU_ALLOC_SHRABL_BUF(rlcDbCfg->u.umUniDirDlCfg, sizeof(UmUniDirDlBearerCfg));
6990                   if(rlcDbCfg->u.umUniDirDlCfg)
6991                      extractRlcUmDlCfg(rlcDbCfg->u.umUniDirDlCfg, lcCfg->choice.um_Uni_Directional_UL);
6992                }
6993                break;
6994             }
6995          default:
6996             DU_LOG("\nERROR  -->  DUAPP: Invalid rlcMode %d at extractRlcCfgToAddMod()", rlcMode);
6997             break;
6998       }
6999    }
7000 }
7001
7002 /*******************************************************************
7003  *
7004  * @brief Function to extract extractUlLcCfg
7005  *
7006  * @details
7007  *
7008  *    Function : extractUlLcCfg
7009  *
7010  *    Functionality: Function to extract extractUlLcCfg
7011  *
7012  * @params[in] UlLcCfg *f1UlLcCfg, LogicalChannelConfig_t *ulLcCfg
7013  * @return void
7014  *
7015  * ****************************************************************/
7016
7017 void extractUlLcCfg(UlLcCfg *f1UlLcCfg, LogicalChannelConfig_t *ulLcCfg)
7018 {
7019    if(ulLcCfg)
7020    {
7021       if(ulLcCfg->ul_SpecificParameters)
7022       {
7023          f1UlLcCfg->priority = \
7024             ulLcCfg->ul_SpecificParameters->priority;
7025       if(ulLcCfg->ul_SpecificParameters->logicalChannelGroup)
7026       {
7027          f1UlLcCfg->lcGroup = \
7028            *(ulLcCfg->ul_SpecificParameters->logicalChannelGroup);
7029       }
7030       if(ulLcCfg->ul_SpecificParameters->schedulingRequestID)
7031       {
7032          f1UlLcCfg->schReqId = \
7033            *(ulLcCfg->ul_SpecificParameters->schedulingRequestID);
7034       }
7035       f1UlLcCfg->pbr = \
7036          ulLcCfg->ul_SpecificParameters->prioritisedBitRate;
7037       f1UlLcCfg->bsd = \
7038          ulLcCfg->ul_SpecificParameters->bucketSizeDuration;
7039       }
7040    }
7041 }
7042
7043 /*******************************************************************
7044  *
7045  * @brief Function to procRlcLcCfg
7046  *
7047  * @details
7048  *
7049  *    Function : procRlcLcCfg
7050  *
7051  *    Functionality: Function to procRlcLcCfg
7052  *
7053  * @params[in] rbId, lcId, rbType, rlcMod
7054  *             RLC_Config_t *, RlcBearerCfg * ,
7055  * @return void
7056  *
7057  * ****************************************************************/
7058
7059 void procRlcLcCfg(uint8_t rbId, uint8_t lcId, uint8_t rbType, uint8_t rlcMode,\
7060    uint8_t configType, RLC_Config_t *f1RlcCfg, RlcBearerCfg *lcCfg)
7061 {
7062
7063    lcCfg->rbId   = rbId;
7064    lcCfg->configType = configType;
7065
7066    if(rbType == RB_TYPE_SRB)
7067    {
7068       lcCfg->rbType = RB_TYPE_SRB;
7069       lcCfg->lcId   = rbId;
7070       lcCfg->lcType = LCH_DCCH;
7071       lcCfg->rlcMode = RLC_AM;
7072    }
7073    else if(rbType == RB_TYPE_DRB)
7074    {
7075       lcCfg->rbType = RB_TYPE_DRB;
7076       lcCfg->lcId   = lcId;
7077       lcCfg->lcType = LCH_DTCH;
7078       lcCfg->rlcMode = rlcMode;
7079    }
7080    if(f1RlcCfg) /* rlc mode config recived */
7081    {
7082       extractRlcModeCfg(lcCfg->rlcMode, lcCfg, f1RlcCfg);
7083    }
7084 }
7085
7086
7087
7088 /*******************************************************************
7089  *
7090  * @brief Fills DrbQos Info received by CU
7091  *
7092  * @details
7093  *
7094  *    Function : extractQosInfo
7095  *
7096  *    Functionality: Fills DrbQos Info received  by CU
7097  *
7098  * @params[in] DrbQosInfo *qosToAdd,
7099  *             QoSFlowLevelQoSParameters_t *qosFlowCfg
7100  * @return void
7101  *
7102  * ****************************************************************/
7103
7104 void extractQosInfo(DrbQosInfo *qosToAdd, QoSFlowLevelQoSParameters_t *qosFlowCfg)
7105 {
7106    qosToAdd->fiveQiType = qosFlowCfg->qoS_Characteristics.present;
7107    qosToAdd->u.nonDyn5Qi.fiveQi     =\
7108          qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->fiveQI;
7109    if(qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow)
7110    {
7111       qosToAdd->u.nonDyn5Qi.avgWindow = \
7112         *(qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow);
7113    }
7114    qosToAdd->u.nonDyn5Qi.maxDataBurstVol = \
7115       *(qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume);
7116    if(qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->qoSPriorityLevel)
7117    {
7118       qosToAdd->u.nonDyn5Qi.priorLevel = \
7119          *(qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->qoSPriorityLevel);
7120    }
7121    qosToAdd->ngRanRetPri.priorityLevel = \
7122       qosFlowCfg->nGRANallocationRetentionPriority.priorityLevel;
7123    qosToAdd->ngRanRetPri.preEmptionCap = \
7124       qosFlowCfg->nGRANallocationRetentionPriority.pre_emptionCapability;
7125    qosToAdd->ngRanRetPri.preEmptionVul = \
7126       qosFlowCfg->nGRANallocationRetentionPriority.pre_emptionVulnerability;
7127    if(qosFlowCfg->gBR_QoS_Flow_Information)
7128    {
7129       memcpy(&qosToAdd->grbQosInfo.maxFlowBitRateDl, \
7130          qosFlowCfg->gBR_QoS_Flow_Information->maxFlowBitRateDownlink.buf, \
7131          qosFlowCfg->gBR_QoS_Flow_Information->maxFlowBitRateDownlink.size);
7132       memcpy(&qosToAdd->grbQosInfo.maxFlowBitRateUl, \
7133          qosFlowCfg->gBR_QoS_Flow_Information->maxFlowBitRateUplink.buf, \
7134          qosFlowCfg->gBR_QoS_Flow_Information->maxFlowBitRateUplink.size);
7135       memcpy(&qosToAdd->grbQosInfo.guarFlowBitRateDl,\
7136          qosFlowCfg->gBR_QoS_Flow_Information->guaranteedFlowBitRateDownlink.buf, \
7137          qosFlowCfg->gBR_QoS_Flow_Information->guaranteedFlowBitRateDownlink.size);
7138       memcpy(&qosToAdd->grbQosInfo.guarFlowBitRateUl,\
7139          qosFlowCfg->gBR_QoS_Flow_Information->guaranteedFlowBitRateUplink.buf, \
7140          qosFlowCfg->gBR_QoS_Flow_Information->guaranteedFlowBitRateUplink.size);
7141    }
7142    qosToAdd->pduSessionId = 0;
7143    qosToAdd->ulPduSessAggMaxBitRate = 0;
7144 }
7145
7146 /*******************************************************************
7147  *
7148  * @brief Function to extract GTP Tunnel Info from CU
7149  *
7150  * @details
7151  *
7152  *    Function : extractUpTnlInfo
7153  *
7154  *    Functionality: Function to extract GTP Tunnel Info from CU
7155  *
7156  * @params[in] F1AP message
7157  * @return ROK/RFAILED
7158  *
7159  * ****************************************************************/
7160
7161 uint8_t extractUpTnlInfo(uint8_t drbId, uint8_t configType,\
7162    ULUPTNLInformation_ToBeSetup_List_t *tnlInfo, UpTnlCfg *upTnlInfo)
7163 {
7164    uint8_t tnlIdx;
7165    uint32_t ipv4_du = 0;
7166    GTPTunnel_t *gtpTunnel = NULLP;
7167
7168    upTnlInfo->drbId = drbId;
7169    upTnlInfo->configType = configType;
7170    cmInetAddr((char *)DU_IP_V4_ADDR, &ipv4_du);
7171
7172    for(tnlIdx=0; tnlIdx < tnlInfo->list.count; tnlIdx++)
7173    {
7174       if(tnlInfo->list.array[tnlIdx]->uLUPTNLInformation.present == UPTransportLayerInformation_PR_gTPTunnel)
7175       {
7176          if(tnlInfo->list.array[tnlIdx]->uLUPTNLInformation.choice.gTPTunnel)
7177          {
7178             gtpTunnel = tnlInfo->list.array[tnlIdx]->uLUPTNLInformation.choice.gTPTunnel;
7179             DU_ALLOC(upTnlInfo->tnlCfg1, sizeof(GtpTnlCfg));
7180             if(upTnlInfo->tnlCfg1 == NULLP)
7181             {
7182                DU_LOG("\nERROR  -->  F1AP : extractUpTnlInfo: Failed to allocate mmeory for tunnel cfg 1");
7183                return RFAILED;
7184             }
7185             bitStringToInt(&gtpTunnel->transportLayerAddress, &upTnlInfo->tnlCfg1->ulTnlAddress);
7186             upTnlInfo->tnlCfg1->dlTnlAddress = ipv4_du;
7187             if(gtpTunnel->gTP_TEID.size > 0)
7188             {
7189                teIdStringToInt(gtpTunnel->gTP_TEID.buf, &upTnlInfo->tnlCfg1->teId);
7190             }
7191          }
7192          break;
7193       }
7194    }
7195    return ROK;
7196 }
7197 /*******************************************************************
7198 *
7199 * @brief Function to extract Drb Qos Cfg Info from CU
7200 *
7201 * @details
7202 *
7203 *    Function : extractDrbQosCfg
7204 *
7205 *    Functionality: Function to extract Drb Qos Cfg Info from CU
7206 *
7207 * @params[in] DRB_Information_t *drbInfo, LcCfg *macLcToAdd
7208 * @return ROK/RFAILED
7209 *
7210 * ****************************************************************/
7211
7212 uint8_t extractDrbQosCfg(DRB_Information_t *drbInfo, LcCfg *macLcToAdd )
7213 {
7214    if(!macLcToAdd->drbQos)
7215    {
7216       DU_ALLOC_SHRABL_BUF(macLcToAdd->drbQos, sizeof(DrbQosInfo));
7217       if(macLcToAdd->drbQos == NULLP)
7218       {
7219          DU_LOG("\nERROR  -->  DUAPP:Memory failed at allocating DrbQos at extractDrbCfg()");
7220          return RFAILED;
7221       }
7222
7223    }
7224    if(drbInfo->dRB_QoS.qoS_Characteristics.present == QoS_Characteristics_PR_non_Dynamic_5QI)
7225    {
7226       extractQosInfo(macLcToAdd->drbQos, &drbInfo->dRB_QoS);
7227       macLcToAdd->dlLcCfg.lcp = macLcToAdd->drbQos->ngRanRetPri.priorityLevel;
7228    }
7229    if(!macLcToAdd->snssai)
7230    {
7231       DU_ALLOC_SHRABL_BUF(macLcToAdd->snssai, sizeof(Snssai));
7232       if(macLcToAdd->snssai == NULLP)
7233       {
7234          DU_LOG("\nERROR  -->  DUAPP : Memory failed at allocating SNSSAI at extractDrbCfg()");
7235          return RFAILED;
7236       }
7237    }
7238    memcpy(&macLcToAdd->snssai->sst, drbInfo->sNSSAI.sST.buf, \
7239          drbInfo->sNSSAI.sST.size);
7240    if(drbInfo->sNSSAI.sD)
7241    {
7242       memcpy(macLcToAdd->snssai->sd, drbInfo->sNSSAI.sD->buf, \
7243             drbInfo->sNSSAI.sD->size);
7244    }
7245    return ROK;
7246 }
7247 /*******************************************************************
7248  *
7249  * @brief Function to extract DRB info received from CU
7250  *
7251  * @details
7252  *
7253  *    Function : extractDrbCfg
7254  *
7255  *    Functionality: Function to extract DRB info received from CU
7256  *
7257  * @params[in] F1AP message
7258  * @return void
7259  *
7260  * ****************************************************************/
7261 uint8_t extractDrbCfg(DRBs_ToBeSetup_Item_t *drbItem,DRBs_ToBeSetupMod_Item_t *drbSetupModItem,\
7262 LcCfg *macLcToAdd, UpTnlCfg *upTnlInfo)
7263 {
7264    DRB_Information_t *drbInfo = NULLP;
7265
7266    if(drbItem != NULLP)
7267    {
7268       if(extractUpTnlInfo(drbItem->dRBID, CONFIG_ADD, &drbItem->uLUPTNLInformation_ToBeSetup_List, upTnlInfo) != ROK)
7269       {
7270          DU_LOG("\nERROR  -->  DUAPP : Failed to extract tunnel Cfg at extractDrbCfg()");
7271          return RFAILED;
7272       }
7273       if(drbItem->qoSInformation.present == QoSInformation_PR_choice_extension)
7274       {
7275          if(drbItem->qoSInformation.choice.choice_extension->value.present == QoSInformation_ExtIEs__value_PR_DRB_Information)
7276          {
7277             drbInfo = &drbItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information;
7278             if(extractDrbQosCfg(drbInfo , macLcToAdd) != ROK)
7279             {
7280                DU_LOG("\nERROR  -->  DUAPP : Failed to extract qos Cfg at extractDrbCfg()");
7281                return RFAILED;
7282             }
7283          }
7284       }
7285    }
7286    else if(drbSetupModItem != NULLP)
7287    {
7288       if(extractUpTnlInfo(drbSetupModItem->dRBID, CONFIG_ADD, &drbSetupModItem->uLUPTNLInformation_ToBeSetup_List,\
7289       upTnlInfo) != ROK)
7290       {
7291          DU_LOG("\nERROR  -->  DUAPP : Failed to extract tunnel Cfg at extractDrbCfg()");
7292          return RFAILED;
7293       }
7294       if(drbSetupModItem->qoSInformation.present == QoSInformation_PR_choice_extension)
7295       {
7296          if(drbSetupModItem->qoSInformation.choice.choice_extension->value.present ==\
7297          QoSInformation_ExtIEs__value_PR_DRB_Information)
7298          {
7299             drbInfo = &drbSetupModItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information;
7300             if(extractDrbQosCfg(drbInfo , macLcToAdd) != ROK)
7301             {
7302                DU_LOG("\nERROR  -->  DUAPP : Failed to extract qos Cfg at extractDrbCfg()");
7303                return RFAILED;
7304             }
7305
7306          }
7307       }
7308    }
7309
7310    return ROK;
7311 }
7312
7313 /*******************************************************************
7314  *
7315  * @brief Function to extract RB info received from CU
7316  *
7317  * @details
7318  *
7319  *    Function : extractMacRbCfg
7320  *
7321  *    Functionality: Function to extract RB info received from CU
7322  *
7323  * @params[in] F1AP message
7324  * @return ROK/RFAILED
7325  *
7326  * ****************************************************************/
7327
7328 uint8_t extractMacRbCfg(uint8_t lcId, DRBs_ToBeSetup_Item_t *drbCfg,\
7329 DRBs_ToBeSetupMod_Item_t *drbSetupModCfg,  LogicalChannelConfig_t *ulLcCfg, LcCfg *lcCfg, UpTnlCfg *upTnlInfo)
7330 {
7331    if(drbCfg != NULLP)
7332    {
7333       if(extractDrbCfg(drbCfg, NULL, lcCfg, upTnlInfo) != ROK)
7334       {
7335          DU_LOG("ERROR  -->  F1AP : Failed to build Drb Qos at extractMacRbCfg()");
7336          return RFAILED;
7337       }
7338    }
7339    else if(drbSetupModCfg != NULLP)
7340    {
7341       if(extractDrbCfg(NULL, drbSetupModCfg, lcCfg, upTnlInfo) != ROK)
7342       {
7343          DU_LOG("ERROR  -->  F1AP : Failed to build Drb Qos at extractMacRbCfg()");
7344          return RFAILED;
7345       }
7346    }
7347    else
7348    {
7349       lcCfg->drbQos = NULLP;
7350       lcCfg->snssai = NULLP;
7351       if(lcCfg->lcId == SRB2_LCID)
7352          lcCfg->dlLcCfg.lcp = LC_PRIORITY_3;
7353       else
7354          lcCfg->dlLcCfg.lcp = LC_PRIORITY_1;
7355    }
7356    if(ulLcCfg)
7357    {
7358       lcCfg->ulLcCfgPres = true;
7359       extractUlLcCfg(&lcCfg->ulLcCfg, ulLcCfg);
7360    }
7361    else
7362       lcCfg->ulLcCfgPres = false;
7363    return ROK;
7364 }
7365
7366 /*******************************************************************
7367  *
7368  * @brief Function processing LC config info received from CU
7369  *
7370  * @details
7371  *
7372  *    Function : procMacLcCfg
7373  *
7374  *    Functionality: Function processing LC config info received from CU
7375  *
7376  * @params[in] F1AP message
7377  * @return ROK/RFAILED
7378  *
7379  * ****************************************************************/
7380
7381 uint8_t procMacLcCfg(uint8_t lcId, uint8_t rbType, uint8_t configType,\
7382 DRBs_ToBeSetup_Item_t *drbItem, DRBs_ToBeSetupMod_Item_t *drbSetupModItem, LogicalChannelConfig_t *ulLcCfg,\
7383 LcCfg *lcCfg, UpTnlCfg *upTnlInfo)
7384 {
7385    uint8_t ret = ROK;
7386
7387    lcCfg->lcId = lcId;
7388    lcCfg->configType = configType;
7389    if(rbType == RB_TYPE_SRB)
7390    {
7391       ret = extractMacRbCfg(lcId, NULL,NULL, ulLcCfg, lcCfg, NULL);
7392    }
7393    else if(rbType == RB_TYPE_DRB)
7394    {
7395       if(drbItem != NULL)
7396         ret = extractMacRbCfg(lcId, drbItem, NULL, ulLcCfg, lcCfg, upTnlInfo);
7397       else if(drbSetupModItem != NULL)
7398         ret = extractMacRbCfg(lcId, NULL, drbSetupModItem, ulLcCfg, lcCfg, upTnlInfo);
7399    }
7400    return ret;
7401 }
7402
7403 /*******************************************************************
7404  *
7405  * @brief Function to extract Rlc cfg To Add/Mod in CellGrp Info
7406  *
7407  * @details
7408  *
7409  *    Function : extractRlcCfgToAddMod
7410  *
7411  *    Functionality: Function to extract Rlc cfg To Add/Mod in CellGrp Info
7412  *
7413  * @params[in] CellGroupConfigRrc__rlc_BearerTo pointer
7414  *             DuUeCfg Pointer
7415  * @return ROK/RFAILED
7416  *
7417  * ****************************************************************/
7418
7419 uint8_t extractRlcCfgToAddMod(struct CellGroupConfigRrc__rlc_BearerToAddModList *lcCfg, DuUeCfg *ueCfgDb)
7420 {
7421   uint8_t idx, rbId, lcId, rlcMode, rbType;
7422   RLC_Config_t *f1RlcCfg = NULLP;
7423   LogicalChannelConfig_t *macUlLcCfg = NULLP;
7424
7425   for(idx = 0; idx < lcCfg->list.count; idx++)
7426   {
7427      lcId = lcCfg->list.array[idx]->logicalChannelIdentity;
7428      if(lcCfg->list.array[idx]->servedRadioBearer)
7429      {
7430         /* RadioBearer for SRB/DRB */
7431         if(lcCfg->list.array[idx]->servedRadioBearer->present ==\
7432         RLC_BearerConfig__servedRadioBearer_PR_srb_Identity)
7433         {
7434            rbId = lcCfg->list.array[idx]->servedRadioBearer->choice.srb_Identity;
7435            rbType = RB_TYPE_SRB;
7436         }
7437         else if(lcCfg->list.array[idx]->servedRadioBearer->present ==\
7438         RLC_BearerConfig__servedRadioBearer_PR_drb_Identity)
7439         {
7440            rbId = lcCfg->list.array[idx]->servedRadioBearer->choice.drb_Identity;
7441            rbType = RB_TYPE_DRB;
7442         }
7443         else
7444         {
7445            DU_LOG("\nERROR  -->  No components present in Bearer config to ADD/MOD");
7446            return RFAILED;
7447         }
7448         /* MAC UL LC Config */
7449         if(lcCfg->list.array[idx]->mac_LogicalChannelConfig)
7450         {
7451            macUlLcCfg = lcCfg->list.array[idx]->mac_LogicalChannelConfig;
7452         }
7453      }
7454      else
7455      {
7456         DU_LOG("\nERROR  -->  DUAPP: Received RadioBearer config is NULL");
7457         return RFAILED;
7458      }
7459      /* RLC Mode Config */
7460      if(lcCfg->list.array[idx]->rlc_Config)
7461      {
7462         rlcMode  = lcCfg->list.array[idx]->rlc_Config->present;
7463         f1RlcCfg = lcCfg->list.array[idx]->rlc_Config;
7464      }
7465
7466      /* Filling RLC/MAC Config*/
7467      memset(&ueCfgDb->macLcCfg[idx], 0, sizeof(LcCfg));
7468      memset(&ueCfgDb->rlcLcCfg[idx], 0, sizeof(RlcBearerCfg));
7469      procRlcLcCfg(rbId, lcId, rbType, rlcMode, CONFIG_UNKNOWN, f1RlcCfg, &(ueCfgDb->rlcLcCfg[idx]));
7470      if(procMacLcCfg(lcId, rbType, CONFIG_UNKNOWN, NULL, NULL, macUlLcCfg, &ueCfgDb->macLcCfg[idx], NULL) != ROK)
7471      {
7472         DU_LOG("\nERROR  -->  DU APP : Failed while filling MAC LC config at extractRlcCfgToAddMod()");
7473         return RFAILED;
7474      }
7475      (ueCfgDb->numRlcLcs)++;
7476      (ueCfgDb->numMacLcs)++;
7477   }
7478   //TODO: To send the failure cause in UeContextSetupRsp
7479   return ROK;
7480 }
7481
7482 /*******************************************************************
7483  *
7484  * @brief DeAlloc pdsch serv cell config info
7485  *
7486  * @details
7487  *
7488  *    Function : freeMacPdschServCellInfo
7489  *
7490  *    Functionality: DeAlloc pdsch serv cell config info
7491  *
7492  * @params[in] PdschServCellCfg pointer
7493  * @return void
7494  *
7495  * ****************************************************************/
7496
7497 void freeMacPdschServCellInfo(PdschServCellCfg *pdsch)
7498 {
7499    if(pdsch->xOverhead)
7500    {
7501       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, pdsch->xOverhead, sizeof(uint8_t));
7502    }
7503    if(pdsch->codeBlkGrpFlushInd)
7504    {
7505       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, pdsch->codeBlkGrpFlushInd, sizeof(bool));
7506    }
7507    if(pdsch->maxCodeBlkGrpPerTb)
7508    {
7509       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, pdsch->maxCodeBlkGrpPerTb, sizeof(uint8_t));
7510    }
7511    if(pdsch->maxMimoLayers)
7512    {
7513       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, pdsch->maxMimoLayers, sizeof(uint8_t));
7514    }
7515 }
7516
7517 /*******************************************************************
7518  *
7519  * @brief Free Serving cell Info
7520  *
7521  * @details
7522  *
7523  *    Function : freeMacServingCellInfo
7524  *
7525  *    Functionality: Free Serving cell Info
7526  *
7527  * @params[in] ServCellCfgInfo *srvCellCfg
7528  * @return void
7529  *
7530  * ****************************************************************/
7531 void freeMacServingCellInfo(ServCellCfgInfo *srvCellCfg)
7532 {
7533    freeMacPdschServCellInfo(&srvCellCfg->pdschServCellCfg);
7534    if(srvCellCfg->bwpInactivityTmr)
7535    {
7536       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, srvCellCfg->bwpInactivityTmr, sizeof(uint8_t));
7537    }
7538 }
7539
7540 /*******************************************************************
7541  *
7542  * @brief Free cell Grp Cfg Info
7543  *
7544  * @details
7545  *
7546  *    Function : freeUeReCfgCellGrpInfo
7547  *
7548  *    Functionality: Free cell Grp Cfg Info
7549  *
7550  * @params[in] MacUeCfg*  duUeCfg
7551  * @return void
7552  *
7553  * ****************************************************************/
7554
7555 void freeUeReCfgCellGrpInfo(MacUeCfg *macUeCfg)
7556 {
7557    freeMacServingCellInfo(&macUeCfg->spCellCfg.servCellCfg);
7558 }
7559
7560 /*******************************************************************
7561  *
7562  * @brief Fills Reconfig SchReqReConfig
7563  *
7564  * @details
7565  *
7566  *    Function : extractSchReqReConfig
7567  *
7568  *    Functionality: Fills Reconfig SchReqReConfig
7569  *
7570  * @params[in] SchedulingRequestConfig_t *cuSchedReq
7571  *             SchedReqCfg*  macSchedReq
7572  * @return void
7573  *
7574  * ****************************************************************/
7575 void extractSchReqReConfig(SchedulingRequestConfig_t *cuSchedReq, SchedReqCfg *macSchedReq)
7576 {
7577    uint8_t schReqIdx = 0;
7578    struct SchedulingRequestConfig__schedulingRequestToAddModList *schReqListToAdd = NULLP;
7579    struct SchedulingRequestConfig__schedulingRequestToReleaseList *schReqListToRel = NULLP;
7580
7581    if(cuSchedReq->schedulingRequestToAddModList)
7582    {
7583       schReqListToAdd = cuSchedReq->schedulingRequestToAddModList;
7584       if(schReqListToAdd->list.count)
7585       {
7586          macSchedReq->addModListCount = schReqListToAdd->list.count;
7587          for(schReqIdx = 0; schReqIdx < schReqListToAdd->list.count; schReqIdx++)
7588          {
7589             macSchedReq->addModList[schReqIdx].schedReqId = \
7590                schReqListToAdd->list.array[schReqIdx]->schedulingRequestId;
7591             macSchedReq->addModList[schReqIdx].srProhibitTmr = \
7592                *(schReqListToAdd->list.array[schReqIdx]->sr_ProhibitTimer);
7593             macSchedReq->addModList[schReqIdx].srTransMax    =\
7594                schReqListToAdd->list.array[schReqIdx]->sr_TransMax;
7595          }
7596       }
7597    }
7598    /* Scheduling Req To release */
7599    if(cuSchedReq->schedulingRequestToReleaseList)
7600    {
7601       schReqListToRel = cuSchedReq->schedulingRequestToReleaseList;
7602       if(schReqListToRel->list.count)
7603       {
7604          macSchedReq->relListCount = schReqListToRel->list.count;
7605          for(schReqIdx = 0; schReqIdx < schReqListToRel->list.count; schReqIdx++)
7606          {
7607             macSchedReq->relList[schReqIdx] = \
7608                *schReqListToRel->list.array[schReqIdx];
7609          }
7610       }
7611    }
7612 }
7613
7614 /*******************************************************************
7615  *
7616  * @brief Fills TagReconfig
7617  *
7618  * @details
7619  *
7620  *    Function : extractTagReconfig
7621  *
7622  *    Functionality: Fills extractTagReconfig
7623  *
7624  * @params[in] TAG_Config_t *cuTagCfg
7625  *             TagCfg *macTagCfg
7626  * @return void
7627  *
7628  * ****************************************************************/
7629
7630 void extractTagReconfig(TAG_Config_t *cuTagCfg, TagCfg *macTagCfg)
7631 {
7632   uint8_t tagIdx = 0;
7633   struct TAG_Config__tag_ToAddModList  *tagListToAddMod = NULLP;
7634   struct TAG_Config__tag_ToReleaseList *tagListToRel = NULLP;
7635
7636   /* Tag config to AddMod */
7637   if(cuTagCfg->tag_ToAddModList)
7638   {
7639      tagListToAddMod = cuTagCfg->tag_ToAddModList;
7640      if(tagListToAddMod->list.count)
7641      {
7642         macTagCfg->addModListCount = tagListToAddMod->list.count;
7643         for(tagIdx = 0; tagIdx < tagListToAddMod->list.count; tagIdx++)
7644         {
7645            macTagCfg->addModList[tagIdx].tagId =\
7646               tagListToAddMod->list.array[tagIdx]->tag_Id;
7647            macTagCfg->addModList[tagIdx].timeAlignTimer = \
7648
7649               tagListToAddMod->list.array[tagIdx]->timeAlignmentTimer;
7650         }
7651      }
7652   }
7653   /* Tag config to release */
7654   if(cuTagCfg->tag_ToReleaseList)
7655   {
7656      tagListToRel = cuTagCfg->tag_ToReleaseList;
7657      if(tagListToRel->list.count)
7658      {
7659         macTagCfg->relListCount = tagListToRel->list.count;
7660         for(tagIdx = 0; tagIdx < tagListToRel->list.count; tagIdx++)
7661         {
7662            macTagCfg->relList[tagIdx] = *tagListToRel->list.array[tagIdx];
7663         }
7664      }
7665   }
7666 }
7667
7668 /*******************************************************************
7669  *
7670  * @brief Fills PdcchCfg received by CU
7671  *
7672  * @details
7673  *
7674  *    Function : extractPdcchCfg
7675  *
7676  *    Functionality: Fills PdcchCfg received  by CU
7677  *
7678  * @params[in] PDCCH_Config_t *cuPdcchCfg,
7679  *             PdcchConfig *duPdcchCfg
7680  * @return void
7681  *
7682  * ****************************************************************/
7683
7684 void extractPdcchCfg(PDCCH_Config_t *cuPdcchCfg, PdcchConfig *macPdcchCfg)
7685 {
7686    uint8_t cRsetIdx = 0;
7687    uint8_t srchSpcIdx = 0;
7688
7689    struct PDCCH_Config__controlResourceSetToAddModList *cRsetToAddModList = NULLP;
7690    struct PDCCH_Config__controlResourceSetToReleaseList *cRsetToRelList = NULLP;
7691    struct PDCCH_Config__searchSpacesToAddModList *srchSpcToAddModList = NULLP;
7692    struct PDCCH_Config__searchSpacesToReleaseList *srchSpcToRelList = NULLP;
7693
7694
7695    /* Control Resource Set To Add/Mod List */
7696    if(cuPdcchCfg->controlResourceSetToAddModList)
7697    {
7698       cRsetToAddModList = cuPdcchCfg->controlResourceSetToAddModList;
7699       if(cRsetToAddModList->list.count)
7700       {
7701          macPdcchCfg->numCRsetToAddMod = cRsetToAddModList->list.count;
7702          for(cRsetIdx = 0; cRsetIdx < cRsetToAddModList->list.count; cRsetIdx++)
7703          {
7704             macPdcchCfg->cRSetToAddModList[cRsetIdx].cRSetId = \
7705               cRsetToAddModList->list.array[cRsetIdx]->controlResourceSetId;
7706             bitStringToInt(&cRsetToAddModList->list.array[cRsetIdx]->frequencyDomainResources,\
7707                macPdcchCfg->cRSetToAddModList[cRsetIdx].freqDomainRsrc);
7708             macPdcchCfg->cRSetToAddModList[cRsetIdx].duration = \
7709               cRsetToAddModList->list.array[cRsetIdx]->duration;
7710
7711             macPdcchCfg->cRSetToAddModList[cRsetIdx].cceRegMappingType = \
7712               cRsetToAddModList->list.array[cRsetIdx]->cce_REG_MappingType.present;
7713             if(macPdcchCfg->cRSetToAddModList[cRsetIdx].cceRegMappingType == CCE_REG_MAPPINGTYPE_PR_INTERLEAVED)
7714             {
7715                //TODO: handle the case for Interleaved
7716             }
7717             macPdcchCfg->cRSetToAddModList[cRsetIdx].precoderGranularity = \
7718               cRsetToAddModList->list.array[cRsetIdx]->precoderGranularity;
7719             if(cRsetToAddModList->list.array[cRsetIdx]->pdcch_DMRS_ScramblingID)
7720             {
7721                macPdcchCfg->cRSetToAddModList[cRsetIdx].dmrsScramblingId= \
7722                   *(cRsetToAddModList->list.array[cRsetIdx]->pdcch_DMRS_ScramblingID);
7723             }
7724          }
7725       }
7726
7727    }
7728    /* Control Resource Set To Release List */
7729    if(cuPdcchCfg->controlResourceSetToReleaseList)
7730    {
7731       cRsetToRelList = cuPdcchCfg->controlResourceSetToReleaseList;
7732       if(cRsetToRelList->list.count)
7733       {
7734          macPdcchCfg->numCRsetToRel = cRsetToRelList->list.count;
7735          for(cRsetIdx = 0; cRsetIdx < cRsetToRelList->list.count; cRsetIdx++)
7736          {
7737             macPdcchCfg->cRSetToRelList[cRsetIdx] = *(cRsetToRelList->list.array[cRsetIdx]);
7738          }
7739       }
7740    }
7741
7742    /* Search space To Add/Mod List */
7743    if(cuPdcchCfg->searchSpacesToAddModList)
7744    {
7745       srchSpcToAddModList = cuPdcchCfg->searchSpacesToAddModList;
7746       if(srchSpcToAddModList->list.count)
7747       {
7748          macPdcchCfg->numSearchSpcToAddMod = srchSpcToAddModList->list.count;
7749          for(srchSpcIdx = 0; srchSpcIdx < srchSpcToAddModList->list.count; srchSpcIdx++)
7750          {
7751             macPdcchCfg->searchSpcToAddModList[srchSpcIdx].searchSpaceId =\
7752                srchSpcToAddModList->list.array[srchSpcIdx]->searchSpaceId;
7753             macPdcchCfg->searchSpcToAddModList[srchSpcIdx].cRSetId =\
7754                *(srchSpcToAddModList->list.array[srchSpcIdx]->controlResourceSetId);
7755             if(srchSpcToAddModList->list.array[srchSpcIdx]->monitoringSlotPeriodicityAndOffset)
7756             {
7757                macPdcchCfg->searchSpcToAddModList[srchSpcIdx].mSlotPeriodicityAndOffset =\
7758                   srchSpcToAddModList->list.array[srchSpcIdx]->monitoringSlotPeriodicityAndOffset->present;
7759             }
7760             if(srchSpcToAddModList->list.array[srchSpcIdx]->monitoringSymbolsWithinSlot)
7761             {
7762                bitStringToInt(srchSpcToAddModList->list.array[srchSpcIdx]->monitoringSymbolsWithinSlot,\
7763                   macPdcchCfg->searchSpcToAddModList[srchSpcIdx].mSymbolsWithinSlot);
7764             }
7765             if(srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates)
7766             {
7767               macPdcchCfg->searchSpcToAddModList[srchSpcIdx].numCandidatesAggLevel1 = \
7768                   srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates->aggregationLevel1;
7769               macPdcchCfg->searchSpcToAddModList[srchSpcIdx].numCandidatesAggLevel2 = \
7770                   srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates->aggregationLevel2;
7771               macPdcchCfg->searchSpcToAddModList[srchSpcIdx].numCandidatesAggLevel4 = \
7772                   srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates->aggregationLevel4;
7773
7774               macPdcchCfg->searchSpcToAddModList[srchSpcIdx].numCandidatesAggLevel8 = \
7775                   srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates->aggregationLevel8;
7776
7777               macPdcchCfg->searchSpcToAddModList[srchSpcIdx].numCandidatesAggLevel16 = \
7778                   srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates->aggregationLevel16;
7779             }
7780             if(srchSpcToAddModList->list.array[srchSpcIdx]->searchSpaceType)
7781             {
7782                macPdcchCfg->searchSpcToAddModList[srchSpcIdx].searchSpaceType =\
7783                   srchSpcToAddModList->list.array[srchSpcIdx]->searchSpaceType->present;
7784                if(macPdcchCfg->searchSpcToAddModList[srchSpcIdx].searchSpaceType == SEARCHSPACETYPE_PR_UE_SPECIFIC)
7785                {
7786                   macPdcchCfg->searchSpcToAddModList[srchSpcIdx].ueSpecificDciFormat =\
7787                      srchSpcToAddModList->list.array[srchSpcIdx]->searchSpaceType->choice.ue_Specific->dci_Formats;
7788                }
7789
7790             }
7791          }
7792       }
7793    }
7794    /* Search space To Rel List */
7795    if(cuPdcchCfg->searchSpacesToReleaseList)
7796    {
7797       srchSpcToRelList = cuPdcchCfg->searchSpacesToReleaseList;
7798       if(srchSpcToRelList->list.count)
7799       {
7800          macPdcchCfg->numSearchSpcToRel = srchSpcToRelList->list.count;
7801          for(srchSpcIdx = 0; srchSpcIdx < srchSpcToRelList->list.count; srchSpcIdx++)
7802          {
7803             macPdcchCfg->searchSpcToRelList[srchSpcIdx] =\
7804                *(srchSpcToRelList->list.array[srchSpcIdx]);
7805          }
7806       }
7807    }
7808 }
7809
7810 /*******************************************************************
7811  *
7812  * @brief Fills PdschCfg received by CU
7813  *
7814  * @details
7815  *
7816  *    Function : extractPdschCfg
7817  *
7818  *    Functionality: Fills PdschCfg received  by CU
7819  *
7820  * @params[in] PDSCH_Config_t *cuPdschCfg,
7821  *             PdschConfig *macPdschCfg
7822  * @return void
7823  *
7824  * ****************************************************************/
7825
7826 void extractPdschCfg(PDSCH_Config_t *cuPdschCfg, PdschConfig *macPdschCfg)
7827 {
7828    uint8_t timeDomIdx;
7829    struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAlloc = NULLP;
7830
7831    if(cuPdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA)
7832    {
7833       if(cuPdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA->present == \
7834          PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA_PR_setup)
7835       {
7836          if(cuPdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA->choice.setup)
7837          {
7838             macPdschCfg->dmrsDlCfgForPdschMapTypeA.addPos = \
7839                *(cuPdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA->choice.setup->dmrs_AdditionalPosition);
7840          }
7841       }
7842    }
7843    macPdschCfg->resourceAllocType = cuPdschCfg->resourceAllocation;
7844    if(cuPdschCfg->pdsch_TimeDomainAllocationList)
7845    {
7846       timeDomAlloc = cuPdschCfg->pdsch_TimeDomainAllocationList;
7847       if(timeDomAlloc->present ==\
7848          PDSCH_Config__pdsch_TimeDomainAllocationList_PR_setup)
7849       {
7850          if(timeDomAlloc->choice.setup)
7851          {
7852             macPdschCfg->numTimeDomRsrcAlloc  = timeDomAlloc->choice.setup->list.count;
7853             for(timeDomIdx = 0; timeDomIdx < timeDomAlloc->choice.setup->list.count; timeDomIdx++)
7854             {
7855                macPdschCfg->timeDomRsrcAllociList[timeDomIdx].mappingType = \
7856                   timeDomAlloc->choice.setup->list.array[timeDomIdx]->mappingType;
7857                macPdschCfg->timeDomRsrcAllociList[timeDomIdx].startSymbolAndLength = \
7858                   timeDomAlloc->choice.setup->list.array[timeDomIdx]->startSymbolAndLength;
7859             }
7860          }
7861       }
7862    }
7863    macPdschCfg->rbgSize = cuPdschCfg->rbg_Size;
7864    if(cuPdschCfg->maxNrofCodeWordsScheduledByDCI)
7865       macPdschCfg->numCodeWordsSchByDci = *(cuPdschCfg->maxNrofCodeWordsScheduledByDCI);
7866    if(cuPdschCfg->prb_BundlingType.present == PDSCH_Config__prb_BundlingType_PR_staticBundling)
7867    {
7868       macPdschCfg->bundlingType = cuPdschCfg->prb_BundlingType.present;
7869       if(cuPdschCfg->prb_BundlingType.choice.staticBundling)
7870       {
7871          if(cuPdschCfg->prb_BundlingType.choice.staticBundling->bundleSize)
7872          {
7873             macPdschCfg->bundlingInfo.StaticBundling.size = \
7874                *(cuPdschCfg->prb_BundlingType.choice.staticBundling->bundleSize);
7875          }
7876       }
7877    }
7878    else if(cuPdschCfg->prb_BundlingType.present == PDSCH_Config__prb_BundlingType_PR_dynamicBundling)
7879    {
7880       macPdschCfg->bundlingType = cuPdschCfg->prb_BundlingType.present;
7881    }
7882
7883 }
7884
7885 /*******************************************************************
7886  *
7887  * @brief Fills PdschServingCellCfg received by CU
7888  *
7889  * @details
7890  *
7891  *    Function : extractPdschServingCellCfg
7892  *
7893  *    Functionality: Fills PdschCfg received  by CU
7894  *
7895  * @params[in] PDSCH_ServingCellConfig_t *cuPdschSrvCellCfg,
7896  *             PdschServCellCfg *macUePdschSrvCellCfg
7897  * @return ROK/RFAILED
7898  *
7899  * ****************************************************************/
7900
7901 uint8_t extractPdschServingCellCfg(PDSCH_ServingCellConfig_t *cuPdschSrvCellCfg, PdschServCellCfg *macUePdschSrvCellCfg)
7902 {
7903    if(cuPdschSrvCellCfg->codeBlockGroupTransmission)
7904    {
7905       if(cuPdschSrvCellCfg->codeBlockGroupTransmission->choice.setup)
7906       {
7907          if(macUePdschSrvCellCfg->maxCodeBlkGrpPerTb)
7908          {
7909             *(macUePdschSrvCellCfg->maxCodeBlkGrpPerTb)  = \
7910                cuPdschSrvCellCfg->codeBlockGroupTransmission->choice.setup->maxCodeBlockGroupsPerTransportBlock;
7911          }
7912          else
7913          {
7914             DU_ALLOC_SHRABL_BUF(macUePdschSrvCellCfg->maxCodeBlkGrpPerTb, sizeof(uint8_t));
7915             if(macUePdschSrvCellCfg->maxCodeBlkGrpPerTb)
7916             {
7917                *(macUePdschSrvCellCfg->maxCodeBlkGrpPerTb)  = \
7918                   cuPdschSrvCellCfg->codeBlockGroupTransmission->choice.setup->maxCodeBlockGroupsPerTransportBlock;
7919             }
7920             else
7921             {
7922                DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for maxCodeBlkGrpPerTb at extractPdschServingCellCfg()");
7923                return RFAILED;
7924             }
7925          }
7926          if(macUePdschSrvCellCfg->codeBlkGrpFlushInd)
7927          {
7928             *(macUePdschSrvCellCfg->codeBlkGrpFlushInd)  = \
7929                cuPdschSrvCellCfg->codeBlockGroupTransmission->choice.setup->codeBlockGroupFlushIndicator;
7930          }
7931          else
7932          {
7933             DU_ALLOC_SHRABL_BUF(macUePdschSrvCellCfg->maxCodeBlkGrpPerTb, sizeof(bool));
7934             if(macUePdschSrvCellCfg->codeBlkGrpFlushInd)
7935             {
7936                *(macUePdschSrvCellCfg->codeBlkGrpFlushInd)  = \
7937                   cuPdschSrvCellCfg->codeBlockGroupTransmission->choice.setup->codeBlockGroupFlushIndicator;
7938             }
7939             else
7940             {
7941                DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for codeBlkGrpFlushInd at extractPdschServingCellCfg()");
7942                return RFAILED;
7943             }
7944          }
7945       }
7946    }
7947    if(cuPdschSrvCellCfg->nrofHARQ_ProcessesForPDSCH)
7948    {
7949       macUePdschSrvCellCfg->numHarqProcForPdsch = *(cuPdschSrvCellCfg->nrofHARQ_ProcessesForPDSCH);
7950    }
7951    if(cuPdschSrvCellCfg->ext1)
7952    {
7953       if(cuPdschSrvCellCfg->ext1->maxMIMO_Layers)
7954       {
7955         if(macUePdschSrvCellCfg->maxMimoLayers)
7956         {
7957            *(macUePdschSrvCellCfg->maxMimoLayers)  = *(cuPdschSrvCellCfg->ext1->maxMIMO_Layers);
7958         }
7959         else
7960         {
7961            DU_ALLOC_SHRABL_BUF(macUePdschSrvCellCfg->maxMimoLayers, sizeof(uint8_t));
7962            if(macUePdschSrvCellCfg->maxMimoLayers)
7963            {
7964               *(macUePdschSrvCellCfg->maxMimoLayers)  = *(cuPdschSrvCellCfg->ext1->maxMIMO_Layers);
7965            }
7966            else
7967            {
7968               DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for maxMimoLayers at extractPdschServingCellCfg()");
7969               return RFAILED;
7970            }
7971         }
7972       }
7973    }
7974    if(cuPdschSrvCellCfg->xOverhead)
7975    {
7976       if(macUePdschSrvCellCfg->xOverhead)
7977       {
7978          *(macUePdschSrvCellCfg->xOverhead)  = *(cuPdschSrvCellCfg->xOverhead);
7979       }
7980       else
7981       {
7982          DU_ALLOC_SHRABL_BUF(macUePdschSrvCellCfg->xOverhead, sizeof(uint8_t));
7983          if(macUePdschSrvCellCfg->xOverhead)
7984          {
7985             *(macUePdschSrvCellCfg->xOverhead)  = *(cuPdschSrvCellCfg->xOverhead);
7986          }
7987          else
7988          {
7989             DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for xOverhead at extractPdschServingCellCfg()");
7990             return RFAILED;
7991          }
7992       }
7993    }
7994    return ROK;
7995 }
7996
7997 /*******************************************************************
7998  *
7999  * @brief Fills PuschCfg received by CU
8000  *
8001  * @details
8002  *
8003  *    Function : extractPuschCfg
8004  *
8005  *    Functionality: Fills PuschCfg received  by CU
8006  *
8007  * @params[in] BWP_UplinkDedicated__pusch_Config *cuPuschCfg,
8008  *             PuschCfg *macPuschCfg
8009  * @return void
8010  *
8011  * ****************************************************************/
8012
8013 void extractPuschCfg(struct BWP_UplinkDedicated__pusch_Config *cuPuschCfg, PuschCfg *macPuschCfg)
8014 {
8015    uint8_t timeDomIdx = 0;
8016    DMRS_UplinkConfig_t *dmrsUlCfg = NULLP;
8017    struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList = NULLP;
8018
8019    if(cuPuschCfg->present == BWP_UplinkDedicated__pusch_Config_PR_setup)
8020    {
8021       if(cuPuschCfg->choice.setup)
8022       {
8023          if(cuPuschCfg->choice.setup->dataScramblingIdentityPUSCH)
8024          {
8025              macPuschCfg->dataScramblingId = \
8026                 *(cuPuschCfg->choice.setup->dataScramblingIdentityPUSCH);
8027          }
8028          if(cuPuschCfg->choice.setup->dmrs_UplinkForPUSCH_MappingTypeA)
8029          {
8030             if(cuPuschCfg->choice.setup->dmrs_UplinkForPUSCH_MappingTypeA->present == PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA_PR_setup)
8031             {
8032                if(cuPuschCfg->choice.setup->dmrs_UplinkForPUSCH_MappingTypeA->choice.setup)
8033                {
8034                   dmrsUlCfg = (cuPuschCfg->choice.setup->dmrs_UplinkForPUSCH_MappingTypeA->choice.setup);
8035                   if(dmrsUlCfg->dmrs_AdditionalPosition)
8036                   {
8037                      macPuschCfg->dmrsUlCfgForPuschMapTypeA.addPos =\
8038                         *(dmrsUlCfg->dmrs_AdditionalPosition);
8039                   }
8040                   if(dmrsUlCfg->transformPrecodingDisabled)
8041                   {
8042                      if(dmrsUlCfg->transformPrecodingDisabled->scramblingID0)
8043                      {
8044                         macPuschCfg->dmrsUlCfgForPuschMapTypeA.transPrecodDisabled.scramblingId0 = \
8045                            *(dmrsUlCfg->transformPrecodingDisabled->scramblingID0);
8046                      }
8047                   }
8048                }
8049             }
8050          }
8051          /*Res Alloc Type for UL */
8052          if(cuPuschCfg->choice.setup->resourceAllocation)
8053          {
8054             macPuschCfg->resourceAllocType = \
8055                cuPuschCfg->choice.setup->resourceAllocation;
8056          }
8057          if(cuPuschCfg->choice.setup->pusch_TimeDomainAllocationList)
8058          {
8059             timeDomAllocList = cuPuschCfg->choice.setup->pusch_TimeDomainAllocationList;
8060             if(timeDomAllocList->present == PUSCH_Config__pusch_TimeDomainAllocationList_PR_setup)
8061             {
8062                if(timeDomAllocList->choice.setup)
8063                {
8064                   macPuschCfg->numTimeDomRsrcAlloc = timeDomAllocList->choice.setup->list.count;
8065                   for(timeDomIdx = 0; timeDomIdx <timeDomAllocList->choice.setup->list.count; timeDomIdx++)
8066                   {
8067                      macPuschCfg->timeDomRsrcAllocList[timeDomIdx].k2 = \
8068                         *(timeDomAllocList->choice.setup->list.array[timeDomIdx]->k2);
8069                      macPuschCfg->timeDomRsrcAllocList[timeDomIdx].mappingType = \
8070                         timeDomAllocList->choice.setup->list.array[timeDomIdx]->mappingType;
8071                      macPuschCfg->timeDomRsrcAllocList[timeDomIdx].startSymbolAndLength = \
8072                         timeDomAllocList->choice.setup->list.array[timeDomIdx]->startSymbolAndLength;
8073                   }
8074                }
8075             }
8076          }
8077          if(cuPuschCfg->choice.setup->transformPrecoder)
8078             macPuschCfg->transformPrecoder = *(cuPuschCfg->choice.setup->transformPrecoder);
8079       }
8080    }
8081 }
8082
8083 /*******************************************************************
8084  *
8085  * @brief Function to fill pucch Power Control
8086  *
8087  * @details
8088  *
8089  *    Function : extractPucchPowerControl
8090  *
8091  *    Functionality: Function to fill pucch Power Control
8092  *
8093  * @params[in] PucchPowerControl *pwrCtrl,
8094  *             struct PUCCH_PowerControl *cuPwrCtrlCfg
8095  * @return void
8096  *
8097  * ****************************************************************/
8098
8099 void extractPucchPowerControl(PucchPowerControl *pwrCtrl, struct PUCCH_PowerControl *cuPwrCtrlCfg)
8100 {
8101    uint8_t arrIdx;
8102
8103    if(cuPwrCtrlCfg->deltaF_PUCCH_f0)
8104       pwrCtrl->deltaF_Format0 = *cuPwrCtrlCfg->deltaF_PUCCH_f0;
8105    if(cuPwrCtrlCfg->deltaF_PUCCH_f1)
8106       pwrCtrl->deltaF_Format1 = *cuPwrCtrlCfg->deltaF_PUCCH_f1;
8107    if(cuPwrCtrlCfg->deltaF_PUCCH_f2)
8108       pwrCtrl->deltaF_Format2 = *cuPwrCtrlCfg->deltaF_PUCCH_f2;
8109    if(cuPwrCtrlCfg->deltaF_PUCCH_f3)
8110       pwrCtrl->deltaF_Format3 = *cuPwrCtrlCfg->deltaF_PUCCH_f3;
8111    if(cuPwrCtrlCfg->deltaF_PUCCH_f4)
8112       pwrCtrl->deltaF_Format4 = *cuPwrCtrlCfg->deltaF_PUCCH_f4;
8113    if(cuPwrCtrlCfg->p0_Set)
8114    {
8115       pwrCtrl->p0SetCount = cuPwrCtrlCfg->p0_Set->list.count;
8116       for(arrIdx=0; arrIdx < pwrCtrl->p0SetCount; arrIdx++)
8117       {
8118          pwrCtrl->p0Set[arrIdx].p0PucchId =\
8119             cuPwrCtrlCfg->p0_Set->list.array[arrIdx]->p0_PUCCH_Id;
8120          pwrCtrl->p0Set[arrIdx].p0PucchVal =\
8121             cuPwrCtrlCfg->p0_Set->list.array[arrIdx]->p0_PUCCH_Value;
8122       }
8123    }
8124    if(cuPwrCtrlCfg->pathlossReferenceRSs)
8125    {
8126       pwrCtrl->pathLossRefRSListCount = cuPwrCtrlCfg->pathlossReferenceRSs->list.count;
8127       for(arrIdx = 0; arrIdx < pwrCtrl->pathLossRefRSListCount; arrIdx++)
8128       {
8129          pwrCtrl->pathLossRefRSList[arrIdx].pathLossRefRSId =\
8130             cuPwrCtrlCfg->pathlossReferenceRSs->list.array[arrIdx]->pucch_PathlossReferenceRS_Id;
8131       }
8132    }
8133 }
8134
8135  /*******************************************************************
8136  *
8137  * @brief Function to extractResrcSetToAddModList sent by CU
8138  *
8139  * @details
8140  *
8141  *    Function : extractResrcSetToAddModList
8142  *
8143  *    Functionality: Fucntion to extractResrcSetToAddModList
8144  *
8145  * @params[in] PucchResrcSetCfg pointer,
8146  *             struct PUCCH_Config__resourceSetToAddModList pointer
8147  * @return void
8148  *
8149  * ****************************************************************/
8150
8151 void extractResrcSetToAddModList(PucchResrcSetCfg *macRsrcSetList, struct PUCCH_Config__resourceSetToAddModList *cuRsrcSetList)
8152 {
8153    uint8_t arrIdx, rsrcListIdx;
8154
8155    macRsrcSetList->resrcSetToAddModListCount = cuRsrcSetList->list.count;
8156    for(arrIdx = 0; arrIdx < macRsrcSetList->resrcSetToAddModListCount; arrIdx++)
8157    {
8158       macRsrcSetList->resrcSetToAddModList[arrIdx].resrcSetId     =\
8159          cuRsrcSetList->list.array[arrIdx]->pucch_ResourceSetId;
8160       macRsrcSetList->resrcSetToAddModList[arrIdx].resrcListCount =\
8161          cuRsrcSetList->list.array[arrIdx]->resourceList.list.count;
8162       for(rsrcListIdx = 0; rsrcListIdx < macRsrcSetList->resrcSetToAddModList[arrIdx].resrcListCount; rsrcListIdx++)
8163       {
8164          macRsrcSetList->resrcSetToAddModList[arrIdx].resrcList[rsrcListIdx] =\
8165             *cuRsrcSetList->list.array[arrIdx]->resourceList.list.array[rsrcListIdx];
8166       }
8167       macRsrcSetList->resrcSetToAddModList[arrIdx].maxPayLoadSize =\
8168          *cuRsrcSetList->list.array[arrIdx]->maxPayloadMinus1;
8169    }
8170 }/* End of extractResrcSetToAddModList */
8171
8172 /*******************************************************************
8173  *
8174  * @brief Fills extractResrcToAddModList sent by CU
8175  *
8176  * @details
8177  *
8178  *    Function : extractResrcToAddModList
8179  *
8180  *    Functionality: Fills extractResrcToAddModList
8181  *
8182  * @params[in] PucchResrcCfg pointer,
8183  *             struct PUCCH_Config__resourceToAddModList pointer
8184  * @return ROk/RFAILED
8185  *
8186  * ****************************************************************/
8187
8188 uint8_t extractResrcToAddModList(PucchResrcCfg *macResrcList, struct PUCCH_Config__resourceToAddModList *cuResrcList)
8189 {
8190    uint8_t arrIdx;
8191
8192    macResrcList->resrcToAddModListCount = cuResrcList->list.count;
8193    for(arrIdx = 0; arrIdx < macResrcList->resrcToAddModListCount; arrIdx++)
8194    {
8195       macResrcList->resrcToAddModList[arrIdx].resrcId      =\
8196         cuResrcList->list.array[arrIdx]->pucch_ResourceId;
8197       macResrcList->resrcToAddModList[arrIdx].startPrb     =\
8198         cuResrcList->list.array[arrIdx]->startingPRB;
8199       if(cuResrcList->list.array[arrIdx]->intraSlotFrequencyHopping)
8200       {
8201          macResrcList->resrcToAddModList[arrIdx].intraFreqHop =\
8202            *cuResrcList->list.array[arrIdx]->intraSlotFrequencyHopping;
8203       }
8204       if(cuResrcList->list.array[arrIdx]->secondHopPRB)
8205       {
8206          macResrcList->resrcToAddModList[arrIdx].secondPrbHop =\
8207            *cuResrcList->list.array[arrIdx]->secondHopPRB;
8208       }
8209       /* PUCCH RSRC FORMAT */
8210       if(cuResrcList->list.array[arrIdx]->format.present == PUCCH_Resource__format_PR_format0)
8211       {
8212          macResrcList->resrcToAddModList[arrIdx].pucchFormat = PUCCH_FORMAT_0;
8213          if(cuResrcList->list.array[arrIdx]->format.choice.format0)
8214          {
8215             DU_ALLOC_SHRABL_BUF(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format0, sizeof(PucchFormat0));
8216             if(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format0 == NULLP)
8217             {
8218                DU_LOG("\nERROR  --> F1AP : Failed to allocate memory for Format0 in extractResrcToAddModList()");
8219                return RFAILED;
8220             }
8221             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format0->initialCyclicShift =\
8222                cuResrcList->list.array[arrIdx]->format.choice.format0->initialCyclicShift;
8223             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format0->numSymbols =\
8224                cuResrcList->list.array[arrIdx]->format.choice.format0->nrofSymbols;
8225             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format0->startSymbolIdx =\
8226                cuResrcList->list.array[arrIdx]->format.choice.format0->startingSymbolIndex;
8227          }
8228       }
8229       else if(cuResrcList->list.array[arrIdx]->format.present == PUCCH_Resource__format_PR_format1)
8230       {
8231          macResrcList->resrcToAddModList[arrIdx].pucchFormat = PUCCH_FORMAT_1;
8232          if(cuResrcList->list.array[arrIdx]->format.choice.format1)
8233          {
8234             DU_ALLOC_SHRABL_BUF(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1, sizeof(PucchFormat1));
8235             if(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1 == NULLP)
8236             {
8237                DU_LOG("\nERROR  --> F1AP : Failed to allocate memory for Format1 in extractResrcToAddModList()");
8238                return RFAILED;
8239             }
8240             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1->initialCyclicShift =\
8241                 cuResrcList->list.array[arrIdx]->format.choice.format1->initialCyclicShift;
8242             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1->numSymbols =\
8243                 cuResrcList->list.array[arrIdx]->format.choice.format1->nrofSymbols;
8244             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1->startSymbolIdx =\
8245                 cuResrcList->list.array[arrIdx]->format.choice.format1->startingSymbolIndex;
8246             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1->timeDomOCC =\
8247                 cuResrcList->list.array[arrIdx]->format.choice.format1->timeDomainOCC;
8248          }
8249       }
8250       else if(cuResrcList->list.array[arrIdx]->format.present == PUCCH_Resource__format_PR_format2)
8251       {
8252          macResrcList->resrcToAddModList[arrIdx].pucchFormat = PUCCH_FORMAT_2;
8253          if(cuResrcList->list.array[arrIdx]->format.choice.format2)
8254          {
8255             DU_ALLOC_SHRABL_BUF(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format2, sizeof(PucchFormat2_3));
8256             if(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format2 == NULLP)
8257             {
8258                DU_LOG("\nERROR  --> F1AP : Failed to allocate memory for Format2 in extractResrcToAddModList()");
8259                return RFAILED;
8260             }
8261             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format2->numPrbs =\
8262                 cuResrcList->list.array[arrIdx]->format.choice.format2->nrofPRBs;
8263             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format2->numSymbols =\
8264                 cuResrcList->list.array[arrIdx]->format.choice.format2->nrofSymbols;
8265             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format2->startSymbolIdx =\
8266                 cuResrcList->list.array[arrIdx]->format.choice.format2->startingSymbolIndex;
8267          }
8268       }
8269       else if(cuResrcList->list.array[arrIdx]->format.present == PUCCH_Resource__format_PR_format3)
8270       {
8271          macResrcList->resrcToAddModList[arrIdx].pucchFormat = PUCCH_FORMAT_3;
8272          if(cuResrcList->list.array[arrIdx]->format.choice.format3)
8273          {
8274             DU_ALLOC_SHRABL_BUF(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format3, sizeof(PucchFormat2_3));
8275             if(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format3 == NULLP)
8276             {
8277                DU_LOG("\nERROR  --> F1AP : Failed to allocate memory for Format3 in extractResrcToAddModList()");
8278                return RFAILED;
8279             }
8280             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format3->numPrbs =\
8281                 cuResrcList->list.array[arrIdx]->format.choice.format3->nrofPRBs;
8282             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format3->numSymbols =\
8283                 cuResrcList->list.array[arrIdx]->format.choice.format3->nrofSymbols;
8284             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format3->startSymbolIdx =\
8285                 cuResrcList->list.array[arrIdx]->format.choice.format3->startingSymbolIndex;
8286          }
8287       }
8288       else if(cuResrcList->list.array[arrIdx]->format.present == PUCCH_Resource__format_PR_format4)
8289       {
8290          macResrcList->resrcToAddModList[arrIdx].pucchFormat = PUCCH_FORMAT_4;
8291          if(cuResrcList->list.array[arrIdx]->format.choice.format4)
8292          {
8293             DU_ALLOC_SHRABL_BUF(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4, sizeof(PucchFormat4));
8294             if(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4 == NULLP)
8295             {
8296                DU_LOG("\nERROR  --> F1AP : Failed to allocate memory for Format4 in extractResrcToAddModList()");
8297                return RFAILED;
8298             }
8299             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4->numSymbols =\
8300                 cuResrcList->list.array[arrIdx]->format.choice.format4->nrofSymbols;
8301             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4->occLen =\
8302                 cuResrcList->list.array[arrIdx]->format.choice.format4->occ_Length;
8303             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4->occIdx =\
8304                 cuResrcList->list.array[arrIdx]->format.choice.format4->occ_Index;
8305             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4->startSymbolIdx =\
8306                 cuResrcList->list.array[arrIdx]->format.choice.format4->startingSymbolIndex;
8307          }
8308       }
8309    }
8310    return ROK;
8311
8312 }/* End of extractResrcToAddModList */
8313
8314 /*******************************************************************
8315  *
8316  * @brief Fills fillPucchSchedReqPeriodAndOffset sent by CU
8317  *
8318  * @details
8319  *
8320  *    Function : fillPucchSchedReqPeriodAndOffset
8321  *
8322  *    Functionality: To fillPucchSchedReqPeriodAndOffset
8323  *
8324  * @params[in] macPeriodicty,
8325  *     SchedulingRequestResourceConfig__periodicityAndOffset pointer
8326  * @return void
8327  *
8328  * ****************************************************************/
8329
8330 void fillPucchSchedReqPeriodAndOffset(uint8_t macPeriodicty, uint16_t  macOffset,\
8331    struct SchedulingRequestResourceConfig__periodicityAndOffset *cuPeriodicty)
8332 {
8333    macPeriodicty = cuPeriodicty->present;
8334    switch(macPeriodicty)
8335    {
8336       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sym2:
8337          {
8338             macOffset     = cuPeriodicty->choice.sym2;
8339             break;
8340          }
8341       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sym6or7:
8342          {
8343             macOffset     = cuPeriodicty->choice.sym6or7;
8344             break;
8345          }
8346       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl1:
8347          {
8348             macOffset     = cuPeriodicty->choice.sl1;
8349             break;
8350          }
8351       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl2:
8352          {
8353             macOffset = cuPeriodicty->choice.sl2;
8354             break;
8355          }
8356       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl4:
8357          {
8358             macOffset = cuPeriodicty->choice.sl4;
8359             break;
8360          }
8361       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl5:
8362          {
8363             macOffset = cuPeriodicty->choice.sl5;
8364             break;
8365          }
8366       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl8:
8367          {
8368             macOffset = cuPeriodicty->choice.sl8;
8369             break;
8370          }
8371       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl10:
8372          {
8373             macOffset = cuPeriodicty->choice.sl10;
8374             break;
8375          }
8376       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl16:
8377          {
8378             macOffset = cuPeriodicty->choice.sl16;
8379             break;
8380          }
8381       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl20:
8382          {
8383             macOffset = cuPeriodicty->choice.sl20;
8384             break;
8385          }
8386       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl40:
8387          {
8388             macOffset = cuPeriodicty->choice.sl40;
8389             break;
8390          }
8391       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl80:
8392          {
8393             macOffset = cuPeriodicty->choice.sl80;
8394             break;
8395          }
8396       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl160:
8397          {
8398             macOffset = cuPeriodicty->choice.sl160;
8399             break;
8400          }
8401       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl320:
8402          {
8403             macOffset = cuPeriodicty->choice.sl320;
8404             break;
8405          }
8406       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl640:
8407          {
8408             macOffset = cuPeriodicty->choice.sl640;
8409             break;
8410          }
8411       default :
8412          DU_LOG("\nERROR  -->  F1AP : Invalid periodicity %d", macPeriodicty);
8413    }
8414 }
8415
8416 /*******************************************************************
8417  *
8418  * @brief Function to extractPucchFormatCfg sent by CU
8419  *
8420  * @details
8421  *
8422  *    Function : extractPucchFormatCfg
8423  *
8424  *    Functionality: Function to extractPucchFormatCfg
8425  *
8426  * @params[in] PucchFormatCfg pointer,
8427  *             PUCCH_FormatConfig_t pointer
8428  * @return void
8429  *
8430  * ****************************************************************/
8431
8432 void extractPucchFormatCfg(PucchFormatCfg *macFormatCfg, PUCCH_FormatConfig_t *cuFormatCfg)
8433  {
8434     if(cuFormatCfg->interslotFrequencyHopping)
8435        macFormatCfg->interSlotFreqHop = *cuFormatCfg->interslotFrequencyHopping;
8436     if(cuFormatCfg->additionalDMRS)
8437        macFormatCfg->addDmrs = *cuFormatCfg->additionalDMRS;
8438     if(cuFormatCfg->maxCodeRate)
8439        macFormatCfg->maxCodeRate = *cuFormatCfg->maxCodeRate;
8440     if(cuFormatCfg->nrofSlots)
8441        macFormatCfg->numSlots = *cuFormatCfg->nrofSlots;
8442     if(cuFormatCfg->pi2BPSK)
8443        macFormatCfg->pi2BPSK = *cuFormatCfg->pi2BPSK;
8444     if(cuFormatCfg->simultaneousHARQ_ACK_CSI)
8445        macFormatCfg->harqAckCSI = *cuFormatCfg->simultaneousHARQ_ACK_CSI;
8446  }/* End of extractPucchFormatCfg */
8447
8448 /*******************************************************************
8449  *
8450  * @brief Function to extractSchedReqCfgToAddMod sent by CU
8451  *
8452  * @details
8453  *
8454  *    Function : extractSchedReqCfgToAddMod
8455  *
8456  *    Functionality: Function to extractSchedReqCfgToAddMod
8457  *
8458  * @params[in] PucchSchedReqCfg pointer,
8459  *      PUCCH_Config__schedulingRequestResourceToAddModList pointer
8460  * @return void
8461  *
8462  * ****************************************************************/
8463
8464 void extractSchedReqCfgToAddMod(PucchSchedReqCfg *macSchedReqCfg, struct PUCCH_Config__schedulingRequestResourceToAddModList *cuSchedReqList)
8465 {
8466    uint8_t arrIdx;
8467
8468    macSchedReqCfg->schedAddModListCount = cuSchedReqList->list.count;
8469    for(arrIdx = 0; arrIdx <  macSchedReqCfg->schedAddModListCount; arrIdx++)
8470    {
8471       macSchedReqCfg->schedAddModList[arrIdx].resrcId =\
8472          cuSchedReqList->list.array[arrIdx]->schedulingRequestResourceId;
8473       macSchedReqCfg->schedAddModList[arrIdx].requestId =\
8474          cuSchedReqList->list.array[arrIdx]->schedulingRequestID;
8475       if(cuSchedReqList->list.array[arrIdx]->periodicityAndOffset)
8476       {
8477          fillPucchSchedReqPeriodAndOffset(macSchedReqCfg->schedAddModList[arrIdx].periodicity,\
8478             macSchedReqCfg->schedAddModList[arrIdx].offset, cuSchedReqList->list.array[arrIdx]->periodicityAndOffset);
8479       }
8480       if(cuSchedReqList->list.array[arrIdx]->resource)
8481       {
8482          macSchedReqCfg->schedAddModList[arrIdx].resrc =\
8483             *cuSchedReqList->list.array[arrIdx]->resource;
8484       }
8485    }
8486
8487 }/* End of extractSchedReqCfgToAddMod */
8488
8489  /*******************************************************************
8490  *
8491  * @brief Fills PucchCfg received by CU
8492  *
8493  * @details
8494  *
8495  *    Function : extractPucchCfg
8496  *
8497  *    Functionality: Fills PucchCfg received  by CU
8498  *
8499  * @params[in] BWP_UplinkDedicated__pucch_Config *cuPucchCfg,
8500  *             PucchCfg *macPucchCfg
8501  * @return ROK/RFAILED
8502  *
8503  * ****************************************************************/
8504
8505 uint8_t extractPucchCfg(struct BWP_UplinkDedicated__pucch_Config *cuPucchCfg, PucchCfg *macPucchCfg)
8506 {
8507    uint8_t arrIdx;
8508
8509    if(cuPucchCfg->present == BWP_UplinkDedicated__pucch_Config_PR_setup)
8510    {
8511       if(cuPucchCfg->choice.setup)
8512       {
8513          /* Resource Set Cfg */
8514          if(cuPucchCfg->choice.setup->resourceSetToAddModList)
8515          {
8516             DU_ALLOC_SHRABL_BUF(macPucchCfg->resrcSet, sizeof(PucchResrcSetCfg));
8517             if(macPucchCfg->resrcSet == NULLP)
8518             {
8519                DU_LOG("\nERROR --> F1AP : Failed to extract Resrc set List in extractPucchCfg()");
8520                return RFAILED;
8521             }
8522             memset(macPucchCfg->resrcSet, 0, sizeof(PucchResrcSetCfg));
8523             extractResrcSetToAddModList(macPucchCfg->resrcSet, cuPucchCfg->choice.setup->resourceSetToAddModList);
8524          }
8525
8526          /* Resource Cfg */
8527          if(cuPucchCfg->choice.setup->resourceToAddModList)
8528          {
8529             DU_ALLOC_SHRABL_BUF(macPucchCfg->resrc, sizeof(PucchResrcCfg));
8530             if(macPucchCfg->resrc == NULLP)
8531             {
8532                DU_LOG("\nERROR --> F1AP : Failed to extract Resrc List in extractPucchCfg()");
8533                return RFAILED;
8534             }
8535             memset(macPucchCfg->resrc, 0, sizeof(PucchResrcCfg));
8536             extractResrcToAddModList(macPucchCfg->resrc, cuPucchCfg->choice.setup->resourceToAddModList);
8537          }
8538
8539          /* Format 1 Cfg */
8540          if(cuPucchCfg->choice.setup->format1)
8541          {
8542             DU_ALLOC_SHRABL_BUF(macPucchCfg->format1, sizeof(PucchFormatCfg));
8543             if(macPucchCfg->format1 == NULLP)
8544             {
8545                DU_LOG("\nERROR --> F1AP : Failed to extract format 1 Cfg in  extractPucchCfg()");
8546                return RFAILED;
8547             }
8548             memset(macPucchCfg->format1, 0, sizeof(PucchFormatCfg));
8549             extractPucchFormatCfg(macPucchCfg->format1,\
8550                cuPucchCfg->choice.setup->format1->choice.setup);
8551          }
8552
8553          /* Format 2 Cfg */
8554          if(cuPucchCfg->choice.setup->format2)
8555          {
8556             DU_ALLOC_SHRABL_BUF(macPucchCfg->format2, sizeof(PucchFormatCfg));
8557             if(macPucchCfg->format2 == NULLP)
8558             {
8559                DU_LOG("\nERROR --> F1AP : Failed to extract format 2 Cfg in  extractPucchCfg()");
8560                return RFAILED;
8561             }
8562             memset(macPucchCfg->format2, 0, sizeof(PucchFormatCfg));
8563             extractPucchFormatCfg(macPucchCfg->format2,\
8564                cuPucchCfg->choice.setup->format2->choice.setup);
8565          }
8566
8567          /* Format 3 Cfg */
8568          if(cuPucchCfg->choice.setup->format3)
8569          {
8570             DU_ALLOC_SHRABL_BUF(macPucchCfg->format3, sizeof(PucchFormatCfg));
8571             if(macPucchCfg->format3 == NULLP)
8572             {
8573                DU_LOG("\nERROR --> F1AP : Failed to extract format 3 Cfg in  extractPucchCfg()");
8574                return RFAILED;
8575             }
8576             memset(macPucchCfg->format3, 0, sizeof(PucchFormatCfg));
8577             extractPucchFormatCfg(macPucchCfg->format3,\
8578                cuPucchCfg->choice.setup->format3->choice.setup);
8579          }
8580
8581          /* Format 4 Cfg */
8582          if(cuPucchCfg->choice.setup->format4)
8583          {
8584             DU_ALLOC_SHRABL_BUF(macPucchCfg->format4, sizeof(PucchFormatCfg));
8585             if(macPucchCfg->format4 == NULLP)
8586             {
8587                DU_LOG("\nERROR --> F1AP : Failed to extract format 4 Cfg in  extractPucchCfg()");
8588                return RFAILED;
8589             }
8590             memset(macPucchCfg->format4, 0, sizeof(PucchFormatCfg));
8591             extractPucchFormatCfg(macPucchCfg->format4,\
8592                cuPucchCfg->choice.setup->format4->choice.setup);
8593          }
8594
8595          /* Sched Req List */
8596          if(cuPucchCfg->choice.setup->schedulingRequestResourceToAddModList)
8597          {
8598             DU_ALLOC_SHRABL_BUF(macPucchCfg->schedReq, sizeof(PucchSchedReqCfg));
8599             if(macPucchCfg->schedReq == NULLP)
8600             {
8601                DU_LOG("\nERROR --> F1AP : Failed to extract schedReqCfg in  extractPucchCfg()");
8602                return RFAILED;
8603             }
8604             memset(macPucchCfg->schedReq, 0, sizeof(PucchSchedReqCfg));
8605             extractSchedReqCfgToAddMod(macPucchCfg->schedReq,\
8606             cuPucchCfg->choice.setup->schedulingRequestResourceToAddModList);
8607          }
8608
8609          /*TODO: Add support for  Spatial Info */
8610
8611          /* MultiCsiCfg */
8612          if(cuPucchCfg->choice.setup->multi_CSI_PUCCH_ResourceList)
8613          {
8614             DU_ALLOC_SHRABL_BUF(macPucchCfg->multiCsiCfg, sizeof(PucchMultiCsiCfg));
8615             if(macPucchCfg->multiCsiCfg == NULLP)
8616             {
8617                DU_LOG("\nERROR --> F1AP : Failed to extract multiCsiCfg in  extractPucchCfg()");
8618                return RFAILED;
8619             }
8620             memset(macPucchCfg->multiCsiCfg, 0, sizeof(PucchMultiCsiCfg));
8621             macPucchCfg->multiCsiCfg->multiCsiResrcListCount = cuPucchCfg->choice.setup->multi_CSI_PUCCH_ResourceList->list.count;
8622             for(arrIdx =0; arrIdx < macPucchCfg->multiCsiCfg->multiCsiResrcListCount; arrIdx++)
8623             {
8624                macPucchCfg->multiCsiCfg->multiCsiResrcList[arrIdx] =\
8625                  *cuPucchCfg->choice.setup->multi_CSI_PUCCH_ResourceList->list.array[arrIdx];
8626             }
8627          }
8628
8629          /* Dl_DataToUL_ACK */
8630          if(cuPucchCfg->choice.setup->dl_DataToUL_ACK)
8631          {
8632             DU_ALLOC_SHRABL_BUF(macPucchCfg->dlDataToUlAck, sizeof(PucchDlDataToUlAck));
8633             if(macPucchCfg->dlDataToUlAck == NULLP)
8634             {
8635                DU_LOG("\nERROR --> F1AP : Failed to extract Dl_DataToUL_ACK in extractPucchCfg()");
8636                return RFAILED;
8637             }
8638             memset(macPucchCfg->dlDataToUlAck, 0, sizeof(PucchDlDataToUlAck));
8639             macPucchCfg->dlDataToUlAck->dlDataToUlAckListCount = cuPucchCfg->choice.setup->dl_DataToUL_ACK->list.count;
8640             for(arrIdx = 0; arrIdx < macPucchCfg->dlDataToUlAck->dlDataToUlAckListCount; arrIdx++)
8641             {
8642                macPucchCfg->dlDataToUlAck->dlDataToUlAckList[arrIdx] =\
8643                   *cuPucchCfg->choice.setup->dl_DataToUL_ACK->list.array[arrIdx];
8644             }
8645          }
8646
8647          /* Power Control */
8648          if(cuPucchCfg->choice.setup->pucch_PowerControl)
8649          {
8650             DU_ALLOC_SHRABL_BUF(macPucchCfg->powerControl, sizeof(PucchPowerControl));
8651             if(macPucchCfg->powerControl == NULLP)
8652             {
8653                DU_LOG("\nERROR --> F1AP : Failed to extract power control in extractPucchCfg()");
8654                return RFAILED;
8655             }
8656             extractPucchPowerControl(macPucchCfg->powerControl,\
8657                cuPucchCfg->choice.setup->pucch_PowerControl);
8658          }
8659       }
8660    }
8661    return ROK;
8662 }
8663
8664 /*******************************************************************
8665  *
8666  * @brief Fills ServingCellReconfig received by CU
8667  *
8668  * @details
8669  *
8670  *    Function : extractSpCellDedicatedCfg
8671  *
8672  *    Functionality: Fills ServingCellReconfig received  by CU
8673  *
8674  * @params[in] ServingCellConfig_t *cuSrvCellCfg
8675  *             ServCellCfgInfo *macSrvCellCfg
8676  * @return ROK/RFAILD
8677  *
8678  * ****************************************************************/
8679 uint8_t extractSpCellDedicatedCfg(ServingCellConfig_t *cuSrvCellCfg, ServCellCfgInfo *macSrvCellCfg)
8680 {
8681    uint8_t ret = ROK;
8682    BWP_DownlinkDedicated_t *dlBwp = NULLP;
8683    BWP_UplinkDedicated_t   *ulBwp = NULLP;
8684
8685    if(cuSrvCellCfg->initialDownlinkBWP)
8686    {
8687       dlBwp = ((BWP_DownlinkDedicated_t *)(cuSrvCellCfg->initialDownlinkBWP));
8688       if(dlBwp->pdcch_Config)
8689       {
8690          if(dlBwp->pdcch_Config->choice.setup)
8691          {
8692             macSrvCellCfg->initDlBwp.pdcchPresent = true;
8693             extractPdcchCfg(dlBwp->pdcch_Config->choice.setup, &macSrvCellCfg->initDlBwp.pdcchCfg);
8694          }
8695       }
8696       if(dlBwp->pdsch_Config)
8697       {
8698          if(dlBwp->pdsch_Config->choice.setup)
8699          {
8700             macSrvCellCfg->initDlBwp.pdschPresent = true;
8701             extractPdschCfg(dlBwp->pdsch_Config->choice.setup, &macSrvCellCfg->initDlBwp.pdschCfg);
8702          }
8703       }
8704    }
8705    if(cuSrvCellCfg->firstActiveDownlinkBWP_Id)
8706       macSrvCellCfg->firstActvDlBwpId = *(cuSrvCellCfg->firstActiveDownlinkBWP_Id);
8707    if(cuSrvCellCfg->defaultDownlinkBWP_Id)
8708       macSrvCellCfg->defaultDlBwpId = *(cuSrvCellCfg->defaultDownlinkBWP_Id);
8709    if(cuSrvCellCfg->bwp_InactivityTimer)
8710    {
8711       if(macSrvCellCfg->bwpInactivityTmr)
8712       {
8713          memcpy(macSrvCellCfg->bwpInactivityTmr, cuSrvCellCfg->bwp_InactivityTimer, sizeof(uint8_t));
8714       }
8715       else
8716       {
8717          macSrvCellCfg->bwpInactivityTmr = NULLP;
8718          DU_ALLOC_SHRABL_BUF(macSrvCellCfg->bwpInactivityTmr, sizeof(uint8_t));
8719          if(macSrvCellCfg->bwpInactivityTmr)
8720          {
8721             memcpy(macSrvCellCfg->bwpInactivityTmr, cuSrvCellCfg->bwp_InactivityTimer, sizeof(uint8_t));
8722          }
8723          else
8724          {
8725             DU_LOG("\nERROR  --> F1AP : Memory Alloc failed for bwpInactivityTmr at extractSpCellDedicatedCfg()");
8726             return RFAILED;
8727          }
8728       }
8729    }
8730    if(cuSrvCellCfg->pdsch_ServingCellConfig)
8731    {
8732       if(cuSrvCellCfg->pdsch_ServingCellConfig->choice.setup)
8733       {
8734          ret = extractPdschServingCellCfg(cuSrvCellCfg->pdsch_ServingCellConfig->choice.setup, &macSrvCellCfg->pdschServCellCfg);
8735          if(ret == RFAILED)
8736          {
8737             DU_LOG("\nERROR --> F1AP : Failed at extractPdschServingCellCfg()");
8738             return RFAILED;
8739          }
8740       }
8741    }
8742    if(cuSrvCellCfg->uplinkConfig)
8743    {
8744      if(cuSrvCellCfg->uplinkConfig->initialUplinkBWP)
8745      {
8746         ulBwp = ((BWP_UplinkDedicated_t *)(cuSrvCellCfg->uplinkConfig->initialUplinkBWP));
8747         if(ulBwp->pusch_Config)
8748         {
8749            macSrvCellCfg->initUlBwp.puschPresent = true;
8750            extractPuschCfg(ulBwp->pusch_Config, &macSrvCellCfg->initUlBwp.puschCfg);
8751         }
8752         if(ulBwp->pucch_Config)
8753         {
8754            macSrvCellCfg->initUlBwp.pucchPresent = true;
8755            memset(&macSrvCellCfg->initUlBwp.pucchCfg, 0, sizeof(PucchCfg));
8756            extractPucchCfg(ulBwp->pucch_Config, &macSrvCellCfg->initUlBwp.pucchCfg);
8757         }
8758      }
8759      if(cuSrvCellCfg->uplinkConfig->firstActiveUplinkBWP_Id)
8760         macSrvCellCfg->firstActvUlBwpId = *(cuSrvCellCfg->uplinkConfig->firstActiveUplinkBWP_Id);
8761    }
8762    return ret;
8763 }
8764 /*******************************************************************
8765  *
8766  * @brief Fills Reconfig Cell group Info received by CU
8767  *
8768  * @details
8769  *
8770  *    Function : extractUeReCfgCellInfo
8771  *
8772  *    Functionality: Fills Reconfig Cell group Info received by CU
8773  *
8774  * @params[in] CellGroupConfigRrc_t *macCellGrpCfg
8775  *             MacUeCfg*  macUeCfg
8776  * @return ROK/RFAILED
8777  *
8778  * ****************************************************************/
8779 uint8_t extractUeReCfgCellInfo(CellGroupConfigRrc_t *cellGrp, MacUeCfg *macUeCfg)
8780 {
8781    uint8_t ret = ROK;
8782    MAC_CellGroupConfig_t     *macCellGroup = NULLP;
8783    PhysicalCellGroupConfig_t *phyCellGrpCfg = NULLP;
8784    SpCellConfig_t            *spcellCfg = NULLP;
8785    ServingCellConfig_t       *servCellCfg = NULLP;
8786
8787    if(cellGrp)
8788    {
8789       /* Fill MacCell Group Reconfig  */
8790       if(cellGrp->mac_CellGroupConfig)
8791       {
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          phyCellGrpCfg = ((PhysicalCellGroupConfig_t *)(cellGrp->physicalCellGroupConfig));
8840          if(phyCellGrpCfg->p_NR_FR1)
8841          {
8842             if(*(phyCellGrpCfg->p_NR_FR1) != macUeCfg->phyCellGrpCfg.pNrFr1)
8843                macUeCfg->phyCellGrpCfg.pNrFr1 = *(phyCellGrpCfg->p_NR_FR1);
8844          }
8845          macUeCfg->phyCellGrpCfg.pdschHarqAckCodebook = phyCellGrpCfg->pdsch_HARQ_ACK_Codebook;
8846       }
8847       /* Fill SpCell Reconfig */
8848       if(cellGrp->spCellConfig)
8849       {
8850          spcellCfg = ((SpCellConfig_t *)(cellGrp->spCellConfig));
8851          if(spcellCfg->servCellIndex)
8852          {
8853             macUeCfg->spCellCfg.servCellIdx = *(spcellCfg->servCellIndex);
8854          }
8855          /* Fill Serving cell Reconfig info */
8856          if(cellGrp->spCellConfig->spCellConfigDedicated)
8857          {
8858             servCellCfg = ((ServingCellConfig_t *)(cellGrp->spCellConfig->spCellConfigDedicated));
8859             ret = extractSpCellDedicatedCfg(servCellCfg, &macUeCfg->spCellCfg.servCellCfg);
8860             if(ret == RFAILED)
8861             {
8862                DU_LOG("\nERROR --> F1AP : Failed at extractSpCellDedicatedCfg()");
8863             }
8864          }
8865       }
8866    }
8867    return ret;
8868 }
8869 /*******************************************************************
8870 *
8871 * @brief free the memory allocated by decoder
8872 *
8873 * @details
8874 *
8875 *    Function : freeAperDecodeNrcgi
8876 *
8877 *    Functionality: Free Nrcgi values
8878 *
8879 * @params[in] NRCGI_t *nrcgi
8880 * @return void
8881 *
8882 * ****************************************************************/
8883
8884
8885 void freeAperDecodeNrcgi(NRCGI_t *nrcgi)
8886 {
8887     if(nrcgi->pLMN_Identity.buf != NULLP)
8888     {
8889        free(nrcgi->pLMN_Identity.buf);
8890     }
8891     if(nrcgi->nRCellIdentity.buf != NULLP)
8892     {
8893        free(nrcgi->nRCellIdentity.buf);
8894     }
8895 }
8896 /*******************************************************************
8897 *
8898 * @brief free the memory allocated by decoder
8899 *
8900 * @details
8901 *
8902 *    Function : freeAperDecodeCuToDuInfo
8903 *
8904 *    Functionality:  Free Cu To Du Information
8905 *
8906 * @params[in] CUtoDURRCInformation_t *rrcMsg
8907 * @return void
8908 *
8909 * ****************************************************************/
8910
8911
8912 void freeAperDecodeCuToDuInfo(CUtoDURRCInformation_t *rrcMsg)
8913 {
8914    uint8_t ieIdx =0;
8915    uint8_t arrIdx =0;
8916
8917    if(rrcMsg->uE_CapabilityRAT_ContainerList)
8918    {
8919       if(rrcMsg->uE_CapabilityRAT_ContainerList->buf)
8920          free(rrcMsg->uE_CapabilityRAT_ContainerList->buf);
8921       free(rrcMsg->uE_CapabilityRAT_ContainerList);
8922    }
8923
8924    if(rrcMsg->iE_Extensions)
8925    {
8926       if(rrcMsg->iE_Extensions->list.array)
8927       {
8928          for(ieIdx= 0; ieIdx < rrcMsg->iE_Extensions->list.count; ieIdx++)
8929          {
8930             if(rrcMsg->iE_Extensions->list.array[ieIdx])
8931             {
8932                switch(rrcMsg->iE_Extensions->list.array[ieIdx]->id)
8933                {
8934                   case ProtocolIE_ID_id_CellGroupConfig:
8935                      if(rrcMsg->iE_Extensions->list.array[ieIdx]->extensionValue.choice.CellGroupConfig.buf != NULLP)
8936                      {
8937                         free(rrcMsg->iE_Extensions->list.array[ieIdx]->extensionValue.choice.CellGroupConfig.buf);
8938                      }
8939                      break;
8940                   default:
8941                      DU_LOG("\nERROR  -->  F1AP : Invalid Event type %ld at FreeCuToDuInfo()", \
8942                            rrcMsg->iE_Extensions->list.array[ieIdx]->id);
8943                      break;
8944                }
8945             }
8946          }
8947          for(arrIdx = 0; arrIdx < ieIdx; arrIdx++)
8948          {
8949             free(rrcMsg->iE_Extensions->list.array[arrIdx]);
8950          }
8951          free(rrcMsg->iE_Extensions->list.array);
8952
8953       }
8954
8955       free(rrcMsg->iE_Extensions);
8956    }
8957 }
8958 /*******************************************************************
8959 *
8960 * @brief free the memory allocated by decoder
8961 *
8962 * @details
8963 *
8964 *    Function : freeAperDecodeSplCellList
8965 *
8966 *    Functionality: Free Spl Cell List
8967                     where memory allocated by aper_decoder
8968 *
8969 * @params[in]  SCell_ToBeSetup_List_t *spCellLst
8970 * @return void
8971 *
8972 * ****************************************************************/
8973
8974
8975 void freeAperDecodeSplCellList(SCell_ToBeSetup_List_t *spCellLst)
8976 {
8977     uint8_t  cellIdx =0;
8978
8979     if(spCellLst->list.array != NULLP)
8980     {
8981        for(cellIdx=0; cellIdx<spCellLst->list.count; cellIdx++)
8982        {
8983           if(cellIdx==0&&spCellLst->list.array[cellIdx]!=NULLP)
8984           {
8985              freeAperDecodeNrcgi(&spCellLst->list.array[cellIdx]->value.choice.SCell_ToBeSetup_Item.sCell_ID);
8986           }
8987           if(spCellLst->list.array[cellIdx]!=NULLP)
8988           {
8989              free(spCellLst->list.array[cellIdx]);
8990           }
8991        }
8992        free(spCellLst->list.array);
8993     }
8994 }
8995 /*******************************************************************
8996 *
8997 * @brief free the memory allocated by decoder
8998 *
8999 * @details
9000 *
9001 *    Function : freeAperDecodeSRBSetup
9002 *
9003 *    Functionality: added free part for the memory allocated by aper_decoder
9004 *
9005 * @params[in] SRBs_ToBeSetup_List_t *srbSet
9006 * @return void
9007 *
9008 ****************************************************************/
9009
9010
9011 void freeAperDecodeSRBSetup(SRBs_ToBeSetup_List_t *srbSet)
9012 {
9013     uint8_t srbIdx =0;
9014     if(srbSet->list.array != NULLP)
9015     {
9016        for(srbIdx=0; srbIdx<srbSet->list.count; srbIdx++)
9017        {
9018           if(srbSet->list.array[srbIdx]!=NULLP)
9019           {
9020              free(srbSet->list.array[srbIdx]);
9021           }
9022        }
9023        free(srbSet->list.array);
9024     }
9025 }
9026
9027 /*******************************************************************
9028 *
9029 * @brief free the memory allocated by decoder
9030 *
9031 * @details
9032 *
9033 *    Function : freeAperDecodeULTnlInfo
9034 *
9035 *    Functionality: added free part for the memory allocated by aper_decoder
9036 *
9037 * @params[in] ULUPTNLInformation_ToBeSetup_List_t *ulInfo
9038 * @return void
9039 *
9040 * ****************************************************************/
9041
9042
9043 void freeAperDecodeULTnlInfo(ULUPTNLInformation_ToBeSetup_List_t *ulInfo)
9044 {
9045    uint8_t ulIdx=0;
9046    if(ulInfo->list.array != NULLP)
9047    {
9048       for(ulIdx=0; ulIdx<ulInfo->list.count; ulIdx++)
9049       {
9050          if(ulIdx==0&&ulInfo->list.array[ulIdx]!=NULLP)
9051          {
9052             if(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel!=NULLP)
9053             {
9054                if(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel->\
9055                      transportLayerAddress.buf != NULLP)
9056                {
9057                   if(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf\
9058                         !=NULLP)
9059                   {
9060                      free(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf);
9061                   }
9062                   free(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel->\
9063                         transportLayerAddress.buf);
9064                }
9065                free(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel);
9066             }
9067          }
9068          if(ulInfo->list.array[ulIdx]!=NULLP)
9069          {
9070             free(ulInfo->list.array[ulIdx]);
9071          }
9072       }
9073       free(ulInfo->list.array);
9074    }
9075 }
9076 /*******************************************************************
9077 *
9078 * @brief free the memory allocated by decoder
9079 *
9080 * @details
9081 *
9082 *    Function : freeAperDecodeDRBSetup
9083 *
9084 *    Functionality: free DRBSetup which is allocated by decoder
9085 *
9086 * @params[in]  DRBs_ToBeSetup_List_t *drbSet
9087 * @return void
9088 *
9089 * ****************************************************************/
9090
9091 void freeAperDecodeDRBSetup(DRBs_ToBeSetup_List_t *drbSet)
9092 {
9093    DRBs_ToBeSetup_Item_t *drbSetItem = NULLP;
9094    uint8_t  flowIdx =0;
9095    uint8_t  drbIdx =0;
9096
9097    if(drbSet->list.array != NULLP)
9098    {
9099       for(drbIdx=0; drbIdx<drbSet->list.count; drbIdx++)
9100       {
9101          if(drbIdx==0&&drbSet->list.array[drbIdx] != NULLP)
9102          {
9103             drbSetItem =&drbSet->list.array[drbIdx]->value.choice.DRBs_ToBeSetup_Item;
9104             if(drbSetItem->qoSInformation.choice.choice_extension != NULLP)
9105             {
9106                if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
9107                      qoS_Characteristics.choice.non_Dynamic_5QI !=NULLP)
9108                {
9109                   if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
9110                         qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow!=NULLP)
9111                   {
9112                      if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
9113                            qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume!=NULLP)
9114                      {
9115
9116                         if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sST.buf!=NULLP)
9117                         {
9118
9119                            if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD!=NULLP)
9120                            {
9121
9122                               if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD->\
9123                                     buf!=NULLP)
9124                               {
9125
9126                                  if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.\
9127                                        flows_Mapped_To_DRB_List.list.array != NULLP)
9128                                  {
9129
9130                                     for(flowIdx=0;flowIdx<drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9131                                           DRB_Information.flows_Mapped_To_DRB_List.list.count; flowIdx++)
9132                                     {
9133
9134                                        if(flowIdx==0&&drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9135                                              DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]!=NULLP)
9136                                        {
9137                                           if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9138                                                 DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
9139                                                 qoSFlowLevelQoSParameters.\
9140                                                 qoS_Characteristics.choice.non_Dynamic_5QI!=NULLP)
9141                                           {
9142                                              if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9143                                                    DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
9144                                                    qoSFlowLevelQoSParameters.\
9145                                                    qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow!=NULLP)
9146                                              {
9147
9148                                                 if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9149                                                       DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
9150                                                       qoSFlowLevelQoSParameters.\
9151                                                       qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume!=NULLP)
9152                                                 {
9153
9154
9155                                                    free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9156                                                          DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
9157                                                          qoSFlowLevelQoSParameters.\
9158                                                          qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume);
9159                                                 }
9160
9161                                                 free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9162                                                       DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
9163                                                       qoSFlowLevelQoSParameters.\
9164                                                       qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow);
9165                                              }
9166
9167                                              free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9168
9169                                                    DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
9170                                                    qoSFlowLevelQoSParameters.\
9171                                                    qoS_Characteristics.choice.non_Dynamic_5QI);
9172                                           }
9173                                        }
9174                                        if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9175                                              DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]!=NULLP)
9176                                        {
9177
9178                                           free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9179                                                 DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]);
9180                                        }
9181                                     }
9182
9183                                     free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9184                                           DRB_Information.flows_Mapped_To_DRB_List.list.array);
9185                                  }
9186
9187                                  free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9188                                        DRB_Information.sNSSAI.sD->buf);
9189                               }
9190
9191                               free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD);
9192                            }
9193
9194                            free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sST.buf);
9195
9196                         }
9197
9198                         free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
9199
9200                               qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume);
9201                      }
9202
9203                      free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
9204                            qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow);
9205                   }
9206
9207                   free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
9208                         qoS_Characteristics.choice.non_Dynamic_5QI);
9209                }
9210                free(drbSetItem->qoSInformation.choice.choice_extension);
9211             }
9212             freeAperDecodeULTnlInfo(&drbSetItem->uLUPTNLInformation_ToBeSetup_List);
9213             if(drbSetItem->uLConfiguration)
9214             {
9215                free(drbSetItem->uLConfiguration);
9216             }
9217          }
9218          if(drbSet->list.array[drbIdx]!=NULLP)
9219          {
9220             free(drbSet->list.array[drbIdx]);
9221          }
9222       }
9223       free(drbSet->list.array);
9224    }
9225 }
9226
9227
9228 /*******************************************************************
9229  *
9230  * @brief builds Mac Cell Cfg
9231  *
9232  * @details
9233  *
9234  *    Function : procUeReCfgCellInfo
9235  *
9236  *    Functionality: builds Mac Cell Cfg
9237  *
9238  * @params[in] MacUeCfg pointer
9239  *             void pointer
9240  *
9241  * @return void
9242  *
9243  * ****************************************************************/
9244 uint8_t procUeReCfgCellInfo(MacUeCfg *macUeCfg, void *cellInfo)
9245 {
9246    uint8_t ret = ROK;
9247    CellGroupConfigRrc_t *cellGrp = NULLP;
9248
9249    if(cellInfo)
9250    {
9251       cellGrp = (CellGroupConfigRrc_t *)cellInfo;
9252       ret = extractUeReCfgCellInfo(cellGrp, macUeCfg);
9253       if(ret == RFAILED)
9254          DU_LOG("\nERROR  -->  F1AP : Failed at procUeReCfgCellInfo()");
9255    }
9256    if(ret == RFAILED)
9257    {
9258       freeUeReCfgCellGrpInfo(macUeCfg);
9259    }
9260    return ret;
9261 }
9262
9263 /*******************************************************************
9264  *
9265  * @brief Filling modulation info in mac ue cfg
9266  *
9267  * @details
9268  *
9269  *    Function : duFillModulationDetails
9270  *
9271  *    Functionality: Filling modulation info in mac ue cfg
9272  *
9273  * @params[in] MAC UE Config to be updated
9274  *             Current UE configuration
9275  *             UE NR capability from CU
9276  * @return ROK     - success
9277  *         RFAILED - failure
9278  *
9279  * ****************************************************************/
9280 void duFillModulationDetails(MacUeCfg *ueCfg, MacUeCfg *oldUeCfg, void *ueCap)
9281 {
9282    UE_NR_Capability_t *ueNrCap;
9283
9284    if(ueCap)
9285       ueNrCap = (UE_NR_Capability_t *)ueCap;
9286
9287    /* Filling DL modulation info */
9288    if(ueNrCap->featureSets && ueNrCap->featureSets->featureSetsDownlinkPerCC && \
9289          ueNrCap->featureSets->featureSetsDownlinkPerCC->list.array[0] && \
9290          ueNrCap->featureSets->featureSetsDownlinkPerCC->list.array[0]->supportedModulationOrderDL)
9291    {
9292       switch(*(ueNrCap->featureSets->featureSetsDownlinkPerCC->list.array[0]->supportedModulationOrderDL))
9293       {
9294          case ModulationOrder_qpsk:
9295             {
9296                ueCfg->dlModInfo.modOrder = MOD_ORDER_QPSK;
9297                break;
9298             }
9299          case ModulationOrder_qam16:
9300             {
9301                ueCfg->dlModInfo.modOrder = MOD_ORDER_QAM16;
9302                break;
9303             }
9304          case ModulationOrder_qam64:
9305             {
9306                ueCfg->dlModInfo.modOrder = MOD_ORDER_QAM64;
9307                ueCfg->dlModInfo.mcsIndex = PDSCH_MCS_INDEX;
9308                ueCfg->dlModInfo.mcsTable = MCS_TABLE_QAM64;
9309                break;
9310             }
9311          case ModulationOrder_qam256:
9312             {
9313                ueCfg->dlModInfo.modOrder = MOD_ORDER_QAM256;
9314                break;
9315             }
9316          default:
9317             {
9318                DU_LOG("\nERROR  -->  DU APP: Incorrect downlink modulation order received. Reatining old modulation configuration");
9319                memcpy(&ueCfg->dlModInfo, &oldUeCfg->dlModInfo, sizeof(ModulationInfo));
9320                break;
9321             }
9322       }
9323    }
9324    else
9325    {
9326       memcpy(&ueCfg->dlModInfo, &oldUeCfg->dlModInfo, sizeof(ModulationInfo));
9327    }
9328
9329    /* Filling UL modulation info */
9330    if(ueNrCap->featureSets && ueNrCap->featureSets->featureSetsUplinkPerCC && \
9331          ueNrCap->featureSets->featureSetsUplinkPerCC->list.array[0] && \
9332          ueNrCap->featureSets->featureSetsUplinkPerCC->list.array[0]->supportedModulationOrderUL)
9333    {
9334       switch(*(ueNrCap->featureSets->featureSetsUplinkPerCC->list.array[0]->supportedModulationOrderUL))
9335       {
9336          case ModulationOrder_qpsk:
9337             {
9338                ueCfg->ulModInfo.modOrder = MOD_ORDER_QPSK;
9339                break;
9340             }
9341          case ModulationOrder_qam16:
9342             {
9343                ueCfg->ulModInfo.modOrder = MOD_ORDER_QAM16;
9344                ueCfg->ulModInfo.mcsIndex = PUSCH_MCS_INDEX;
9345                ueCfg->ulModInfo.mcsTable = MCS_TABLE_QAM64;
9346                break;
9347             }
9348          case ModulationOrder_qam64:
9349             {
9350                ueCfg->ulModInfo.modOrder = MOD_ORDER_QAM64;
9351                break;
9352             }
9353          case ModulationOrder_qam256:
9354             {
9355                ueCfg->ulModInfo.modOrder = MOD_ORDER_QAM256;
9356                break;
9357             }
9358          default:
9359             {
9360                DU_LOG("\nERROR  -->  DU APP: Incorrect uplink modulation order received. Reatining old modulation configuration");
9361                memcpy(&ueCfg->ulModInfo, &oldUeCfg->ulModInfo, sizeof(ModulationInfo));
9362                break;
9363             }
9364       }
9365    }
9366    else
9367    {
9368       memcpy(&ueCfg->ulModInfo, &oldUeCfg->ulModInfo, sizeof(ModulationInfo));
9369    }
9370 }
9371
9372 /*******************************************************************
9373  *
9374  * @brief Function to extract cellGrp Info present in cutoDu cont
9375  *
9376  * @details
9377  *
9378  *    Function : extractCellGrpInfo
9379  *
9380  *    Functionality: Function to extract cellGrp Info present
9381  *                   in cutoDu cont
9382  *
9383  * @params[in] ProtocolExtensionContainer_4624P16_t pointer
9384  *
9385  * @return CellGroupConfigRrc_t *
9386  *
9387  * ****************************************************************/
9388
9389 CellGroupConfigRrc_t *extractCellGrpInfo(ProtocolExtensionContainer_4624P16_t *protocolIeExtn,\
9390       DuUeCfg *ueCfgDb)
9391 {
9392    uint8_t idx2 =0;
9393    uint16_t id =0;
9394    uint16_t recvBufLen =0;
9395    CellGroupConfigRrc_t *cellGrpCfg = NULLP;
9396    CUtoDURRCInformation_ExtIEs_t *extIeInfo = NULLP;
9397    asn_dec_rval_t rval; /* Decoder return value */
9398    memset(&rval, 0, sizeof(asn_dec_rval_t));
9399
9400    if(protocolIeExtn)
9401    {
9402       for(idx2 = 0; idx2 < protocolIeExtn->list.count; idx2++)
9403       {
9404          extIeInfo = ((CUtoDURRCInformation_ExtIEs_t *)(protocolIeExtn->list.array[idx2]));
9405          id = extIeInfo->id;
9406          switch(id)
9407          {
9408             case ProtocolIE_ID_id_CellGroupConfig:
9409             {
9410                recvBufLen = extIeInfo->extensionValue.choice.CellGroupConfig.size;
9411                /* decoding the CellGroup Buf received */
9412                DU_ALLOC(cellGrpCfg, sizeof(CellGroupConfigRrc_t));
9413                if(cellGrpCfg)
9414                {
9415                   memset(cellGrpCfg, 0, sizeof(CellGroupConfigRrc_t));
9416                   rval = aper_decode(0, &asn_DEF_CellGroupConfigRrc, (void **)&cellGrpCfg,
9417                      extIeInfo->extensionValue.choice.CellGroupConfig.buf, recvBufLen, 0, 0);
9418                   if(rval.code == RC_FAIL || rval.code == RC_WMORE)
9419                   {
9420                      DU_LOG("\nERROR  -->  F1AP : ASN decode failed at decodeCellGrpCfg()");
9421                      return NULLP;
9422                   }
9423                   xer_fprint(stdout, &asn_DEF_CellGroupConfigRrc, cellGrpCfg);
9424                   if(extractRlcCfgToAddMod(cellGrpCfg->rlc_BearerToAddModList, ueCfgDb))
9425                      return NULLP;
9426                }
9427                break;
9428             }
9429             default:
9430                DU_LOG("\nERROR  -->  F1AP : Invalid IE received CUtoDURRCInformation:%d at decodeCellGrpCfg()", id);
9431                break;
9432          }
9433       }
9434    }
9435    return cellGrpCfg;
9436 }
9437
9438 /*******************************************************************
9439  *
9440  * @brief Fills Srb List received by CU
9441  *
9442  * @details
9443  *
9444  *    Function : procSrbListToSetup
9445  *
9446  *    Functionality: Fills Srb List received  by CU
9447  *
9448  * @params[in] SRBs_ToBeSetup_Item_t *cuSrbItem
9449  *             LcCfg pointer
9450  *             RlcBearerCfg pointer
9451  * @return void
9452  *
9453  * ****************************************************************/
9454 uint8_t procSrbListToSetup(SRBs_ToBeSetup_Item_t * srbItem, LcCfg *macLcToAdd, RlcBearerCfg *rlcLcToAdd)
9455 {
9456    uint8_t ret = ROK;
9457
9458    /* Filling RLC INFO */
9459    procRlcLcCfg(srbItem->sRBID, srbItem->sRBID, RB_TYPE_SRB, RLC_AM, CONFIG_ADD, NULL, rlcLcToAdd);
9460
9461    /* Filling MAC INFO */
9462    ret = procMacLcCfg(srbItem->sRBID, RB_TYPE_SRB, CONFIG_ADD, NULL,NULL, NULL, macLcToAdd, NULL);
9463    if(ret == RFAILED)
9464    {
9465       DU_LOG("\nERROR  -->  F1AP : Failed at MAC LC Cfg in procSrbListToSetup()");
9466       return ret;
9467    }
9468    return ret;
9469 }
9470
9471
9472
9473 /*******************************************************************
9474  *
9475  * @brief extract Srb List received by CU
9476  *
9477  * @details
9478  *
9479  *    Function : extractSrbListToSetup
9480  *
9481  *    Functionality: extract Srb List received by CU
9482  *                   for both MAC and RLC
9483  *
9484  * @params[in] SRBs_ToBeSetup_Item_t pointer
9485  *             DuUeCfg pointer
9486  * @return ROK/RFAIED
9487  *
9488  * ****************************************************************/
9489
9490 uint8_t extractSrbListToSetup(SRBs_ToBeSetup_List_t *srbCfg, DuUeCfg *ueCfgDb)
9491 {
9492    uint8_t ret, srbIdx;
9493    SRBs_ToBeSetup_Item_t *srbItem = NULLP;
9494
9495    if(srbCfg)
9496    {
9497       for(srbIdx = 0; srbIdx < srbCfg->list.count; srbIdx++)
9498       {
9499          srbItem = &srbCfg->list.array[srbIdx]->value.choice.SRBs_ToBeSetup_Item;
9500          if(ueCfgDb->numMacLcs > MAX_NUM_LC)
9501          {
9502             DU_LOG("\nERROR   -->  F1AP:  MAX LC Reached in MAC");
9503             ret = RFAILED;
9504             break;
9505          }
9506          if(ueCfgDb->numRlcLcs > MAX_NUM_LC)
9507          {
9508             DU_LOG("\nERROR   -->  F1AP:  MAX LC Reached in RLC");
9509             ret = RFAILED;
9510             break;
9511          }
9512          memset(&ueCfgDb->macLcCfg[ueCfgDb->numMacLcs], 0, sizeof(LcCfg));
9513          memset(&ueCfgDb->rlcLcCfg[ueCfgDb->numRlcLcs], 0, sizeof(RlcBearerCfg));
9514          ret = procSrbListToSetup(srbItem, &ueCfgDb->macLcCfg[ueCfgDb->numMacLcs],\
9515             &ueCfgDb->rlcLcCfg[ueCfgDb->numRlcLcs]);
9516          ueCfgDb->numRlcLcs++;
9517          ueCfgDb->numMacLcs++;
9518          if(ret == RFAILED)
9519          {
9520             DU_LOG("\nERROR  -->  F1AP:  Failed at extractSrbListToSetup()");
9521             break;
9522          }
9523       }
9524    }
9525    else
9526       ret = RFAILED;
9527
9528    return ret;
9529 }
9530
9531 /*******************************************************************
9532  *
9533  * @brief Fills Drb List received by CU
9534  *
9535  * @details
9536  *
9537  *    Function : procDrbListToSetup
9538  *
9539  *    Functionality: Fills Drb List received by CU
9540  *                   for both MAC and RLC
9541  *
9542  * @params[in] SRBs_ToBeSetup_Item_t pointer
9543  *             LcCfg pointer,
9544  *             RlcBearerCfg pointer
9545  * @return void
9546  *
9547  * ****************************************************************/
9548
9549 uint8_t procDrbListToSetup(uint8_t lcId, DRBs_ToBeSetup_Item_t *drbItem,\
9550 DRBs_ToBeSetupMod_Item_t *drbSetupModItem, LcCfg *macLcToAdd, RlcBearerCfg *rlcLcToAdd, UpTnlCfg *upTnlInfo)
9551 {
9552
9553    if(drbItem != NULLP)
9554    {
9555       /* Filling RLC INFO */
9556       procRlcLcCfg(drbItem->dRBID, lcId, RB_TYPE_DRB, drbItem->rLCMode, CONFIG_ADD, NULL, rlcLcToAdd);
9557
9558       /* Filling MAC INFO */
9559       if(procMacLcCfg(lcId, RB_TYPE_DRB, CONFIG_ADD, drbItem, NULL, NULL, macLcToAdd, upTnlInfo) != ROK)
9560       {
9561          DU_LOG("\nERROR  --> F1AP : Failed at RLC LC Cfg in procDrbListToSetup()");
9562          return RFAILED;
9563       }
9564    }
9565    else if(drbSetupModItem != NULLP)
9566    {
9567       procRlcLcCfg(drbSetupModItem->dRBID, lcId, RB_TYPE_DRB, drbSetupModItem->rLCMode, CONFIG_ADD, NULL, rlcLcToAdd);
9568
9569       if(procMacLcCfg(lcId, RB_TYPE_DRB, CONFIG_ADD, NULL, drbSetupModItem, NULL, macLcToAdd, upTnlInfo) != ROK)
9570       {
9571          DU_LOG("\nERROR  --> F1AP : Failed at RLC LC Cfg in procDrbListToSetup()");
9572          return RFAILED;
9573       }
9574    }
9575    return ROK;
9576 }
9577
9578 /*******************************************************************
9579  *
9580  * @brief extract Drb List received by CU
9581  *
9582  * @details
9583  *
9584  *    Function : extractDrbListToSetup
9585  *
9586  *    Functionality: extract Drb List received by CU
9587  *                   for both MAC and RLC
9588  *
9589  * @params[in] DRBs_ToBeSetup_Item_t pointer
9590  *             DuUeCfg pointer
9591  * @return ROK/RFAIED
9592  *
9593  * ****************************************************************/
9594
9595 uint8_t extractDrbListToSetup(uint8_t lcId, DRBs_ToBeSetup_List_t *drbCfg,DRBs_ToBeSetupMod_List_t *drbSetupModCfg,\
9596 uint8_t drbCount, DuUeCfg *ueCfgDb)
9597 {
9598    uint8_t ret, drbIdx;
9599    DRBs_ToBeSetup_Item_t *drbItem = NULLP;
9600    DRBs_ToBeSetupMod_ItemIEs_t *drbSetupModItem = NULLP;
9601
9602    ret = ROK;
9603    if(drbCount > 0)
9604    {
9605       for(drbIdx = 0; drbIdx < drbCount; drbIdx++)
9606       {
9607          if(ueCfgDb->numMacLcs > MAX_NUM_LC)
9608          {
9609             DU_LOG("\nERROR  -->  F1AP :  MAX LC Reached in MAC at extractDrbListToSetup()");
9610             ret = RFAILED;
9611             break;
9612          }
9613          if(ueCfgDb->numRlcLcs > MAX_NUM_LC)
9614          {
9615             DU_LOG("\nERROR  -->  F1AP :  MAX LC Reached in RLC at extractDrbListToSetup()");
9616             ret = RFAILED;
9617             break;
9618          }
9619          memset(&ueCfgDb->macLcCfg[ueCfgDb->numMacLcs], 0, sizeof(LcCfg));
9620          memset(&ueCfgDb->rlcLcCfg[ueCfgDb->numRlcLcs], 0, sizeof(RlcBearerCfg));
9621
9622          if(drbCfg != NULL)
9623          {
9624             drbItem = &drbCfg->list.array[drbIdx]->value.choice.DRBs_ToBeSetup_Item;
9625             ret = procDrbListToSetup(lcId, drbItem, NULL, &ueCfgDb->macLcCfg[ueCfgDb->numMacLcs],\
9626                &ueCfgDb->rlcLcCfg[ueCfgDb->numRlcLcs], &ueCfgDb->upTnlInfo[ueCfgDb->numDrb]);
9627             if(ret == RFAILED)
9628             {
9629                DU_LOG("\nERROR  --> F1AP : Failed at extractDrbListToSetup()");
9630                break;
9631             }
9632          }
9633          else if(drbSetupModCfg != NULL)
9634          {
9635             drbSetupModItem = (DRBs_ToBeSetupMod_ItemIEs_t *) drbSetupModCfg->list.array[drbIdx];
9636             ret = procDrbListToSetup(lcId, NULL, &(drbSetupModItem->value.choice.DRBs_ToBeSetupMod_Item) ,\
9637             &ueCfgDb->macLcCfg[ueCfgDb->numMacLcs], &ueCfgDb->rlcLcCfg[ueCfgDb->numRlcLcs],\
9638             &ueCfgDb->upTnlInfo[ueCfgDb->numDrb]);
9639             if(ret == RFAILED)
9640             {
9641                DU_LOG("\nERROR  --> F1AP : Failed at extractDrbListToSetup()");
9642                break;
9643             }
9644          }
9645          ueCfgDb->numRlcLcs++;
9646          ueCfgDb->numMacLcs++;
9647          ueCfgDb->numDrb++;
9648          if(ret == RFAILED)
9649          {
9650             DU_LOG("\nERROR  --> F1AP : Failed at extractDrbListToSetup()");
9651             break;
9652          }
9653       }
9654    }
9655    else
9656       ret = RFAILED;
9657
9658    return ret;
9659 }
9660
9661 /*******************************************************************
9662  *
9663  * @brief Function to extract Dl RRC Msg received from CU
9664  *
9665  * @details
9666  *
9667  *    Function : extractDlRrcMsg
9668  *
9669  *    Functionality: Function to extract Dl RRC Msg received from CU
9670  *
9671  * @params[in] F1AP message
9672  * @return ROK     - success
9673  *         RFAILED - failure
9674  *
9675  * ****************************************************************/
9676
9677 uint8_t extractDlRrcMsg(uint32_t gnbDuUeF1apId, uint32_t gnbCuUeF1apId, \
9678    F1DlRrcMsg *dlRrcMsg, RRCContainer_t *rrcContainer)
9679 {
9680    uint8_t ret = ROK;
9681    dlRrcMsg->rrcMsgSize = rrcContainer->size;
9682    if(dlRrcMsg->rrcMsgSize > 0)
9683    {
9684       DU_ALLOC_SHRABL_BUF(dlRrcMsg->rrcMsgPdu, dlRrcMsg->rrcMsgSize);
9685       if(!dlRrcMsg->rrcMsgPdu)
9686       {
9687          DU_LOG("\nERROR  --> DU APP : Memory allocation failed for RRC Msg in extractDlRrcMsg()");
9688          ret = RFAILED;
9689       }
9690       else
9691       {
9692          dlRrcMsg->gnbDuUeF1apId = gnbDuUeF1apId;
9693          dlRrcMsg->gnbCuUeF1apId = gnbCuUeF1apId;
9694          dlRrcMsg->srbId = SRB1_LCID;
9695          memcpy(dlRrcMsg->rrcMsgPdu, rrcContainer->buf, dlRrcMsg->rrcMsgSize);
9696       }
9697    }
9698    return ret;
9699 }
9700
9701 /*******************************************************************
9702  *
9703  * @brief Extract UE capability info
9704  *
9705  * @details
9706  *
9707  *    Function : extractUeCapability
9708  *
9709  *    Functionality: Extract UE capability info and stores in ue Cb
9710  *
9711  * @params[in] Octet string of UE capability RAT container list
9712  * @return ROK     - success
9713  *         RFAILED - failure
9714  *
9715  * ****************************************************************/
9716 UE_NR_Capability_t *extractUeCapability(UE_CapabilityRAT_ContainerList_t *ueCapablityListBuf, DuUeCb *ueCb)
9717 {
9718    uint8_t  idx;
9719    uint16_t recvBufLen;
9720    asn_dec_rval_t rval;
9721    UE_NR_Capability_t  *ueNrCap = NULLP;
9722    UE_CapabilityRAT_ContainerListRRC_t  *ueCapRatContList = NULLP;
9723
9724    /* Decoding UE Capability RAT Container List */
9725    recvBufLen = ueCapablityListBuf->size;
9726    DU_ALLOC(ueCapRatContList, sizeof(UE_CapabilityRAT_ContainerListRRC_t));
9727    if(!ueCapRatContList)
9728    {
9729       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in extractUeCapability");
9730       return NULLP;
9731    }
9732    memset(ueCapRatContList, 0, sizeof(UE_CapabilityRAT_ContainerListRRC_t));
9733    memset(&rval, 0, sizeof(asn_dec_rval_t));
9734    rval = aper_decode(0, &asn_DEF_UE_CapabilityRAT_ContainerListRRC, (void **)&ueCapRatContList,
9735           ueCapablityListBuf->buf, recvBufLen, 0, 0);
9736    if(rval.code == RC_FAIL || rval.code == RC_WMORE)
9737    {
9738       DU_LOG("\nERROR  -->  F1AP : ASN decode failed at decodeCellGrpCfg()");
9739       return NULLP;
9740    }
9741    xer_fprint(stdout, &asn_DEF_UE_CapabilityRAT_ContainerListRRC, ueCapRatContList);
9742
9743    /* Free encoded buffer after decoding */
9744
9745    for(idx = 0; idx < ueCapRatContList->list.count; idx++)
9746    {
9747       if(ueCapRatContList->list.array[idx]->rat_Type == RAT_Type_nr)
9748       {
9749          /* Decoding UE NR Capability */
9750           recvBufLen = ueCapRatContList->list.array[idx]->ue_CapabilityRAT_Container.size;
9751           DU_ALLOC(ueNrCap, sizeof(UE_NR_Capability_t));
9752           if(!ueNrCap)
9753           {
9754              DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in extractUeCapability");
9755              DU_FREE(ueCapRatContList, sizeof(UE_CapabilityRAT_ContainerListRRC_t));
9756              return NULLP;
9757           }
9758           memset(ueNrCap, 0, sizeof(UE_NR_Capability_t));
9759           memset(&rval, 0, sizeof(asn_dec_rval_t));
9760           rval = aper_decode(0, &asn_DEF_UE_NR_Capability, (void **)&ueNrCap,
9761                  ueCapRatContList->list.array[idx]->ue_CapabilityRAT_Container.buf, recvBufLen, 0, 0);
9762           if(rval.code == RC_FAIL || rval.code == RC_WMORE)
9763           {
9764              DU_LOG("\nERROR  -->  F1AP : ASN decode failed at decodeCellGrpCfg()");
9765              return NULLP;
9766           }
9767           xer_fprint(stdout, &asn_DEF_UE_NR_Capability, ueNrCap);
9768
9769           /* Free encoded buffer after decoding */
9770           free(ueCapRatContList->list.array[idx]->ue_CapabilityRAT_Container.buf);
9771       }
9772       free(ueCapRatContList->list.array[idx]);
9773    }
9774
9775    /* Free Memory*/
9776    free(ueCapRatContList->list.array);
9777    DU_FREE(ueCapRatContList, sizeof(UE_CapabilityRAT_ContainerListRRC_t));
9778    return ueNrCap;
9779 }
9780
9781 /*******************************************************************
9782 *
9783 * @brief free UE context setup request from CU
9784 *
9785 * @details
9786 *
9787 *    Function : freeAperDecodeF1UeContextSetupReq
9788 *
9789 *    Functionality: freeing part for the memory allocated by aper_decoder
9790 *
9791 * @params[in] F1AP message
9792 * @return ROK     - success
9793 *         RFAILED - failure
9794 *
9795 * ****************************************************************/
9796 void freeAperDecodeF1UeContextSetupReq(UEContextSetupRequest_t   *ueSetReq)
9797 {
9798    uint8_t ieIdx = 0;
9799
9800    if(ueSetReq->protocolIEs.list.array != NULLP)
9801    {
9802       for(ieIdx = 0; ieIdx < ueSetReq->protocolIEs.list.count; ieIdx++)
9803       {
9804          if(ueSetReq->protocolIEs.list.array[ieIdx])
9805          {
9806             switch(ueSetReq->protocolIEs.list.array[ieIdx]->id)
9807             {
9808                case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
9809                   break;
9810                case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
9811                   break;
9812                case ProtocolIE_ID_id_SpCell_ID:
9813                   freeAperDecodeNrcgi(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.NRCGI);
9814                   break;
9815                case ProtocolIE_ID_id_ServCellIndex:
9816                   break;
9817                case ProtocolIE_ID_id_SpCellULConfigured:
9818                   break;
9819                case ProtocolIE_ID_id_CUtoDURRCInformation:
9820
9821                   freeAperDecodeCuToDuInfo(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.CUtoDURRCInformation);
9822                   break;
9823                case ProtocolIE_ID_id_SCell_ToBeSetup_List:
9824
9825                   freeAperDecodeSplCellList(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.SCell_ToBeSetup_List);
9826                   break;
9827                case ProtocolIE_ID_id_SRBs_ToBeSetup_List:
9828
9829                   freeAperDecodeSRBSetup(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.SRBs_ToBeSetup_List);
9830                   break;
9831                case ProtocolIE_ID_id_DRBs_ToBeSetup_List:
9832
9833                   freeAperDecodeDRBSetup(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.DRBs_ToBeSetup_List);
9834                   break;
9835                case ProtocolIE_ID_id_RRCContainer:
9836                   {
9837
9838                      if(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf != NULLP)
9839                      {
9840
9841                         free(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf);
9842                      }
9843                      break;
9844                   }
9845                case ProtocolIE_ID_id_RRCDeliveryStatusRequest:
9846                   break;
9847                case ProtocolIE_ID_id_GNB_DU_UE_AMBR_UL:
9848                   {
9849                      if(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.BitRate.buf)
9850                      {
9851                         free(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.BitRate.buf);
9852                      }
9853                      break;
9854                   }
9855                default:
9856                   DU_LOG("\nERROR  -->  F1AP: Invalid event type %ld " ,ueSetReq->protocolIEs.list.array[ieIdx]->id);
9857             }
9858             free(ueSetReq->protocolIEs.list.array[ieIdx]);
9859          }
9860       }
9861       free(ueSetReq->protocolIEs.list.array);
9862    }
9863 }
9864 /*******************************************************************
9865  *
9866  * @brief Process UE context setup request from CU
9867  *
9868  * @details
9869  *
9870  *    Function : procF1UeContextSetupReq
9871  *
9872  *    Functionality: Process UE context setup request from CU
9873  *
9874  * @params[in] F1AP message
9875  * @return ROK     - success
9876  *         RFAILED - failure
9877  *
9878  * ****************************************************************/
9879 uint8_t procF1UeContextSetupReq(F1AP_PDU_t *f1apMsg)
9880 {
9881    uint8_t  ret=0, ieIdx=0, ueIdx=0, lcId=0, cellIdx=0;
9882    bool ueCbFound = false;
9883    uint32_t gnbCuUeF1apId=0, gnbDuUeF1apId=0, bitRateSize=0;
9884    DuUeCb   *duUeCb = NULL;
9885    UEContextSetupRequest_t   *ueSetReq = NULL;
9886    DRBs_ToBeSetup_List_t *drbCfg = NULL;
9887
9888    ret = ROK;
9889
9890    ueSetReq = &f1apMsg->choice.initiatingMessage->value.choice.UEContextSetupRequest;
9891    for(ieIdx=0; (ieIdx < ueSetReq->protocolIEs.list.count && ret == ROK); ieIdx++)
9892    {
9893       switch(ueSetReq->protocolIEs.list.array[ieIdx]->id)
9894       {
9895          case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
9896             {
9897                gnbCuUeF1apId = ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID;
9898                break;
9899             }
9900          case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
9901             {
9902                gnbDuUeF1apId = ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID;
9903                break;
9904             }
9905          case ProtocolIE_ID_id_ServCellIndex:
9906             {
9907                cellIdx = ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.ServCellIndex;
9908                for(ueIdx = 0; ueIdx < MAX_NUM_UE; ueIdx++)
9909                {
9910                   if((duCb.actvCellLst[cellIdx]->ueCb[ueIdx].gnbDuUeF1apId == gnbDuUeF1apId)&&\
9911                         (duCb.actvCellLst[cellIdx]->ueCb[ueIdx].gnbCuUeF1apId == gnbCuUeF1apId))
9912                   {
9913                      ueCbFound = true;
9914                      duUeCb = &duCb.actvCellLst[cellIdx]->ueCb[ueIdx];
9915                      DU_ALLOC(duUeCb->f1UeDb, sizeof(F1UeContextSetupDb));
9916                      if(duUeCb->f1UeDb)
9917                      {
9918                         memset(duUeCb->f1UeDb, 0, sizeof(F1UeContextSetupDb));
9919                         duUeCb->f1UeDb->actionType = UE_CTXT_SETUP;
9920                         duUeCb->f1UeDb->cellIdx = cellIdx;
9921                      }
9922                      else
9923                      {
9924                         DU_LOG("\nERROR  -->  F1AP: Memory Alloc Failed at procF1UeContextSetupReq()");
9925                         ret = RFAILED;
9926                      }
9927                   }
9928                   else
9929                      ueCbFound = false;
9930
9931                }
9932                if(!ueCbFound)
9933                {
9934                   DU_LOG("\nERROR  -->  F1AP: DuUeCb is not found at procF1UeContextSetupReq()");
9935                   ret = RFAILED;
9936                }
9937                break;
9938             }
9939          case ProtocolIE_ID_id_SpCellULConfigured:
9940             /* Indicates whether the gNB-CU requests the gNB-DU to configure the uplink as no UL,
9941                UL, SUL or UL+SUL for the indicated cell for the UE */
9942             break;
9943          case ProtocolIE_ID_id_CUtoDURRCInformation:
9944             {
9945                if(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.CUtoDURRCInformation.uE_CapabilityRAT_ContainerList)
9946                {
9947                   duUeCb->f1UeDb->duUeCfg.ueNrCapability = \
9948                   extractUeCapability(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.CUtoDURRCInformation.\
9949                   uE_CapabilityRAT_ContainerList, duUeCb);
9950                }
9951                if(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.CUtoDURRCInformation.iE_Extensions)
9952                {
9953                   duUeCb->f1UeDb->duUeCfg.cellGrpCfg = extractCellGrpInfo(ueSetReq->protocolIEs.list.array[ieIdx]->\
9954                         value.choice.CUtoDURRCInformation.iE_Extensions, &duUeCb->f1UeDb->duUeCfg);
9955                   if(!duUeCb->f1UeDb->duUeCfg.cellGrpCfg)
9956                   {
9957                      DU_LOG("\nERROR  -->  F1AP: Failed to extract cell Grp Info");
9958                      //TODO: Update the failure cause in ue context Setup Response
9959                      ret = RFAILED;
9960                   }
9961                }
9962                break;
9963             }
9964          case ProtocolIE_ID_id_SCell_ToBeSetup_List:
9965             {
9966                DU_LOG("\nINFO   -->  DU_APP: Received SCell_ToBeSetup_List but  Not processing the list");
9967                break;
9968             }
9969          case ProtocolIE_ID_id_SRBs_ToBeSetup_List:
9970             {
9971                if(extractSrbListToSetup(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.SRBs_ToBeSetup_List,\
9972                &duUeCb->f1UeDb->duUeCfg))
9973                {
9974                   DU_LOG("\nERROR  -->  DU APP : Failed at extractSrbListToSetup()");
9975                   //TODO: Update the failure cause in ue context Setup Response
9976                   ret = RFAILED;
9977                }
9978                break;
9979             }
9980          case ProtocolIE_ID_id_DRBs_ToBeSetup_List:
9981             {
9982                lcId = getDrbLcId(&duUeCb->drbBitMap);
9983                if(lcId != RFAILED)
9984                {
9985                   drbCfg = &ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.DRBs_ToBeSetup_List;
9986                   if(extractDrbListToSetup(lcId, drbCfg, NULL, drbCfg->list.count, &duUeCb->f1UeDb->duUeCfg))
9987                   {
9988                      DU_LOG("\nERROR  -->  DU APP : Failed at extractDrbListToSetup()");
9989                      //TODO: Update the failure cause in ue context Setup Response
9990                      ret = RFAILED;
9991                   }
9992                }
9993                else
9994                   ret = RFAILED;
9995                break;
9996             }
9997          case ProtocolIE_ID_id_RRCContainer:
9998             {
9999                /* Filling Dl RRC Msg Info */
10000                DU_ALLOC_SHRABL_BUF(duUeCb->f1UeDb->dlRrcMsg, sizeof(F1DlRrcMsg));
10001                if(!duUeCb->f1UeDb->dlRrcMsg)
10002                {
10003                   DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for DL RRC Msg in procUeCtxtSetupReq()");
10004                   ret = RFAILED;
10005                }
10006                else
10007                {
10008                   memset(duUeCb->f1UeDb->dlRrcMsg, 0, sizeof(F1DlRrcMsg));
10009                   ret = extractDlRrcMsg(gnbDuUeF1apId, gnbCuUeF1apId, duUeCb->f1UeDb->dlRrcMsg,\
10010                         &ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer);
10011                }
10012                break;
10013             }
10014          case ProtocolIE_ID_id_RRCDeliveryStatusRequest:
10015             {
10016                if(duUeCb->f1UeDb->dlRrcMsg->rrcMsgPdu)
10017                {
10018                   duUeCb->f1UeDb->dlRrcMsg->deliveryStatRpt = true;
10019                }
10020                else
10021                {
10022                   DU_LOG("\nERROR  -->  Ignoring delivery report, since rrcContainer is not present");
10023                }
10024                break;
10025             }
10026          case ProtocolIE_ID_id_GNB_DU_UE_AMBR_UL:
10027             {
10028                /* MaximumBitRate Uplink */
10029                bitRateSize = ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.BitRate.size;
10030                if(bitRateSize > 0)
10031                {
10032                   DU_ALLOC_SHRABL_BUF(duUeCb->f1UeDb->duUeCfg.ambrCfg, bitRateSize);
10033                   if(!duUeCb->f1UeDb->duUeCfg.ambrCfg)
10034                   {
10035                      DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for bitRate in procUeCtxtSetupReq");
10036                      ret = RFAILED;
10037                   }
10038                   else
10039                   {
10040                      memset(duUeCb->f1UeDb->duUeCfg.ambrCfg, 0, sizeof(AmbrCfg));
10041                      memcpy(&duUeCb->f1UeDb->duUeCfg.ambrCfg->ulBr,
10042                            ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.BitRate.buf, bitRateSize);
10043                   }
10044                }
10045                else
10046                   ret = RFAILED;
10047                break;
10048             }
10049          default:
10050             {
10051                break;
10052             }
10053       }
10054    }
10055    if(ret == RFAILED)
10056    {
10057       /*TODO : Negative case*/
10058       // BuildAndSendUeContextSetupRsp(ueIdx, cellId);
10059       DU_LOG("\nERROR  -->  F1AP: Failed to process UE CNTXT SETUP REQ at procF1UeContextSetupReq()");
10060    }
10061    else
10062       ret = duProcUeContextSetupRequest(duUeCb);
10063
10064    freeAperDecodeF1UeContextSetupReq(ueSetReq);
10065    return ret;
10066
10067 }
10068 /*******************************************************************
10069  * @brief Free the memory allocated for Dl Tunnel Info
10070  *
10071  * @details
10072  *
10073  *    Function : freeDlTnlInfo
10074  *
10075  *    Functionality:
10076  *       Free the memory allocated for Dl Tunnel Info
10077  *
10078  * @params[in] DLUPTNLInformation_ToBeSetup_List_t *
10079  * @return void
10080  *
10081  * ****************************************************************/
10082
10083 void freeDlTnlInfo(DLUPTNLInformation_ToBeSetup_List_t *tnlInfo)
10084 {
10085    uint8_t arrIdx = 0;
10086
10087    for(arrIdx=0; arrIdx < tnlInfo->list.count; arrIdx++)
10088    {
10089       DU_FREE(tnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel, sizeof(GTPTunnel_t));
10090    }
10091 }
10092
10093 /*******************************************************************
10094  * @brief Free the memory allocated for DRB setup List
10095  *
10096  * @details
10097  *
10098  *    Function : freeDrbSetupList
10099  *
10100  *    Functionality:
10101  *       Free the memory allocated for DRB setup list
10102  *
10103  * @params[in] DRBs_Setup_List_t *
10104  * @return void
10105  *
10106  * ****************************************************************/
10107 void freeDrbSetupList(DRBs_Setup_List_t *drbSetupList)
10108 {
10109    uint8_t arrIdx = 0;
10110    DRBs_Setup_ItemIEs_t *drbItemIe = NULLP;
10111
10112    for(arrIdx = 0; arrIdx < drbSetupList->list.count; arrIdx++)
10113    {
10114       drbItemIe = ((DRBs_Setup_ItemIEs_t *)drbSetupList->list.array[arrIdx]);
10115       freeDlTnlInfo(&drbItemIe->value.choice.DRBs_Setup_Item.dLUPTNLInformation_ToBeSetup_List);
10116    }
10117 }
10118
10119 /*******************************************************************
10120  * @brief Free the memory allocated for UE Setup response
10121  *
10122  * @details
10123  *
10124  *    Function : FreeUeContextSetupRsp
10125  *
10126  *    Functionality:
10127  *       Free the memory allocated for UE Setup response
10128  *
10129  * @params[in] F1AP PDU for UE setup response
10130  * @return ROK     - success
10131  *         RFAILED - failure
10132  *
10133  * ****************************************************************/
10134 void FreeUeContextSetupRsp(F1AP_PDU_t *f1apMsg)
10135 {
10136    uint8_t idx;
10137    UEContextSetupResponse_t *ueSetRsp = NULLP;
10138
10139    if(f1apMsg)
10140    {
10141       if(f1apMsg->choice.successfulOutcome)
10142       {
10143          ueSetRsp = &f1apMsg->choice.successfulOutcome->value.choice.\
10144                     UEContextSetupResponse;
10145          if(ueSetRsp->protocolIEs.list.array)
10146          {
10147             for(idx = 0; idx < ueSetRsp->protocolIEs.list.count; idx++)
10148             {
10149                if(ueSetRsp->protocolIEs.list.array[idx])
10150                {
10151                   switch(ueSetRsp->protocolIEs.list.array[idx]->id)
10152                   {
10153                      case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
10154                         break;
10155                      case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
10156                         break;
10157                      case ProtocolIE_ID_id_DUtoCURRCInformation:
10158                         {
10159                            CellGroupConfig_t *cellGrpCfg = NULLP;
10160                            cellGrpCfg  = &ueSetRsp->protocolIEs.list.array[idx]->value.choice.\
10161                                          DUtoCURRCInformation.cellGroupConfig;
10162                            if(cellGrpCfg->buf != NULLP)
10163                            {
10164                               DU_FREE(cellGrpCfg->buf, cellGrpCfg->size);
10165                               cellGrpCfg = NULLP;
10166                            }
10167                            break;
10168                         }
10169                     case ProtocolIE_ID_id_DRBs_Setup_List:
10170                         {
10171                            freeDrbSetupList(&ueSetRsp->protocolIEs.list.array[idx]->value.choice.DRBs_Setup_List);
10172                            break;
10173                         }
10174                      default:
10175                         DU_LOG("\nERROR  -->  DUAPP: Invalid Id %ld at FreeUeContextSetupRsp()",\
10176                         ueSetRsp->protocolIEs.list.array[idx]->id);
10177                         break;
10178                   }
10179                   DU_FREE(ueSetRsp->protocolIEs.list.array[idx],\
10180                         sizeof(UEContextSetupResponseIEs_t));
10181                }
10182             }
10183             DU_FREE(ueSetRsp->protocolIEs.list.array, \
10184                   ueSetRsp->protocolIEs.list.size);
10185          }
10186          DU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
10187       }
10188       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
10189    }
10190 }
10191
10192 /*******************************************************************
10193  *
10194  * @brief Builds Ue context Setup Rsp DU To CU Info
10195  *
10196  * @details
10197  *
10198  *    Function : EncodeUeCntxtDuToCuInfo
10199  *
10200  *    Functionality: Builds Ue context Setup Rsp DU To CU Info
10201  *
10202  * @params[in] CellGroupConfig_t *, CellGroupConfigRrc_t *
10203  *
10204  * @return ROK     - success
10205  *         RFAILED - failure
10206  *
10207  ******************************************************************/
10208
10209 uint8_t EncodeUeCntxtDuToCuInfo(CellGroupConfig_t *duToCuCellGrp, CellGroupConfigRrc_t *duCellGrpCfg)
10210 {
10211    asn_enc_rval_t        encRetVal;
10212
10213    xer_fprint(stdout, &asn_DEF_CellGroupConfigRrc, duCellGrpCfg);
10214    memset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
10215    encBufSize = 0;
10216    encRetVal = aper_encode(&asn_DEF_CellGroupConfigRrc, 0, duCellGrpCfg, PrepFinalEncBuf, encBuf);
10217    /* Encode results */
10218    if(encRetVal.encoded == ENCODE_FAIL)
10219    {
10220       DU_LOG( "\nERROR  -->  F1AP : Could not encode UeCntxtDuToCuInfo (at %s)\n",\
10221             encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
10222       return RFAILED;
10223    }
10224    else
10225    {
10226       DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for UeCntxtDuToCuInfo\n");
10227       for(int i=0; i< encBufSize; i++)
10228       {
10229          printf("%x",encBuf[i]);
10230       }
10231    }
10232    duToCuCellGrp->size = encBufSize;
10233    DU_ALLOC(duToCuCellGrp->buf, duToCuCellGrp->size);
10234    if(!duToCuCellGrp->buf)
10235    {
10236       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in UeCntxtDuToCuInfo");
10237    }
10238    memcpy(duToCuCellGrp->buf, encBuf, duToCuCellGrp->size);
10239    return ROK;
10240 }
10241
10242 /*******************************************************************
10243  *
10244  * @brief Fills Dl Gtp tunnel Info
10245  *
10246  * @details
10247  *
10248  *    Function : fillGtpTunnelforDl
10249  *
10250  *    Functionality: Fills Dl Gtp tunnel Info
10251  *
10252  * @params[in]
10253  *
10254  * @return ROK     - success
10255  *         RFAILED - failure
10256  *
10257  * ****************************************************************/
10258
10259 uint8_t fillGtpTunnelforDl(GTPTunnel_t *gtpDl, GtpTnlCfg *gtpUeCfg)
10260 {
10261    uint8_t bufSize = 0;
10262
10263    gtpDl->transportLayerAddress.size    = 4*sizeof(uint8_t);
10264    DU_ALLOC(gtpDl->transportLayerAddress.buf, gtpDl->transportLayerAddress.size);
10265    if(gtpDl->transportLayerAddress.buf == NULLP)
10266    {
10267       return RFAILED;
10268    }
10269    memcpy(gtpDl->transportLayerAddress.buf, &gtpUeCfg->dlTnlAddress, gtpDl->transportLayerAddress.size);
10270
10271    /*GTP TEID*/
10272    gtpDl->gTP_TEID.size = 4 * sizeof(uint8_t);
10273    DU_ALLOC(gtpDl->gTP_TEID.buf, gtpDl->gTP_TEID.size);
10274    if(gtpDl->gTP_TEID.buf == NULLP)
10275    {
10276       return RFAILED;
10277    }
10278    bufSize = 3; /*forming an Octect String*/
10279    fillTeIdString(bufSize, gtpUeCfg->teId, gtpDl->gTP_TEID.buf);
10280
10281    return ROK;
10282 }
10283
10284 /*******************************************************************
10285  *
10286  * @brief Fills DL Tunnel Setup List
10287  *
10288  * @details
10289  *
10290  *    Function : fillDlTnlSetupList
10291  *
10292  *    Functionality: Fills the DL Tunnel Setup List
10293  *
10294  * @params[in]
10295  *
10296  * @return ROK     - success
10297  *         RFAILED - failure
10298  *
10299  * ****************************************************************/
10300
10301 uint8_t fillDlTnlSetupList(DLUPTNLInformation_ToBeSetup_List_t *dlTnlInfo, UpTnlCfg *tnlCfg)
10302 {
10303    uint8_t ret = ROK, arrIdx = 0, eleCount = 0;
10304
10305    eleCount = 1;
10306    dlTnlInfo->list.count = eleCount;
10307    dlTnlInfo->list.size = (eleCount * sizeof(DLUPTNLInformation_ToBeSetup_Item_t *));
10308
10309    /* Initialize the DL Tnl Setup List Members */
10310    DU_ALLOC(dlTnlInfo->list.array, dlTnlInfo->list.size);
10311    if(dlTnlInfo->list.array == NULLP)
10312    {
10313       DU_LOG(" ERROR  -->  F1AP : Memory allocation for DL Tnl Setup List in fillDlTnlSetupList()");
10314       ret = RFAILED;
10315    }
10316    for(arrIdx=0; arrIdx < eleCount; arrIdx++)
10317    {
10318       DU_ALLOC(dlTnlInfo->list.array[arrIdx], sizeof(DLUPTNLInformation_ToBeSetup_Item_t));
10319       if(dlTnlInfo->list.array[arrIdx] == NULLP)
10320       {
10321          DU_LOG(" ERROR  -->  F1AP : Memory allocation for arrIdx [%d] failed in fillDlTnlSetupList()", arrIdx);
10322          return RFAILED;
10323       }
10324       dlTnlInfo->list.array[arrIdx]->dLUPTNLInformation.present = UPTransportLayerInformation_PR_gTPTunnel;
10325       DU_ALLOC(dlTnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel, sizeof(GTPTunnel_t));
10326       if(dlTnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel == NULLP)
10327       {
10328          DU_LOG(" ERROR  -->  F1AP : Memory allocation for DL tunnel info in fillDlTnlSetupList()");
10329          return RFAILED;
10330       }
10331       ret = fillGtpTunnelforDl(dlTnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel,\
10332                tnlCfg->tnlCfg1);
10333       if(ret != ROK)
10334          break;
10335    }
10336    return ret;
10337 }
10338
10339 /*******************************************************************
10340  *
10341  * @brief Fills the Drb Setup List for Ue Context Setup Response
10342  *
10343  * @details
10344  *
10345  *    Function : fillDrbSetupList
10346  *
10347  *    Functionality: Fills the Drb Setup List for Ue Context Setup Response
10348  *
10349  * @params[in]
10350  *
10351  * @return ROK     - success
10352  *         RFAILED - failure
10353  *
10354  * ****************************************************************/
10355 uint8_t fillDrbSetupList(DRBs_Setup_List_t *drbSetupList, DuUeCfg *ueCfg)
10356 {
10357    uint8_t ret = ROK, arrIdx = 0, eleCount = 0;
10358    DRBs_Setup_ItemIEs_t *drbItemIe = NULLP;
10359
10360    eleCount = ueCfg->numDrb;
10361    drbSetupList->list.count = eleCount;
10362    drbSetupList->list.size = \
10363         (eleCount * sizeof(DRBs_Setup_Item_t *));
10364
10365    /* Initialize the Drb Setup List Members */
10366    DU_ALLOC(drbSetupList->list.array, drbSetupList->list.size);
10367    if(drbSetupList->list.array == NULLP)
10368    {
10369       DU_LOG(" ERROR  -->  F1AP : Memory allocation for DRB Setup List in fillDrbSetupList()");
10370       ret = RFAILED;
10371    }
10372
10373    for(arrIdx=0; arrIdx < eleCount; arrIdx++)
10374    {
10375       DU_ALLOC(drbSetupList->list.array[arrIdx], sizeof(DRBs_Setup_Item_t));
10376       if(drbSetupList->list.array[arrIdx] == NULLP)
10377       {
10378          DU_LOG(" ERROR  -->  F1AP : Memory allocation for arrIdx [%d] failed in fillDrbSetupList()", arrIdx);
10379          return RFAILED;
10380       }
10381       drbItemIe = ((DRBs_Setup_ItemIEs_t *)drbSetupList->list.array[arrIdx]);
10382       drbItemIe->id = ProtocolIE_ID_id_DRBs_Setup_Item;
10383       drbItemIe->criticality = Criticality_reject;
10384       drbItemIe->value.present = DRBs_Setup_ItemIEs__value_PR_DRBs_Setup_Item;
10385       drbItemIe->value.choice.DRBs_Setup_Item.dRBID = ueCfg->upTnlInfo[arrIdx].drbId;
10386       ret = fillDlTnlSetupList(&drbItemIe->value.choice.DRBs_Setup_Item.dLUPTNLInformation_ToBeSetup_List,\
10387           &ueCfg->upTnlInfo[arrIdx]);
10388       if(ret != ROK)
10389          break;
10390    }
10391    return ret;
10392 }
10393
10394 /*******************************************************************
10395  *
10396  * @brief Builds and sends the UE Setup Response
10397  *
10398  * @details
10399  *
10400  *    Function : BuildAndSendUeContextSetupRsp
10401  *
10402  *    Functionality: Constructs the UE Setup Response and sends
10403  *                   it to the DU through SCTP.
10404  *
10405  * @params[in]
10406  *
10407  * @return ROK     - success
10408  *         RFAILED - failure
10409  *
10410  * ****************************************************************/
10411 uint8_t BuildAndSendUeContextSetupRsp(uint8_t ueIdx, uint8_t cellId)
10412 {
10413    uint8_t   idx, ret, cellIdx, elementCnt;
10414    uint32_t  gnbCuUeF1apId;   /* gNB-CU UE F1AP Id */
10415    uint32_t  gnbDuUeF1apId;   /* gNB-DU UE F1AP Id */
10416    asn_enc_rval_t  encRetVal;        /* Encoder return value */
10417    F1AP_PDU_t               *f1apMsg = NULLP;
10418    UEContextSetupResponse_t *ueSetRsp = NULLP;
10419    CellGroupConfigRrc_t     *cellGrpCfg = NULLP;
10420    DuUeCb                   *ueCb = NULLP;
10421
10422    DU_LOG("\n INFO   -->  F1AP : Building UE Context Setup Response for cellId %d, ueIdx %d\n", cellId, ueIdx);
10423
10424    while(true)
10425    {
10426       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
10427       if(f1apMsg == NULLP)
10428       {
10429          DU_LOG(" ERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
10430          ret = RFAILED;
10431          break;
10432       }
10433
10434       f1apMsg->present = F1AP_PDU_PR_successfulOutcome;
10435       DU_ALLOC(f1apMsg->choice.successfulOutcome,
10436             sizeof(SuccessfulOutcome_t));
10437       if(f1apMsg->choice.successfulOutcome == NULLP)
10438       {
10439          DU_LOG(" ERROR  -->  F1AP : Memory allocation for      F1AP-PDU failed");
10440          ret = RFAILED;
10441          break;
10442       }
10443
10444       f1apMsg->choice.successfulOutcome->procedureCode = \
10445                                                          ProcedureCode_id_UEContextSetup;
10446       f1apMsg->choice.successfulOutcome->criticality = Criticality_reject;
10447       f1apMsg->choice.successfulOutcome->value.present = \
10448                                                          SuccessfulOutcome__value_PR_UEContextSetupResponse;
10449
10450       ueSetRsp =
10451          &f1apMsg->choice.successfulOutcome->value.choice.UEContextSetupResponse;
10452       elementCnt = 4;
10453       ueSetRsp->protocolIEs.list.count = elementCnt;
10454       ueSetRsp->protocolIEs.list.size = \
10455                                         elementCnt * sizeof(UEContextSetupResponse_t *);
10456
10457       /* Initialize the UESetup members */
10458       DU_ALLOC(ueSetRsp->protocolIEs.list.array, \
10459             ueSetRsp->protocolIEs.list.size);
10460       if(ueSetRsp->protocolIEs.list.array == NULLP)
10461       {
10462          DU_LOG(" ERROR  -->  F1AP : Memory allocation for UE Setup Response failed");
10463          ret = RFAILED;
10464          break;
10465       }
10466
10467       for(idx=0; idx<elementCnt; idx++)
10468       {
10469          DU_ALLOC(ueSetRsp->protocolIEs.list.array[idx],\
10470                sizeof(UEContextSetupResponseIEs_t));
10471          if(ueSetRsp->protocolIEs.list.array[idx] == NULLP)
10472          {
10473             DU_LOG(" ERROR  -->  F1AP : Memory allocation for UE Setup Response failed");
10474             ret = RFAILED;
10475             break;
10476          }
10477       }
10478       /* Fetching Ue Cb Info*/
10479       GET_CELL_IDX(cellId, cellIdx);
10480       gnbDuUeF1apId = duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].gnbDuUeF1apId;
10481       gnbCuUeF1apId = duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].gnbCuUeF1apId;
10482       ueCb = &duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1];
10483
10484       idx = 0;
10485       /*GNB CU UE F1AP ID*/
10486       ueSetRsp->protocolIEs.list.array[idx]->id = \
10487                                                   ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
10488       ueSetRsp->protocolIEs.list.array[idx]->criticality = Criticality_reject;
10489       ueSetRsp->protocolIEs.list.array[idx]->value.present = \
10490                                                              UEContextSetupResponseIEs__value_PR_GNB_CU_UE_F1AP_ID;
10491       ueSetRsp->protocolIEs.list.array[idx]->value.choice.GNB_CU_UE_F1AP_ID = gnbCuUeF1apId;
10492
10493       /*GNB DU UE F1AP ID*/
10494       idx++;
10495       ueSetRsp->protocolIEs.list.array[idx]->id = \
10496                                                   ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
10497       ueSetRsp->protocolIEs.list.array[idx]->criticality = Criticality_reject;
10498       ueSetRsp->protocolIEs.list.array[idx]->value.present = \
10499                                                              UEContextSetupResponseIEs__value_PR_GNB_DU_UE_F1AP_ID;
10500       ueSetRsp->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID = gnbDuUeF1apId;
10501
10502
10503       /*DUtoCURRC Information */
10504       idx++;
10505       ueSetRsp->protocolIEs.list.array[idx]->id  = \
10506                                                    ProtocolIE_ID_id_DUtoCURRCInformation;
10507       ueSetRsp->protocolIEs.list.array[idx]->criticality = Criticality_reject;
10508       ueSetRsp->protocolIEs.list.array[idx]->value.present =\
10509                                                             UEContextSetupResponseIEs__value_PR_DUtoCURRCInformation;
10510       if(ueCb->f1UeDb)
10511       {
10512          if(ueCb->f1UeDb->duUeCfg.cellGrpCfg)
10513          {
10514             cellGrpCfg = (CellGroupConfigRrc_t*)ueCb->f1UeDb->duUeCfg.cellGrpCfg;
10515             ret = EncodeUeCntxtDuToCuInfo(&ueSetRsp->protocolIEs.list.array[idx]->value.\
10516                      choice.DUtoCURRCInformation.cellGroupConfig, cellGrpCfg);
10517             if(ret == RFAILED)
10518             {
10519                DU_LOG("\nERROR  -->  F1AP : Failed to EncodeUeCntxtDuToCuInfo in BuildAndSendUeContextSetupRsp()");
10520                freeF1UeDb(ueCb->f1UeDb);
10521                ueCb->f1UeDb = NULLP;
10522                break;
10523             }
10524          }
10525       }
10526       else
10527       {
10528          DU_LOG("\nERROR  -->  F1AP : Failed to form DUtoCU RRCInfo at BuildAndSendUeContextSetupRsp()");
10529          ret = RFAILED;
10530          break;
10531       }
10532
10533       /* Drb Setup List */
10534       idx++;
10535       ueSetRsp->protocolIEs.list.array[idx]->id  = \
10536                                  ProtocolIE_ID_id_DRBs_Setup_List;
10537       ueSetRsp->protocolIEs.list.array[idx]->criticality = Criticality_reject;
10538       ueSetRsp->protocolIEs.list.array[idx]->value.present =\
10539                                  UEContextSetupResponseIEs__value_PR_DRBs_Setup_List;
10540       ret = fillDrbSetupList(&ueSetRsp->protocolIEs.list.array[idx]->value.choice.DRBs_Setup_List,\
10541                &ueCb->f1UeDb->duUeCfg);
10542       if(ret == RFAILED)
10543       {
10544          DU_LOG("\nERROR  -->  F1AP : Failed to fillDrbSetupList in BuildAndSendUeContextSetupRsp()");
10545          freeF1UeDb(ueCb->f1UeDb);
10546          ueCb->f1UeDb = NULLP;
10547          break;
10548       }
10549
10550        /* Free UeContext Db created during Ue context Req */
10551        freeF1UeDb(ueCb->f1UeDb);
10552        ueCb->f1UeDb = NULLP;
10553
10554       /* TODO: To send Drb list */
10555       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
10556
10557       /* Encode the UE context setup response type as APER */
10558       memset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
10559       encBufSize = 0;
10560       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
10561             encBuf);
10562       /* Encode results */
10563       if(encRetVal.encoded == ENCODE_FAIL)
10564       {
10565          DU_LOG( "\nERROR  -->  F1AP : Could not encode UE Context Setup Response structure (at %s)\n",\
10566                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
10567          ret = RFAILED;
10568          break;
10569       }
10570       else
10571       {
10572          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for UE Context Setup Response\n");
10573          for(int i=0; i< encBufSize; i++)
10574          {
10575             printf("%x",encBuf[i]);
10576          }
10577       }
10578
10579       /* Sending  msg  */
10580       if(SendF1APMsg(DU_APP_MEM_REGION,DU_POOL) != ROK)
10581       {
10582          DU_LOG("\nERROR  -->  F1AP : Sending UE Context Setup Response failed");
10583          ret = RFAILED;
10584          break;
10585       }
10586       break;
10587    }
10588    FreeUeContextSetupRsp(f1apMsg);
10589    return ret;
10590 }/* End of BuildAndSendUeContextSetupRsp */
10591 /*******************************************************************
10592 *
10593 * @brief  Build And Send Ue Context Rsp
10594 *
10595 * @details
10596 *
10597 *    Function : BuildAndSendUeCtxtRsp
10598 *
10599 *    Functionality : Build And Send Ue Context Rsp
10600
10601 * @params[in]
10602 * @return sucess = ROK
10603 *         failure = RFAILED
10604 *
10605 * ****************************************************************/
10606 uint8_t BuildAndSendUeCtxtRsp(uint8_t ueIdx, uint8_t cellId)
10607 {
10608    uint8_t cellIdx = 0, actionType = 0;
10609
10610    GET_CELL_IDX(cellId, cellIdx);
10611    actionType = duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].f1UeDb->actionType;
10612
10613    switch(actionType)
10614    {
10615       case UE_CTXT_SETUP:
10616          BuildAndSendUeContextSetupRsp(ueIdx, cellId);
10617          break;
10618       case UE_CTXT_MOD:
10619          BuildAndSendUeContextModResp(ueIdx, cellId);
10620          break;
10621       default:
10622          DU_LOG("ERROR  -->  F1AP: Invalid Action Type %d at BuildAndSendUeCtxtRsp()", actionType);
10623          break;
10624
10625    }
10626    return ROK;
10627 }
10628
10629 /*******************************************************************
10630  *
10631  * @brief deallocating the memory of  F1reset msg
10632  *
10633  * @details
10634  *
10635  *    Function : FreeF1ResetReq
10636  *
10637  *    Functionality :
10638  *         - freeing memory of F1reset request msg
10639  *
10640  * @params[in]
10641  * @return void
10642  *
10643  *
10644  * ****************************************************************/
10645 void FreeF1ResetReq(F1AP_PDU_t *f1apMsg)
10646 {
10647    uint8_t idx =0 ;
10648    Reset_t *f1ResetMsg;
10649
10650    if(f1apMsg)
10651    {
10652       if(f1apMsg->choice.initiatingMessage)
10653       {
10654          f1ResetMsg = &f1apMsg->choice.initiatingMessage->value.choice.Reset;
10655
10656          if(f1ResetMsg->protocolIEs.list.array)
10657          {
10658             for(idx=0 ;idx < f1ResetMsg->protocolIEs.list.count ; idx++)
10659             {
10660                if(f1ResetMsg->protocolIEs.list.array[idx])
10661                {
10662                   DU_FREE(f1ResetMsg->protocolIEs.list.array[idx],sizeof(ResetIEs_t));
10663                }
10664             }
10665             DU_FREE(f1ResetMsg->protocolIEs.list.array,f1ResetMsg->protocolIEs.list.size);
10666          }
10667          DU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
10668       }
10669       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
10670    }
10671 }
10672 /*******************************************************************
10673  *
10674  * @brief Build and Send F1reset request
10675  *
10676  * @details
10677  *
10678  *    Function : BuildAndSendF1ResetReq
10679  *
10680  *    Functionality:
10681  *         - Build and Send F1reset request msg
10682  *
10683  * @params[in]
10684  * @return ROK     - success
10685  *         RFAILED - failure
10686  *
10687  * ****************************************************************/
10688 uint8_t BuildAndSendF1ResetReq()
10689 {
10690    uint8_t          elementCnt=0;
10691    uint8_t          idx=0;
10692    uint8_t          ret= RFAILED;
10693    Reset_t          *f1ResetMsg = NULLP;
10694    F1AP_PDU_t       *f1apMsg = NULLP;
10695    asn_enc_rval_t   encRetVal;
10696    DU_LOG("\nINFO   -->  F1AP : Building F1 Reset request \n");
10697    do
10698    {
10699       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
10700       if(f1apMsg == NULLP)
10701       {
10702          break;
10703       }
10704       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
10705       DU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
10706       if(f1apMsg->choice.initiatingMessage == NULLP)
10707       {
10708          break;
10709       }
10710       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_Reset;
10711       f1apMsg->choice.initiatingMessage->criticality = Criticality_reject;
10712       f1apMsg->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_Reset;
10713
10714       f1ResetMsg = &f1apMsg->choice.initiatingMessage->value.choice.Reset;
10715
10716       elementCnt = 3;
10717       f1ResetMsg->protocolIEs.list.count = elementCnt;
10718       f1ResetMsg->protocolIEs.list.size = elementCnt * sizeof(ResetIEs_t *);
10719
10720       /* Initialize the F1Setup members */
10721       DU_ALLOC(f1ResetMsg->protocolIEs.list.array,f1ResetMsg->protocolIEs.list.size);
10722       if(f1ResetMsg->protocolIEs.list.array == NULLP)
10723       {
10724          break;
10725       }
10726       for(idx=0; idx<elementCnt; idx++)
10727       {
10728          DU_ALLOC(f1ResetMsg->protocolIEs.list.array[idx],sizeof(ResetIEs_t));
10729          if(f1ResetMsg->protocolIEs.list.array[idx] == NULLP)
10730          {
10731             break;
10732          }
10733       }
10734
10735       /*TransactionID*/
10736       idx=0;
10737       f1ResetMsg->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_TransactionID;
10738       f1ResetMsg->protocolIEs.list.array[idx]->criticality = Criticality_reject;
10739       f1ResetMsg->protocolIEs.list.array[idx]->value.present = ResetIEs__value_PR_TransactionID;
10740       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.TransactionID = 1;
10741
10742       /*Cause*/
10743       idx++;
10744       f1ResetMsg->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_Cause;
10745       f1ResetMsg->protocolIEs.list.array[idx]->criticality = Criticality_ignore;
10746       f1ResetMsg->protocolIEs.list.array[idx]->value.present = ResetIEs__value_PR_Cause;
10747       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.Cause.present = Cause_PR_radioNetwork;
10748       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.Cause.choice.radioNetwork = CauseRadioNetwork_action_desirable_for_radio_reasons;
10749
10750       /*Reset Type*/
10751       idx++;
10752       f1ResetMsg->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_ResetType;
10753       f1ResetMsg->protocolIEs.list.array[idx]->criticality = Criticality_reject;
10754       f1ResetMsg->protocolIEs.list.array[idx]->value.present = ResetIEs__value_PR_ResetType;
10755       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.ResetType.present = ResetType_PR_f1_Interface;
10756       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.ResetType.choice.f1_Interface = ResetAll_reset_all;
10757
10758       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
10759
10760       /* Encode the F1SetupRequest type as APER */
10761       memset(encBuf, 0, ENC_BUF_MAX_LEN);
10762       encBufSize = 0;
10763       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
10764             encBuf);
10765
10766       /* Encode results */
10767       if(encRetVal.encoded == ENCODE_FAIL)
10768       {
10769          DU_LOG("\nERROR  -->  F1AP : Could not encode F1Reset structure (at %s)\n",\
10770                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
10771          break;
10772       }
10773       else
10774       {
10775          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for F1Reset\n");
10776          for(idx=0; idx< encBufSize; idx++)
10777          {
10778             printf("%x",encBuf[idx]);
10779          }
10780       }
10781
10782       if(SendF1APMsg(DU_APP_MEM_REGION, DU_POOL) != ROK)
10783       {
10784          DU_LOG("\nERROR  -->  F1AP : Sending F1 Reset request failed");
10785          break;
10786       }
10787
10788       ret = ROK;
10789       break;
10790    }while(true);
10791
10792    FreeF1ResetReq(f1apMsg);
10793    return ret;
10794 }
10795 /*******************************************************************
10796  *
10797  * @brief Build And Send F1ResetAck
10798  *
10799  * @details
10800  *
10801  *    Function : BuildAndSendF1ResetAck
10802  *
10803  *    Functionality:
10804  *         - Build And Send  F1ResetRSP
10805  *
10806  * @return ROK     - success
10807  *         RFAILED - failure
10808  *
10809  * ****************************************************************/
10810 void FreeF1ResetAck(F1AP_PDU_t *f1apMsg)
10811 {
10812    uint8_t idx;
10813    ResetAcknowledge_t *f1ResetAck;
10814
10815    if(f1apMsg)
10816    {
10817       if(f1apMsg->choice.successfulOutcome)
10818       {
10819          f1ResetAck= &f1apMsg->choice.successfulOutcome->value.choice.ResetAcknowledge;
10820
10821          if(f1ResetAck->protocolIEs.list.array)
10822          {
10823             for(idx=0; idx<f1ResetAck->protocolIEs.list.count ; idx++)
10824             {
10825                if(f1ResetAck->protocolIEs.list.array[idx])
10826                {
10827                   DU_FREE(f1ResetAck->protocolIEs.list.array[idx], sizeof(ResetAcknowledgeIEs_t));
10828                }
10829             }
10830             DU_FREE(f1ResetAck->protocolIEs.list.array, f1ResetAck->protocolIEs.list.size );
10831          }
10832          DU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
10833       }
10834       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
10835    }
10836 }
10837
10838 /*******************************************************************
10839  *
10840  * @brief Build And Send F1ResetAck
10841  *
10842  * @details
10843  *
10844  *    Function : BuildAndSendF1ResetAck
10845  *
10846  *    Functionality:
10847  *         - Build And Send  F1ResetRSP
10848  *
10849  *  @params[in]
10850  * @return ROK     - success
10851  *         RFAILED - failure
10852  *
10853  * ****************************************************************/
10854 uint8_t BuildAndSendF1ResetAck()
10855 {
10856    uint8_t                idx = 0;
10857    uint8_t                elementCnt = 0;
10858    uint8_t                ret = RFAILED;
10859    F1AP_PDU_t             *f1apMsg = NULL;
10860    ResetAcknowledge_t     *f1ResetAck = NULLP;
10861    asn_enc_rval_t         encRetVal;
10862    DU_LOG("\nINFO   -->  F1AP : Building F1 Reset Acknowledgment \n");
10863
10864    do{
10865       /* Allocate the memory for F1ResetRequest_t */
10866       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
10867       if(f1apMsg == NULLP)
10868       {
10869          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
10870          break;
10871       }
10872
10873       f1apMsg->present =  F1AP_PDU_PR_successfulOutcome;
10874
10875       DU_ALLOC(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
10876       if(f1apMsg->choice.successfulOutcome == NULLP)
10877       {
10878          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
10879          break;
10880       }
10881       f1apMsg->choice.successfulOutcome->criticality   = Criticality_reject;
10882       f1apMsg->choice.successfulOutcome->value.present = SuccessfulOutcome__value_PR_ResetAcknowledge;
10883       f1ResetAck = &f1apMsg->choice.successfulOutcome->value.choice.ResetAcknowledge;
10884
10885       elementCnt = 1;
10886
10887       f1ResetAck->protocolIEs.list.count = elementCnt;
10888       f1ResetAck->protocolIEs.list.size = elementCnt*sizeof(ResetAcknowledgeIEs_t *);
10889
10890       DU_ALLOC(f1ResetAck->protocolIEs.list.array, f1ResetAck->protocolIEs.list.size );
10891       if(f1ResetAck->protocolIEs.list.array == NULLP)
10892       {
10893          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1ResetAckIEs failed");
10894          break;
10895       }
10896
10897       for(idx=0; idx<elementCnt; idx++)
10898       {
10899          DU_ALLOC(f1ResetAck->protocolIEs.list.array[idx], sizeof(ResetAcknowledgeIEs_t));
10900          if(f1ResetAck->protocolIEs.list.array[idx] == NULLP)
10901          {
10902             break;
10903          }
10904       }
10905       /*TransactionID*/
10906       idx = 0;
10907       f1ResetAck->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_TransactionID;
10908       f1ResetAck->protocolIEs.list.array[idx]->criticality = Criticality_reject;
10909       f1ResetAck->protocolIEs.list.array[idx]->value.present = ResetAcknowledgeIEs__value_PR_TransactionID;
10910       f1ResetAck->protocolIEs.list.array[idx]->value.choice.TransactionID = TRANS_ID;
10911
10912       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
10913
10914       /* Encode the F1SetupRequest type as UPER */
10915       memset(encBuf, 0, ENC_BUF_MAX_LEN);
10916       encBufSize = 0;
10917       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
10918
10919       /* Check encode results */
10920       if(encRetVal.encoded == ENCODE_FAIL)
10921       {
10922          DU_LOG("\nERROR  -->  F1AP : Could not encode F1ResetAck structure (at %s)\n",\
10923                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
10924          break;
10925       }
10926       else
10927       {
10928          DU_LOG("\nDUBUG   -->  F1AP : Created APER encoded buffer for F1ResetAck\n");
10929          for(int i=0; i< encBufSize; i++)
10930          {
10931             printf("%x",encBuf[i]);
10932          }
10933       }
10934       /* Sending msg */
10935       if(SendF1APMsg(DU_APP_MEM_REGION, DU_POOL) != ROK)
10936       {
10937          DU_LOG("\nERROR  -->  F1AP : Sending F1 Reset Acknowledgement failed");
10938          break;
10939       }
10940
10941       ret = ROK;
10942       break;
10943    }while(true);
10944
10945    FreeF1ResetAck(f1apMsg);
10946    return ret;
10947 }
10948 /******************************************************************
10949 *
10950 * @brief free F1 reset msg allocated by aper_decoder
10951 *
10952 * @details
10953 *
10954 *    Function : freeAperDecodeF1ResetMsg
10955 *
10956 *    Functionality: free F1 reset msg allocated by aper_decoder
10957 *
10958 * @params[in] Reset_t *f1ResetMsg
10959 * @return void
10960 *
10961 * ****************************************************************/
10962
10963 void freeAperDecodeF1ResetMsg(Reset_t *f1ResetMsg)
10964 {
10965    uint8_t ieIdx =0;
10966    if(f1ResetMsg->protocolIEs.list.array)
10967    {
10968       for(ieIdx=0 ;ieIdx < f1ResetMsg->protocolIEs.list.count ; ieIdx++)
10969       {
10970          if(f1ResetMsg->protocolIEs.list.array[ieIdx])
10971          {
10972             free(f1ResetMsg->protocolIEs.list.array[ieIdx]);
10973          }
10974       }
10975       free(f1ResetMsg->protocolIEs.list.array);
10976    }
10977 }
10978
10979 /******************************************************************
10980  *
10981  * @brief Processes DL RRC Message Transfer  sent by CU
10982  *
10983  * @details
10984  *
10985  *    Function : procF1ResetReq
10986  *
10987  *    Functionality: Processes DL RRC Message Transfer sent by CU
10988  *
10989  * @params[in] F1AP_PDU_t ASN decoded F1AP message
10990  * @return ROK     - success
10991  *         RFAILED - failure
10992  *
10993  * ****************************************************************/
10994 uint8_t procF1ResetReq(F1AP_PDU_t *f1apMsg)
10995 {
10996    /* we are currently not supporting Ue release. right now we are supporting only init case of fireset */
10997    uint8_t       ieIdx = 0;
10998    uint8_t        ret = ROK;
10999    Reset_t       *f1ResetMsg = NULLP;
11000
11001    DU_LOG("\nINFO   -->  Processing F1 reset request");
11002    f1ResetMsg = &f1apMsg->choice.initiatingMessage->value.choice.Reset;
11003
11004    for(ieIdx=0; ieIdx<f1ResetMsg->protocolIEs.list.count; ieIdx++)
11005    {
11006       switch(f1ResetMsg->protocolIEs.list.array[ieIdx]->id)
11007       {
11008          case ProtocolIE_ID_id_TransactionID:
11009             break;
11010
11011          case ProtocolIE_ID_id_Cause:
11012             break;
11013
11014          case ProtocolIE_ID_id_ResetType:
11015             {
11016                break;
11017             }
11018
11019          default:
11020             break;
11021       }
11022    }
11023    ret = BuildAndSendF1ResetAck();
11024    DU_LOG("\nINFO   -->  UE release is not supported for now");
11025
11026    freeAperDecodeF1ResetMsg(f1ResetMsg);
11027
11028    return ret;
11029 }
11030
11031 /*******************************************************************
11032  *
11033  * @brief free the RRC delivery report
11034  *
11035  * @details
11036  *
11037  *    Function : freeRrcDeliveryReport
11038  *
11039  *    Functionality: free the RRC delivery report
11040  *
11041  * @params[in]
11042  * @return ROK     - success
11043  *         RFAILED - failure
11044  *
11045  * ****************************************************************/
11046 void freeRrcDeliveryReport(F1AP_PDU_t  *f1apMsg )
11047 {
11048    uint8_t idx=0;
11049    RRCDeliveryReport_t *rrcDeliveryReport= NULLP;
11050
11051    if(f1apMsg)
11052    {
11053       if(f1apMsg->choice.initiatingMessage)
11054       {
11055          rrcDeliveryReport = &f1apMsg->choice.initiatingMessage->value.choice.RRCDeliveryReport;
11056          if(rrcDeliveryReport->protocolIEs.list.array)
11057          {
11058             for(idx =0 ;idx <rrcDeliveryReport->protocolIEs.list.count ;
11059                   idx++)
11060             {
11061                if(rrcDeliveryReport->protocolIEs.list.array[idx])
11062                {
11063                   DU_FREE(rrcDeliveryReport->protocolIEs.list.array[idx],
11064                         sizeof(RRCDeliveryReportIEs_t));
11065                }
11066             }
11067             DU_FREE(rrcDeliveryReport->protocolIEs.list.array,
11068                   rrcDeliveryReport->protocolIEs.list.size);
11069          }
11070          DU_FREE(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
11071       }
11072       DU_FREE(f1apMsg,
11073             sizeof(F1AP_PDU_t));
11074    }
11075 }
11076
11077 /*******************************************************************
11078 *
11079 * @brief Builds and sends the RRC delivery report
11080 *
11081 * @details
11082 *
11083 *    Function : BuildAndSendRrcDeliveryReport
11084 *
11085 *    Functionality: Builds and sends the RRC delivery report
11086 *
11087 * @params[in]
11088 *
11089 * @return ROK     - success
11090 *         RFAILED - failure
11091 *
11092 * ****************************************************************/
11093 uint8_t BuildAndSendRrcDeliveryReport(uint32_t gnbCuUeF1apId, \
11094    uint32_t gnbDuUeF1apId, RrcDeliveryReport *rrcDelivery)
11095 {
11096    uint8_t             ret = RFAILED;
11097    uint8_t             idx    = 0;
11098    uint8_t             idx1   = 0;
11099    uint8_t             elementCnt = 0;
11100    F1AP_PDU_t          *f1apMsg = NULLP;
11101    asn_enc_rval_t      encRetVal;
11102    RRCDeliveryReport_t *rrcDeliveryReport= NULLP;
11103
11104    do{
11105
11106       DU_LOG("\nINFO   -->  F1AP : Building RRC delivery Message Transfer Message\n");
11107       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
11108       if(f1apMsg == NULLP)
11109       {
11110          DU_LOG(" ERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
11111          break;
11112       }
11113       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
11114       DU_ALLOC(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
11115       if(f1apMsg->choice.initiatingMessage == NULLP)
11116       {
11117          DU_LOG(" ERROR  -->  F1AP : Memory allocation for  F1AP-PDU  failed");
11118          break;
11119       }
11120       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_RRCDeliveryReport;
11121       f1apMsg->choice.initiatingMessage->criticality   = Criticality_ignore;
11122       f1apMsg->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_RRCDeliveryReport;
11123
11124       rrcDeliveryReport = &f1apMsg->choice.initiatingMessage->value.choice.RRCDeliveryReport;
11125       elementCnt = 4;
11126       rrcDeliveryReport->protocolIEs.list.count = elementCnt;
11127       rrcDeliveryReport->protocolIEs.list.size = elementCnt * sizeof(RRCDeliveryReportIEs_t *);
11128
11129       /* Initialize the F1Setup members */
11130       DU_ALLOC(rrcDeliveryReport->protocolIEs.list.array, rrcDeliveryReport->protocolIEs.list.size);
11131       if(rrcDeliveryReport->protocolIEs.list.array == NULLP)
11132       {
11133          DU_LOG(" ERROR  -->  F1AP : Memory allocation for RRC Delivery  failed");
11134          break;
11135       }
11136       for(idx =0 ;idx <elementCnt; idx++)
11137       {
11138          DU_ALLOC(rrcDeliveryReport->protocolIEs.list.array[idx], sizeof(RRCDeliveryReportIEs_t));
11139          if(rrcDeliveryReport->protocolIEs.list.array[idx] == NULLP)
11140          {
11141             break;
11142          }
11143       }
11144
11145       idx1 = 0;
11146
11147       /*GNB CU UE F1AP ID*/
11148       rrcDeliveryReport->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
11149       rrcDeliveryReport->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
11150       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.present = RRCDeliveryReportIEs__value_PR_GNB_CU_UE_F1AP_ID;
11151       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.choice.GNB_CU_UE_F1AP_ID = gnbCuUeF1apId;
11152
11153       /*GNB DU UE F1AP ID*/
11154       idx1++;
11155       rrcDeliveryReport->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
11156       rrcDeliveryReport->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
11157       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.present = RRCDeliveryReportIEs__value_PR_GNB_DU_UE_F1AP_ID;
11158       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.choice.GNB_DU_UE_F1AP_ID = gnbDuUeF1apId;
11159
11160       /*RRC delivery status*/
11161       idx1++;
11162       rrcDeliveryReport->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_RRCDeliveryStatus;
11163       rrcDeliveryReport->protocolIEs.list.array[idx1]->criticality = Criticality_ignore;
11164       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.present = RRCDeliveryReportIEs__value_PR_RRCDeliveryStatus;
11165       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.choice.RRCDeliveryStatus.delivery_status =\
11166       rrcDelivery->rrcDeliveryStatus.deliveryStatus;
11167       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.choice.RRCDeliveryStatus.triggering_message =\
11168       rrcDelivery->rrcDeliveryStatus.triggeringMessage;
11169
11170       /* SRB ID */
11171       idx1++;
11172       rrcDeliveryReport->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_SRBID;
11173       rrcDeliveryReport->protocolIEs.list.array[idx1]->criticality = Criticality_ignore;
11174       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.present = RRCDeliveryReportIEs__value_PR_SRBID;
11175       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.choice.SRBID =  rrcDelivery->srbId;
11176
11177       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
11178
11179       /* Encode the RRC DELIVERY REPORT type as APER */
11180       memset(encBuf, 0, ENC_BUF_MAX_LEN);
11181       encBufSize = 0;
11182       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
11183             encBuf);
11184
11185       /* Encode results */
11186       if(encRetVal.encoded == ENCODE_FAIL)
11187       {
11188          DU_LOG("\nERROR  -->  F1AP : Could not encode RRC Delivery Msg structure (at %s)\n",\
11189                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
11190          break;
11191       }
11192       else
11193       {
11194          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for RRC Delivery Msg \n");
11195          for(idx=0; idx< encBufSize; idx++)
11196          {
11197             printf("%x",encBuf[idx]);
11198          }
11199       }
11200
11201       /* Sending msg */
11202       if(SendF1APMsg(DU_APP_MEM_REGION, DU_POOL) != ROK)
11203       {
11204          DU_LOG("\nERROR  -->  F1AP : Sending RRC delivery  msg request failed");
11205          break;
11206       }
11207       ret = ROK;
11208       break;
11209
11210    }while(true);
11211
11212    freeRrcDeliveryReport(f1apMsg);
11213    return ret;
11214 }
11215
11216 /*******************************************************************
11217  *
11218  * @brief Processes cells to be activated
11219  *
11220  * @details
11221  *
11222  *    Function : extractCellsToBeActivated
11223  *
11224  *    Functionality:
11225  *      - Processes cells to be activated list received in F1SetupRsp
11226  *
11227  * @params[in] void
11228  * @return ROK     - success
11229  *         RFAILED - failure
11230  *
11231  * ****************************************************************/
11232
11233 uint8_t extractCellsToBeActivated(Cells_to_be_Activated_List_t cellsToActivate)
11234 {
11235    uint8_t  ret = ROK;
11236    uint16_t idx, nci, pci = 0;
11237    Cells_to_be_Activated_List_Item_t cell;
11238
11239    for(idx=0; idx<cellsToActivate.list.count; idx++)
11240    {
11241       nci = 0;
11242       cell = cellsToActivate.list.array[idx]->value.choice.Cells_to_be_Activated_List_Item;
11243       bitStringToInt(&cell.nRCGI.nRCellIdentity, &nci);
11244
11245       if(cell.nRPCI)
11246       {
11247          pci = *cell.nRPCI;
11248       }
11249       ret = duProcCellsToBeActivated(cell.nRCGI.pLMN_Identity.buf, nci, pci);
11250    }
11251    return ret;
11252 }
11253 /******************************************************************
11254 *
11255 * @brief Processes F1 Setup Response allocated by aper_decoder
11256 *
11257 * @details
11258 *
11259 *    Function : freeF1SetupRsp
11260 *
11261 *    Functionality: free F1 Setup Response allocated by aper_decoder
11262 *
11263 * @params[in] F1SetupResponse_t *f1SetRspMsg
11264 * @return void
11265 *
11266 * ****************************************************************/
11267
11268 void freeAperDecodeF1SetupRsp(F1SetupResponse_t *f1SetRspMsg)
11269 {
11270    uint8_t ieIdx =0;
11271    uint8_t arrIdx =0;
11272    Cells_to_be_Activated_List_t *cellToActivate =NULLP;
11273    RRC_Version_t      *rrcVer =NULLP;
11274
11275    if(f1SetRspMsg->protocolIEs.list.array)
11276    {
11277       for(ieIdx=0; ieIdx<f1SetRspMsg->protocolIEs.list.count; ieIdx++)
11278       {
11279          if(f1SetRspMsg->protocolIEs.list.array[ieIdx])
11280          {
11281             switch(f1SetRspMsg->protocolIEs.list.array[ieIdx]->id)
11282             {
11283                case ProtocolIE_ID_id_Cells_to_be_Activated_List:
11284                   {
11285                      cellToActivate =
11286                         &f1SetRspMsg->protocolIEs.list.array[ieIdx]->value.choice.Cells_to_be_Activated_List;
11287                      if(cellToActivate->list.array)
11288                      {
11289                         for(arrIdx=0; arrIdx<cellToActivate->list.count ; arrIdx++)
11290                         {
11291                            if(cellToActivate->list.array[arrIdx])
11292                            {
11293
11294                               if(cellToActivate->list.array[0]->value.choice.Cells_to_be_Activated_List_Item.nRCGI.\
11295                               pLMN_Identity.buf)
11296                               {
11297                                  if(cellToActivate->list.array[0]->value.choice.\
11298                                        Cells_to_be_Activated_List_Item.nRCGI.nRCellIdentity.buf)
11299                                  {
11300                                     free(cellToActivate->list.array[0]->value.choice.\
11301                                           Cells_to_be_Activated_List_Item.nRCGI.nRCellIdentity.buf);
11302                                  }
11303
11304                                  free(cellToActivate->list.array[0]->value.choice.Cells_to_be_Activated_List_Item.\
11305                                        nRCGI.pLMN_Identity.buf);
11306                               }
11307                               free(cellToActivate->list.array[arrIdx]);
11308                            }
11309                         }
11310                         free(cellToActivate->list.array);
11311                      }
11312                      break;
11313                   }
11314                case ProtocolIE_ID_id_TransactionID:
11315                   {
11316                      break;
11317                   }
11318                case ProtocolIE_ID_id_gNB_CU_Name:
11319                   {
11320                      free(f1SetRspMsg->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_Name.buf);
11321                      break;
11322                   }
11323                case ProtocolIE_ID_id_GNB_CU_RRC_Version:
11324                   {
11325                      rrcVer = &f1SetRspMsg->protocolIEs.list.array[ieIdx]->value.choice.RRC_Version;
11326                      if(rrcVer->latest_RRC_Version.buf)
11327                      {
11328                         if(rrcVer->iE_Extensions)
11329                         {
11330                            if(rrcVer->iE_Extensions->list.array)
11331                            {
11332                               if(rrcVer->iE_Extensions->list.array[0])
11333                               {
11334                                  if(rrcVer->iE_Extensions->list.\
11335                                        array[0]->extensionValue.choice.Latest_RRC_Version_Enhanced.buf)
11336                                  {
11337                                     free(rrcVer->iE_Extensions->list.\
11338                                           array[0]->extensionValue.choice.Latest_RRC_Version_Enhanced.buf);
11339                                  }
11340                                  free(rrcVer->iE_Extensions->list.array[0]);
11341                               }
11342                               free(rrcVer->iE_Extensions->list.array);
11343                            }
11344                            free(rrcVer->iE_Extensions);
11345                         }
11346                         free(rrcVer->latest_RRC_Version.buf);
11347                      }
11348                      break;
11349
11350                   }
11351                default:
11352                   {
11353                      DU_LOG("\nERROR  -->  DU_APP : Invalid IE received in F1SetupRsp:%ld",
11354                            f1SetRspMsg->protocolIEs.list.array[ieIdx]->id);
11355                   }
11356             }
11357             free(f1SetRspMsg->protocolIEs.list.array[ieIdx]);
11358          }
11359       }
11360       free(f1SetRspMsg->protocolIEs.list.array);
11361    }
11362 }
11363 /******************************************************************
11364  *
11365  * @brief Processes F1 Setup Response sent by CU
11366  *
11367  * @details
11368  *
11369  *    Function : procF1SetupRsp
11370  *
11371  *    Functionality: Processes F1 Setup Response sent by CU
11372  *
11373  * @params[in] F1AP_PDU_t ASN decoded F1AP message
11374  * @return ROK     - success
11375  *         RFAILED - failure
11376  *
11377  * ****************************************************************/
11378 uint8_t procF1SetupRsp(F1AP_PDU_t *f1apMsg)
11379 {
11380    uint8_t ret = ROK;
11381    uint16_t idx =0;
11382    F1SetupResponse_t *f1SetRspMsg = NULLP;
11383    GNB_CU_Name_t     *cuName = NULLP;
11384    F1SetupRsp  f1SetRspDb;
11385    RRC_Version_t      *rrcVer =NULLP;
11386
11387    memset(&f1SetRspDb, 0, sizeof(F1SetupRsp));
11388
11389    DU_LOG("\nINFO   -->  F1AP : F1 Setup Response received");
11390    f1SetRspMsg = &f1apMsg->choice.successfulOutcome->value.choice.F1SetupResponse;
11391
11392    for(idx=0; idx<f1SetRspMsg->protocolIEs.list.count; idx++)
11393    {
11394       switch(f1SetRspMsg->protocolIEs.list.array[idx]->id)
11395       {
11396          case ProtocolIE_ID_id_Cells_to_be_Activated_List:
11397             {
11398                extractCellsToBeActivated(f1SetRspMsg->protocolIEs.list.array[idx]->\
11399                      value.choice.Cells_to_be_Activated_List);
11400                break;
11401             }
11402          case ProtocolIE_ID_id_TransactionID:
11403             {
11404                f1SetRspDb.transId = f1SetRspMsg->protocolIEs.list.array[idx]->\
11405                                     value.choice.TransactionID;
11406                break;
11407             }
11408          case ProtocolIE_ID_id_gNB_CU_Name:
11409             {
11410                cuName = &f1SetRspMsg->protocolIEs.list.array[idx]->\
11411                         value.choice.GNB_CU_Name;
11412                strcpy(f1SetRspDb.cuName, (const char*)cuName->buf);
11413                break;
11414             }
11415          case ProtocolIE_ID_id_GNB_CU_RRC_Version:
11416             {
11417                rrcVer = &f1SetRspMsg->protocolIEs.list.array[idx]->value.choice.RRC_Version;
11418                strcpy(f1SetRspDb.rrcVersion.rrcVer,
11419                      (const char*)rrcVer->latest_RRC_Version.buf);
11420                break;
11421             }
11422          default:
11423             DU_LOG("\nERROR  -->  DU_APP : Invalid IE received in F1SetupRsp:%ld",
11424                   f1SetRspMsg->protocolIEs.list.array[idx]->id);
11425       }
11426       duProcF1SetupRsp();
11427    }
11428
11429    freeAperDecodeF1SetupRsp(f1SetRspMsg);
11430    return ret;
11431 }
11432 /*******************************************************************
11433 *
11434 * @brief free GNB DU config update ack
11435 *
11436 * @details
11437 *
11438 *    Function : freeAperDecodeGnbDuAck
11439 *
11440 *    Functionality: Processes GNB DU config update ack And
11441 *                     added free part for the memory allocated by aper_decoder
11442 *
11443 * @params[in] F1AP_PDU_t ASN decoded F1AP message
11444 * @return ROK     - success
11445 *         RFAILED - failure
11446 *
11447 * ****************************************************************/
11448
11449 void freeAperDecodeGnbDuAck(GNBDUConfigurationUpdateAcknowledge_t *gnbDuAck)
11450 {
11451    uint8_t ieIdx = 0;
11452
11453    if(gnbDuAck->protocolIEs.list.array)
11454    {
11455       for(ieIdx=0; ieIdx < gnbDuAck->protocolIEs.list.count; ieIdx++)
11456       {
11457          if(gnbDuAck->protocolIEs.list.array[ieIdx])
11458          {
11459             free(gnbDuAck->protocolIEs.list.array[ieIdx]);
11460          }
11461       }
11462       free(gnbDuAck->protocolIEs.list.array);
11463    }
11464 }
11465 /*******************************************************************
11466 *
11467 * @brief Processes GNB DU config update ack
11468 *
11469 * @details
11470 *
11471 *    Function : procF1GNBDUCfgUpdAck
11472 *
11473 *    Functionality: added free part for the memory allocated by aper_decoder
11474 *
11475 * @params[in] F1AP_PDU_t *f1apMsg
11476 * @return void
11477 *
11478 * ****************************************************************/
11479 uint8_t procF1GNBDUCfgUpdAck(F1AP_PDU_t *f1apMsg)
11480 {
11481    uint8_t ieIdx;
11482    GNBDUConfigurationUpdateAcknowledge_t *gnbDuAck = NULLP;
11483
11484    DU_LOG("\nINFO   -->  F1AP : GNB-DU config update acknowledgment");
11485    gnbDuAck = &f1apMsg->choice.successfulOutcome->value.choice.GNBDUConfigurationUpdateAcknowledge;
11486
11487    for(ieIdx=0; ieIdx < gnbDuAck->protocolIEs.list.count; ieIdx++)
11488    {
11489       switch(gnbDuAck->protocolIEs.list.array[ieIdx]->id)
11490       {
11491          case ProtocolIE_ID_id_TransactionID:
11492             break;
11493          case ProtocolIE_ID_id_Cells_to_be_Activated_List:
11494             break;
11495          default :
11496             DU_LOG("\nERROR  -->  F1AP: Invalid IE Received: %ld, at procF1GNBDUCfgUpdAck()", \
11497             gnbDuAck->protocolIEs.list.array[ieIdx]->id);
11498             break;
11499       }
11500    }
11501    duProcGnbDuCfgUpdAckMsg();
11502 #if 0
11503    if(BuildAndSendF1ResetReq() != ROK)
11504    {
11505       return RFAILED;
11506    }
11507 #endif
11508
11509    freeAperDecodeGnbDuAck(gnbDuAck);
11510    return ROK;
11511 }
11512 /******************************************************************
11513 *
11514 * @brief free DL RRC Message Transfer allocated by aper_decoder
11515 *
11516 * @details
11517 *
11518 *    Function : freeAperDecodef1DlRrcMsg
11519 *
11520 *    Functionality: free DL RRC Message Transfer allocated by aper_decoder
11521 *
11522 * @params[in] DLRRCMessageTransfer_t *f1DlRrcMsg
11523 * @return ROK     - success
11524 *         RFAILED - failure
11525 *
11526 * ****************************************************************/
11527
11528 void freeAperDecodef1DlRrcMsg(DLRRCMessageTransfer_t *f1DlRrcMsg)
11529 {
11530    uint8_t ieIdx =0;
11531    RRCContainer_t *rrcContainer = NULLP;
11532
11533    if(f1DlRrcMsg->protocolIEs.list.array)
11534    {
11535       for(ieIdx=0; ieIdx<f1DlRrcMsg->protocolIEs.list.count; ieIdx++)
11536       {
11537          if(f1DlRrcMsg->protocolIEs.list.array[ieIdx])
11538          {
11539             switch(f1DlRrcMsg->protocolIEs.list.array[ieIdx]->id)
11540             {
11541                case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
11542                   break;
11543                case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
11544                   break;
11545                case ProtocolIE_ID_id_SRBID:
11546                   break;
11547                case ProtocolIE_ID_id_RRCContainer:
11548                   {
11549                      rrcContainer =&f1DlRrcMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer;
11550                      free(rrcContainer->buf);
11551                   }
11552                case ProtocolIE_ID_id_ExecuteDuplication:
11553                   break;
11554                case ProtocolIE_ID_id_RRCDeliveryStatusRequest:
11555                   break;
11556                   break;
11557             }
11558             free(f1DlRrcMsg->protocolIEs.list.array[ieIdx]);
11559          }
11560       }
11561       free(f1DlRrcMsg->protocolIEs.list.array);
11562    }
11563 }
11564 /******************************************************************
11565  *
11566  * @brief Processes DL RRC Message Transfer  sent by CU
11567  *
11568  * @details
11569  *
11570  *    Function : procF1DlRrcMsgTrans
11571  *
11572  *    Functionality: Processes DL RRC Message Transfer sent by CU
11573  *
11574  * @params[in] F1AP_PDU_t ASN decoded F1AP message
11575  * @return ROK     - success
11576  *         RFAILED - failure
11577  *
11578  * ****************************************************************/
11579 uint8_t procF1DlRrcMsgTrans(F1AP_PDU_t *f1apMsg)
11580 {
11581    uint8_t  idx, ret;
11582    DLRRCMessageTransfer_t *f1DlRrcMsg = NULLP;
11583    F1DlRrcMsg dlMsg;
11584    memset(&dlMsg, 0, sizeof(F1DlRrcMsg));
11585
11586    DU_LOG("\nINFO   -->  DU_APP : DL RRC message transfer Recevied");
11587    f1DlRrcMsg = &f1apMsg->choice.initiatingMessage->value.choice.DLRRCMessageTransfer;
11588
11589    ret = ROK;
11590
11591    for(idx=0; idx<f1DlRrcMsg->protocolIEs.list.count; idx++)
11592    {
11593       switch(f1DlRrcMsg->protocolIEs.list.array[idx]->id)
11594       {
11595          case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
11596             {
11597                dlMsg.gnbCuUeF1apId = f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.GNB_CU_UE_F1AP_ID;
11598                break;
11599             }
11600          case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
11601             {
11602                dlMsg.gnbDuUeF1apId = f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID;
11603                break;
11604             }
11605          case ProtocolIE_ID_id_SRBID:
11606             {
11607                dlMsg.srbId = f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.SRBID;
11608                break;
11609             }
11610          case ProtocolIE_ID_id_ExecuteDuplication:
11611             dlMsg.execDup = true;
11612             break;
11613
11614          case ProtocolIE_ID_id_RRCContainer:
11615             {
11616                if(f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.size > 0)
11617                {
11618                   dlMsg.rrcMsgSize = f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.size;
11619                   DU_ALLOC(dlMsg.rrcMsgPdu, dlMsg.rrcMsgSize);
11620                   if(dlMsg.rrcMsgPdu)
11621                   {
11622                      memcpy(dlMsg.rrcMsgPdu, f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.buf,\
11623                         dlMsg.rrcMsgSize);
11624                   }
11625                   else
11626                   {
11627                      DU_LOG("\nERROR  -->  DU APP : Memory alloc Failed at RRC Container at procF1DlRrcMsgTrans()");
11628                      return RFAILED;
11629                   }
11630                }
11631                else
11632                {
11633                   DU_LOG("\nERROR  -->  DU_APP : RRC Container Size is invalid:%ld",\
11634                   f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.size);
11635                   return RFAILED;
11636                }
11637                break;
11638             }
11639          case ProtocolIE_ID_id_RRCDeliveryStatusRequest:
11640             {
11641                dlMsg.deliveryStatRpt = true;
11642                break;
11643             }
11644          default:
11645             DU_LOG("\nERROR  -->  DU_APP : Invalid IE received in DL RRC Msg Transfer:%ld",
11646                   f1DlRrcMsg->protocolIEs.list.array[idx]->id);
11647       }
11648    }
11649
11650    ret = duProcDlRrcMsg(&dlMsg);
11651
11652    freeAperDecodef1DlRrcMsg(f1DlRrcMsg);
11653    return ret;
11654 }
11655 /*******************************************************************
11656  *
11657 * @brief Builds the DRB to be Setup Mod list
11658 *
11659 * @details
11660 *
11661 *    Function :
11662 *
11663 *    Functionality: Constructs the DRB to be Setup Mod list
11664 *
11665 * @params[in] DRBs_SetupMod_List_t *drbSet
11666 *
11667 * @return ROK     - success
11668 *         RFAILED - failure
11669 *
11670 * ****************************************************************/
11671
11672 uint8_t BuildDrbSetupModList(DRBs_SetupMod_List_t *drbSet , DuUeCfg *ueCfg)
11673 {
11674    uint8_t arrIdx =0;
11675    uint8_t drbCnt =0;
11676    struct DRBs_SetupMod_ItemIEs *drbItemIe;
11677
11678    drbCnt = 1;
11679    drbSet->list.count = drbCnt;
11680    drbSet->list.size = drbCnt * sizeof(DRBs_SetupMod_ItemIEs_t *);
11681    DU_ALLOC(drbSet->list.array, drbSet->list.size);
11682    if(drbSet->list.array == NULLP)
11683    {
11684       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDrbToBeSetupModList");
11685       return  RFAILED;
11686    }
11687    for(arrIdx=0; arrIdx<drbCnt; arrIdx++)
11688    {
11689       DU_ALLOC(drbSet->list.array[arrIdx], sizeof(DRBs_SetupMod_ItemIEs_t));
11690       if(drbSet->list.array[arrIdx] == NULLP)
11691       {
11692               DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDrbToBeSetupModList");
11693               return  RFAILED;
11694       }
11695
11696       drbItemIe = (struct DRBs_SetupMod_ItemIEs *)drbSet->list.array[arrIdx];
11697       drbItemIe->id = ProtocolIE_ID_id_DRBs_SetupMod_Item;
11698       drbItemIe->criticality = Criticality_reject;
11699       drbItemIe->value.present = DRBs_SetupMod_ItemIEs__value_PR_DRBs_SetupMod_Item;
11700       drbItemIe->value.choice.DRBs_SetupMod_Item.dRBID = ueCfg->upTnlInfo[arrIdx].drbId;
11701       if(fillDlTnlSetupList(&drbItemIe->value.choice.DRBs_SetupMod_Item.dLUPTNLInformation_ToBeSetup_List,\
11702       &ueCfg->upTnlInfo[arrIdx])!= ROK)
11703       {
11704          DU_LOG("\nERROR  -->  F1AP : Failed to fill DlTnl SetupList in BuildDrbToBeSetupModList");
11705          return RFAILED;
11706       }
11707
11708    }
11709
11710    return ROK;
11711 }
11712 /*******************************************************************
11713 * @brief Free the memory allocated for DRB setup List
11714 *
11715 * @details
11716 *
11717 *    Function : FreeDrbSetupModList
11718 *
11719 *    Functionality:
11720 *       Free the memory allocated for DRB setup list
11721 *
11722 * @params[in] DRBs_Setup_List_t *
11723 * @return void
11724 *
11725 * ****************************************************************/
11726 void FreeDrbSetupModList(DRBs_SetupMod_List_t *drbSetupList)
11727 {
11728    uint8_t arrIdx = 0;
11729    DRBs_SetupMod_ItemIEs_t *drbItemIe = NULLP;
11730
11731    for(arrIdx = 0; arrIdx < drbSetupList->list.count; arrIdx++)
11732    {
11733       drbItemIe = ((DRBs_SetupMod_ItemIEs_t *)drbSetupList->list.array[arrIdx]);
11734       freeDlTnlInfo(&drbItemIe->value.choice.DRBs_SetupMod_Item.dLUPTNLInformation_ToBeSetup_List);
11735    }
11736 }
11737 /*******************************************************************
11738 * @brief Free the memory allocated for UE Context Mod Response
11739 *
11740 * @details
11741 *
11742 *    Function : FreeUeContextModResp
11743 *
11744 *    Functionality:
11745 *       Free the memory allocated for UE Context Mod Response
11746 *
11747 * @params[in] F1AP_PDU_t *f1apMsg
11748 * @return void
11749 *
11750 * ****************************************************************/
11751
11752 void FreeUeContextModResp(F1AP_PDU_t *f1apMsg)
11753 {
11754    uint8_t ieIdx;
11755    UEContextModificationResponse_t *ueContextModifyRes = NULLP;
11756    if(f1apMsg)
11757    {
11758       if(f1apMsg->choice.successfulOutcome)
11759       {
11760          ueContextModifyRes =&f1apMsg->choice.successfulOutcome->value.choice.UEContextModificationResponse;
11761          if(ueContextModifyRes->protocolIEs.list.array)
11762          {
11763             for(ieIdx=0 ; ieIdx<ueContextModifyRes->protocolIEs.list.count; ieIdx++)
11764             {
11765                if(ueContextModifyRes->protocolIEs.list.array[ieIdx])
11766                {
11767                   switch(ueContextModifyRes->protocolIEs.list.array[ieIdx]->id)
11768                   {
11769                      case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
11770                         break;
11771                      case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
11772                         break;
11773                      case ProtocolIE_ID_id_DRBs_SetupMod_List:
11774                         {
11775                             FreeDrbSetupModList(&(ueContextModifyRes->protocolIEs.list.array[ieIdx]->\
11776                             value.choice.DRBs_SetupMod_List));
11777                             break;
11778                         }
11779                   }
11780                   DU_FREE(ueContextModifyRes->protocolIEs.list.array[ieIdx], sizeof(UEContextModificationResponse_t));
11781                }
11782
11783             }
11784             DU_FREE(ueContextModifyRes->protocolIEs.list.array, ueContextModifyRes->protocolIEs.list.size);
11785          }
11786          DU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
11787       }
11788       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
11789    }
11790 }
11791
11792 /*****************************************************************i
11793 *
11794 * @brief Creating the ue context modifcation response and sending
11795 *
11796 * @details
11797 *
11798 *    Function : BuildAndSendUeContextModResp
11799 *
11800 *    Functionality:
11801 *         - Creating the ue context modifcation response
11802 *
11803 * @params[in]
11804 * @return ROK     - success
11805 *         RFAILED - failure
11806 *
11807 * ****************************************************************/
11808 uint8_t BuildAndSendUeContextModResp(uint8_t ueIdx, uint8_t cellId)
11809 {
11810    uint8_t   ieIdx = 0;
11811    uint8_t   cellIdx =0;
11812    uint8_t   elementCnt = 0;
11813    uint8_t   ret = RFAILED;
11814    uint32_t  gnbCuUeF1apId;   /* gNB-CU UE F1AP Id */
11815    uint32_t  gnbDuUeF1apId;   /* gNB-DU UE F1AP Id */
11816    F1AP_PDU_t *f1apMsg = NULLP;
11817    asn_enc_rval_t         encRetVal;
11818    UEContextModificationResponse_t *ueContextModifyRes = NULLP;
11819    DuUeCb                   *ueCb = NULLP;
11820
11821    DU_LOG("\nINFO  -->  F1AP : Building Ue context modification response\n");
11822
11823    while(1)
11824    {
11825       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
11826       if(f1apMsg == NULLP)
11827       {
11828          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed Ue context modification");
11829          break;
11830       }
11831
11832       f1apMsg->present =  F1AP_PDU_PR_successfulOutcome;
11833
11834       DU_ALLOC(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
11835       if(f1apMsg->choice.successfulOutcome == NULLP)
11836       {
11837          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed Ue context modification");
11838          break;
11839       }
11840       f1apMsg->choice.successfulOutcome->procedureCode = ProcedureCode_id_UEContextModification;
11841       f1apMsg->choice.successfulOutcome->criticality = Criticality_reject;
11842       f1apMsg->choice.successfulOutcome->value.present = SuccessfulOutcome__value_PR_UEContextModificationResponse;
11843
11844       ueContextModifyRes =&f1apMsg->choice.successfulOutcome->value.choice.UEContextModificationResponse;
11845
11846       elementCnt = 3;
11847       ueContextModifyRes->protocolIEs.list.count = elementCnt;
11848       ueContextModifyRes->protocolIEs.list.size = elementCnt*sizeof(UEContextModificationResponse_t*);
11849
11850       /* Initialize the UE context modification members */
11851       DU_ALLOC(ueContextModifyRes->protocolIEs.list.array, ueContextModifyRes->protocolIEs.list.size);
11852       if(ueContextModifyRes->protocolIEs.list.array == NULLP)
11853       {
11854          DU_LOG("\nERROR  -->  F1AP : Memory allocation for UE context modifcation Request failed");
11855          break;
11856       }
11857
11858       for(ieIdx=0 ; ieIdx<elementCnt; ieIdx++)
11859       {
11860          DU_ALLOC(ueContextModifyRes->protocolIEs.list.array[ieIdx], sizeof(UEContextModificationResponse_t));
11861          if(ueContextModifyRes->protocolIEs.list.array[ieIdx] == NULLP)
11862          {
11863             DU_LOG("\nERROR  -->  F1AP : Memory allocation for UE context modifcation Request failed");
11864             break;
11865          }
11866       }
11867
11868       /* Fetching Ue Cb Info*/
11869       GET_CELL_IDX(cellId, cellIdx);
11870       gnbDuUeF1apId = duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].gnbDuUeF1apId;
11871       gnbCuUeF1apId = duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].gnbCuUeF1apId;
11872       ueCb = &duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1];
11873
11874       ieIdx=0;
11875       ueContextModifyRes->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
11876       ueContextModifyRes->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
11877       ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.present =\
11878       UEContextModificationResponseIEs__value_PR_GNB_CU_UE_F1AP_ID;
11879       ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID = gnbCuUeF1apId;
11880
11881       ieIdx++;
11882       ueContextModifyRes->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
11883       ueContextModifyRes->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
11884       ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.present=\
11885       UEContextModificationResponseIEs__value_PR_GNB_DU_UE_F1AP_ID;
11886       ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID = gnbDuUeF1apId;
11887
11888       ieIdx++;
11889       ueContextModifyRes->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_DRBs_SetupMod_List;
11890       ueContextModifyRes->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
11891       ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.present =\
11892       UEContextModificationResponseIEs__value_PR_DRBs_SetupMod_List;
11893       if(ueCb->f1UeDb)
11894       {
11895          ret = BuildDrbSetupModList(&(ueContextModifyRes->protocolIEs.list.array[ieIdx]->\
11896                   value.choice.DRBs_SetupMod_List) , &ueCb->f1UeDb->duUeCfg);
11897          if(ret != ROK)
11898          {
11899             DU_LOG( "\nERROR  -->  F1AP : Failed to build drb setupmod List ");
11900             break;
11901          }
11902          freeF1UeDb(ueCb->f1UeDb);
11903          ueCb->f1UeDb = NULLP;
11904       }
11905       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
11906
11907       /* Encode the F1SetupRequest type as APER */
11908       memset(encBuf, 0, ENC_BUF_MAX_LEN);
11909       encBufSize = 0;
11910       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,encBuf);
11911
11912       /* Encode results */
11913       if(encRetVal.encoded == ENCODE_FAIL)
11914       {
11915          DU_LOG( "\nERROR  -->  F1AP : Could not encode UE Context Setup Request structure (at %s)\n",\
11916                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
11917          ret = RFAILED;
11918          break;
11919       }
11920       else
11921       {
11922          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for UE Context Modification Response\n");
11923          for(int i=0; i< encBufSize; i++)
11924          {
11925             printf("%x",encBuf[i]);
11926          }
11927       }
11928
11929       /* Sending  msg  */
11930       if(SendF1APMsg(DU_APP_MEM_REGION,DU_POOL) != ROK)
11931       {
11932          DU_LOG("\nERROR  -->  F1AP : Sending UE Context Setup Res Failed");
11933          ret = RFAILED;
11934          break;
11935       }
11936       break;
11937    }
11938    FreeUeContextModResp(f1apMsg);
11939    return ret;
11940
11941 }
11942 /*******************************************************************
11943  *
11944  * @brief Deallocating the memory allocated by the aper decoder
11945  *          for QOSInfo
11946  *
11947  * @details
11948  *
11949  *    Function : freeAperDecodeQosInfo
11950  *
11951  *    Functionality:  Deallocating the memory allocated for QOSInfo
11952  *
11953  * @params[in] QoSFlowLevelQoSParameters_t *drbQos
11954  *
11955  * @return void
11956  *
11957  * ****************************************************************/
11958
11959 void freeAperDecodeQosInfo(QoSFlowLevelQoSParameters_t *drbQos)
11960 {
11961    if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI != NULLP)
11962    {
11963       if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow!=NULLP)
11964       {
11965          if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume!=NULLP)
11966          {
11967             free(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume);
11968          }
11969          free(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow);
11970       }
11971       free(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI);
11972    }
11973 }
11974 /*******************************************************************
11975  *
11976  * @brief Deallocating the memory allocated by the aper decoder
11977  *          for UlTnlInfoforDrb
11978  *
11979  * @details
11980  *
11981  *    Function : freeAperDecodeUlTnlInfoforDrbSetupMod
11982  *
11983  *    Functionality:  Deallocating memory allocated for UlTnlInfoforDrb
11984  *
11985  * @params[in] ULUPTNLInformation_ToBeSetup_List_t *ulInfo
11986  *
11987  * @return void
11988  *
11989  * ****************************************************************/
11990 void freeAperDecodeUlTnlInfoforDrbSetupMod(ULUPTNLInformation_ToBeSetup_List_t *ulInfo)
11991 {
11992    uint8_t arrIdx =0;
11993
11994    if(ulInfo->list.array)
11995    {
11996       for(arrIdx=0; arrIdx<ulInfo->list.count ; arrIdx++)
11997       {
11998          if(ulInfo->list.array[arrIdx])
11999          {
12000             if(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel )
12001             {
12002                if(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf)
12003                {
12004                   if(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf)
12005                   {
12006                      free(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
12007                            gTP_TEID.buf);
12008                   }
12009                   free(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
12010                         transportLayerAddress.buf);
12011                }
12012                free(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel);
12013             }
12014             free(ulInfo->list.array[arrIdx]);
12015          }
12016       }
12017       free(ulInfo->list.array);
12018    }
12019 }
12020 /*******************************************************************
12021  *
12022  * @brief Deallocating the memory allocated by the aper decoder
12023  *          for DrbSetupModItem
12024  *
12025  * @details
12026  *
12027  *    Function : freeAperDecodeDrbSetupModItem
12028  *
12029  *    Functionality:  Deallocating memory allocated for DrbSetupModItem
12030  *
12031  * @params[in] DRBs_ToBeSetupMod_Item_t *drbItem
12032  *
12033  * @return void
12034  *
12035  * ****************************************************************/
12036
12037 void freeAperDecodeDrbSetupModItem(DRBs_ToBeSetupMod_Item_t *drbItem)
12038 {
12039    uint8_t arrIdx =0;
12040    SNSSAI_t *snssai =NULLP;
12041    Flows_Mapped_To_DRB_List_t *flowMap = NULLP;
12042
12043    drbItem->qoSInformation.present = QoSInformation_PR_choice_extension;
12044    switch(drbItem->qoSInformation.present)
12045    {
12046       case QoSInformation_PR_NOTHING:
12047          break;
12048       case QoSInformation_PR_eUTRANQoS:
12049          {
12050             if(drbItem->qoSInformation.choice.eUTRANQoS)
12051             {
12052                free(drbItem->qoSInformation.choice.eUTRANQoS);
12053             }
12054             break;
12055          }
12056       case QoSInformation_PR_choice_extension:
12057          {
12058             if(drbItem->qoSInformation.choice.choice_extension)
12059             {
12060                freeAperDecodeQosInfo(&drbItem->qoSInformation.choice.choice_extension->value.choice.\
12061                      DRB_Information.dRB_QoS);
12062                snssai = &drbItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI;
12063                if(snssai->sST.buf)
12064                {
12065                   free(snssai->sST.buf);
12066                }
12067                if(snssai->sD)
12068                {
12069                   if(snssai->sD->buf)
12070                   {
12071                      free(snssai->sD->buf);
12072                   }
12073                   free(snssai->sD);
12074                }
12075
12076                flowMap = &drbItem->qoSInformation.choice.choice_extension->value.choice.\
12077                          DRB_Information.flows_Mapped_To_DRB_List;
12078                if(flowMap->list.array)
12079                {
12080                   for(arrIdx=0; arrIdx<flowMap->list.count; arrIdx++)
12081                   {
12082                      if(flowMap->list.array[arrIdx] )
12083                      {
12084                         freeAperDecodeQosInfo(&flowMap->list.array[arrIdx]->qoSFlowLevelQoSParameters);
12085                         free(flowMap->list.array[arrIdx]);
12086                      }
12087                   }
12088                   free(flowMap->list.array);
12089                }
12090
12091                free(drbItem->qoSInformation.choice.choice_extension);
12092             }
12093             break;
12094          }
12095
12096    }
12097    freeAperDecodeUlTnlInfoforDrbSetupMod(&drbItem->uLUPTNLInformation_ToBeSetup_List);
12098    if(drbItem->uLConfiguration)
12099    {
12100       free(drbItem->uLConfiguration);
12101    }
12102 }
12103
12104 /*******************************************************************
12105  *
12106  * @brief Deallocating the memory allocated by the aper decoder
12107  *          for DrbToBeSetupModList
12108  *
12109  * @details
12110  *
12111  *    Function : freeAperDecodeDrbToBeSetupModList
12112  *
12113  *    Functionality:  Deallocating memory allocated for DrbToBeSetupModList
12114  *
12115  * @params[in] DRBs_ToBeSetupMod_List_t *drbSet
12116  *
12117  * @return void
12118  *
12119  * ****************************************************************/
12120
12121 void freeAperDecodeDrbToBeSetupModList(DRBs_ToBeSetupMod_List_t *drbSet)
12122 {
12123    uint8_t arrIdx =0;
12124    struct DRBs_ToBeSetupMod_ItemIEs *drbItemIe;
12125
12126    if(drbSet->list.array)
12127    {
12128       for(arrIdx=0; arrIdx<drbSet->list.count ; arrIdx++)
12129       {
12130          if(drbSet->list.array[arrIdx] != NULLP)
12131          {
12132             if(arrIdx == 0)
12133             {
12134                drbItemIe = (DRBs_ToBeSetupMod_ItemIEs_t *)drbSet->list.array[arrIdx];
12135                freeAperDecodeDrbSetupModItem(&(drbItemIe->value.choice.DRBs_ToBeSetupMod_Item));
12136             }
12137             free(drbSet->list.array[arrIdx]);
12138          }
12139       }
12140       free(drbSet->list.array);
12141    }
12142
12143 }
12144 /*******************************************************************
12145  *
12146  * @brief Deallocating the memory allocated by the aper decoder
12147  *          for UeContextModificationReqMsg
12148  *
12149  * @details
12150  *
12151  *    Function : freeAperDecodeUeContextModificationReqMsg
12152  *
12153  *    Functionality:  Deallocating memory allocated for
12154  *                  UeContextModificationReqMsg
12155  *
12156  * @params[in] UEContextModificationRequest_t *UeContextModifyReq
12157  *
12158  * @return void
12159  *
12160  * ****************************************************************/
12161 void freeAperDecodeUeContextModificationReqMsg(UEContextModificationRequest_t *UeContextModifyReq )
12162 {
12163    uint8_t arrIdx, ieId;
12164
12165    if(UeContextModifyReq->protocolIEs.list.array)
12166    {
12167       for( arrIdx = 0 ; arrIdx<UeContextModifyReq->protocolIEs.list.count ; arrIdx++)
12168       {
12169          if(UeContextModifyReq->protocolIEs.list.array[arrIdx])
12170          {
12171             ieId = UeContextModifyReq->protocolIEs.list.array[arrIdx]->id;
12172             switch(ieId)
12173             {
12174                case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
12175                   break;
12176                case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
12177                   break;
12178                case ProtocolIE_ID_id_DRBs_ToBeSetupMod_List:
12179                   {
12180                      freeAperDecodeDrbToBeSetupModList(&UeContextModifyReq->protocolIEs.list.array[arrIdx]->\
12181                            value.choice.DRBs_ToBeSetupMod_List);
12182                      break;
12183                   }
12184             }
12185             free(UeContextModifyReq->protocolIEs.list.array[arrIdx]);
12186          }
12187       }
12188       free(UeContextModifyReq->protocolIEs.list.array);
12189    }
12190 }
12191 /*******************************************************************
12192  *
12193  * @brief processing the F1 UeContextModificationReq
12194  *
12195  * @details
12196  *
12197  *    Function : procF1UeContextModificationReq
12198  *
12199  *    Functionality:  processing the F1 UeContextModificationReq
12200  *
12201  * @params[in] F1AP_PDU_t *f1apMsg
12202  *
12203  * @return
12204  * ****************************************************************/
12205 uint8_t procF1UeContextModificationReq(F1AP_PDU_t *f1apMsg)
12206 {
12207    UEContextModificationRequest_t *ueContextModifyReq = NULLP;
12208    uint8_t  ret = ROK, ieIdx = 0, lcId =0,cellIdx=0, ueIdx=0;
12209    DuUeCb   *duUeCb = NULLP;
12210    DRBs_ToBeSetupMod_List_t *drbSetupModCfg;
12211    uint32_t gnbCuUeF1apId, gnbDuUeF1apId;
12212
12213    ueContextModifyReq = &f1apMsg->choice.initiatingMessage->value.choice.UEContextModificationRequest;
12214    for(ieIdx=0; (ieIdx < ueContextModifyReq->protocolIEs.list.count && ret == ROK); ieIdx++)
12215    {
12216       switch(ueContextModifyReq->protocolIEs.list.array[ieIdx]->id)
12217       {
12218          case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
12219             {
12220                gnbCuUeF1apId = ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID;
12221                break;
12222             }
12223          case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
12224             {
12225                gnbDuUeF1apId = ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID;
12226                break;
12227             }
12228          case ProtocolIE_ID_id_DRBs_ToBeSetupMod_List:
12229             {
12230                for(cellIdx = 0; cellIdx < duCb.numActvCells; cellIdx++)
12231                {
12232                   for(ueIdx = 0; ueIdx < duCb.numUe; ueIdx++)
12233                   {
12234                      if((duCb.actvCellLst[cellIdx]->ueCb[ueIdx].gnbDuUeF1apId == gnbDuUeF1apId)&&\
12235                            (duCb.actvCellLst[cellIdx]->ueCb[ueIdx].gnbCuUeF1apId == gnbCuUeF1apId))
12236                      {
12237
12238                         duUeCb = &duCb.actvCellLst[cellIdx]->ueCb[ueIdx];
12239                         lcId = getDrbLcId(&duUeCb->drbBitMap);
12240                         if(lcId != RFAILED)
12241                         {
12242                            DU_ALLOC(duUeCb->f1UeDb, sizeof(F1UeContextSetupDb));
12243                            if(duUeCb->f1UeDb)
12244                            {
12245                               duUeCb->f1UeDb->actionType = UE_CTXT_MOD;
12246                               drbSetupModCfg = &ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.\
12247                               choice.DRBs_ToBeSetupMod_List;
12248                               if(extractDrbListToSetup(lcId, NULL, drbSetupModCfg ,drbSetupModCfg->list.count, \
12249                               &duUeCb->f1UeDb->duUeCfg))
12250                               {
12251                                  DU_LOG("\nERROR  -->  DU APP : Failed at extractDrbListToSetup()");
12252                                  ret = RFAILED;
12253                               }
12254                            }
12255                         }
12256                      }
12257                      else
12258                      {
12259                         DU_LOG("\nERROR  -->  DU APP : wrong values of gnbCuUeF1apId and gnbDuUeF1apId ");
12260                         ret = RFAILED;
12261                      }
12262                   }
12263                }
12264                break;
12265             }
12266       }
12267    }
12268    if(ret != RFAILED)
12269    {
12270       ret = duProcUeContextModReq(duUeCb);
12271    }
12272    freeAperDecodeUeContextModificationReqMsg(ueContextModifyReq);
12273    return ret;
12274 }
12275 /*****************************************************************i
12276  *
12277  * @brief Handles received F1AP message and sends back response
12278  *
12279  * @details
12280  *
12281  *    Function : F1APMsgHdlr
12282  *
12283  *    Functionality:
12284  *         - Decodes received F1AP control message
12285  *         - Prepares response message, encodes and sends to SCTP
12286  *
12287  * @params[in]
12288  * @return ROK     - success
12289  *         RFAILED - failure
12290  *
12291  * ****************************************************************/
12292 void F1APMsgHdlr(Buffer *mBuf)
12293 {
12294    int i =0;
12295    char *recvBuf =NULLP;
12296    MsgLen copyCnt =0;
12297    MsgLen recvBufLen =0;
12298    F1AP_PDU_t *f1apMsg =NULLP;
12299    asn_dec_rval_t rval; /* Decoder return value */
12300    F1AP_PDU_t f1apasnmsg ;
12301    DU_LOG("\nINFO  -->  F1AP : Received F1AP message buffer");
12302    ODU_PRINT_MSG(mBuf, 0,0);
12303
12304    /* Copy mBuf into char array to decode it */
12305    ODU_GET_MSG_LEN(mBuf, &recvBufLen);
12306    DU_ALLOC(recvBuf, (Size)recvBufLen);
12307
12308    if(recvBuf == NULLP)
12309    {
12310       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed");
12311       return;
12312    }
12313    if(ODU_COPY_MSG_TO_FIX_BUF(mBuf, 0, recvBufLen, (Data *)recvBuf, &copyCnt) != ROK)
12314    {
12315       DU_LOG("\nERROR   -->  F1AP : Failed while copying %d", copyCnt);
12316       return;
12317    }
12318
12319    printf("\nDEBUG   -->  F1AP : Received flat buffer to be decoded : ");
12320    for(i=0; i< recvBufLen; i++)
12321    {
12322       printf("%x",recvBuf[i]);
12323    }
12324
12325    /* Decoding flat buffer into F1AP messsage */
12326    f1apMsg = &f1apasnmsg;
12327    memset(f1apMsg, 0, sizeof(F1AP_PDU_t));
12328
12329    rval = aper_decode(0, &asn_DEF_F1AP_PDU, (void **)&f1apMsg, recvBuf, recvBufLen, 0, 0);
12330    DU_FREE(recvBuf, (Size)recvBufLen);
12331
12332    if(rval.code == RC_FAIL || rval.code == RC_WMORE)
12333    {
12334       DU_LOG("\nERROR  -->  F1AP : ASN decode failed");
12335       return;
12336    }
12337    printf("\n");
12338    xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
12339
12340    switch(f1apMsg->present)
12341    {
12342       case F1AP_PDU_PR_successfulOutcome:
12343          {
12344             switch(f1apMsg->choice.successfulOutcome->value.present)
12345             {
12346                case SuccessfulOutcome__value_PR_ResetAcknowledge:
12347                   {
12348                      DU_LOG("\nINFO   -->  F1AP : F1ResetAcknowledge is received successfully ");
12349                      break;
12350                   }
12351                case SuccessfulOutcome__value_PR_F1SetupResponse:
12352                   {
12353 #ifndef ODU_TEST_STUB
12354                      procF1SetupRsp(f1apMsg);
12355 #endif
12356                      break;
12357                   }
12358
12359                case SuccessfulOutcome__value_PR_GNBDUConfigurationUpdateAcknowledge:
12360                   {
12361                      procF1GNBDUCfgUpdAck(f1apMsg);
12362                      break;
12363                   }
12364
12365                default:
12366                   {
12367                      DU_LOG("\nERROR  -->  F1AP : Invalid type of SuccessfulOutcome__value_PR_ResetAcknowledge [%d]",\
12368                            f1apMsg->choice.successfulOutcome->value.present);
12369                      return;
12370                   }
12371             }/* End of switch(successfulOutcome) */
12372             free(f1apMsg->choice.successfulOutcome);
12373             break;
12374          }
12375       case F1AP_PDU_PR_initiatingMessage:
12376          {
12377             switch(f1apMsg->choice.initiatingMessage->value.present)
12378             {
12379                case InitiatingMessage__value_PR_Reset:
12380                   {
12381                      procF1ResetReq(f1apMsg);
12382                      break;
12383                   }
12384                case InitiatingMessage__value_PR_DLRRCMessageTransfer:
12385                   {
12386                      procF1DlRrcMsgTrans(f1apMsg);
12387                      break;
12388                   }
12389                case InitiatingMessage__value_PR_UEContextSetupRequest:
12390                   {
12391                      procF1UeContextSetupReq(f1apMsg);
12392                      break;
12393                   }
12394                case InitiatingMessage__value_PR_UEContextModificationRequest:
12395                   {
12396                      procF1UeContextModificationReq(f1apMsg);
12397                      break;
12398                   }
12399                default:
12400                   {
12401                      DU_LOG("\nERROR  -->  F1AP : Invalid type of F1AP_PDU_PR_initiatingMessage [%d]",
12402                            f1apMsg->choice.initiatingMessage->value.present);
12403                      return;
12404                   }
12405             }/* End of switch(initiatingMessage) */
12406             free(f1apMsg->choice.initiatingMessage);
12407             break;
12408          }
12409
12410       default:
12411          {
12412             DU_LOG("\nERROR  -->  F1AP : Invalid type of f1apMsg->present [%d]",f1apMsg->present);
12413             return;
12414          }
12415          free(f1apMsg);
12416
12417    }/* End of switch(f1apMsg->present) */
12418
12419 } /* End of F1APMsgHdlr */
12420
12421 /**********************************************************************
12422   End of file
12423  **********************************************************************/