src/du_app/du_f1ap_msg_hdl.c

   1 /*******************************************************************************
   2 ################################################################################
   3 #   Copyright (c) [2017-2019] [Radisys]                                        #
   4 #                                                                              #
   5 #   Licensed under the Apache License, Version 2.0 (the "License");            #
   6 #   you may not use this file except in compliance with the License.           #
   7 #   You may obtain a copy of the License at                                    #
   8 #                                                                              #
   9 #       http://www.apache.org/licenses/LICENSE-2.0                             #
  10 #                                                                              #
  11 #   Unless required by applicable law or agreed to in writing, software        #
  12 #   distributed under the License is distributed on an "AS IS" BASIS,          #
  13 #   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.   #
  14 #   See the License for the specific language governing permissions and        #
  15 #   limitations under the License.                                             #
  16 ################################################################################
  17 *******************************************************************************/
  18
  19 /* This file contains F1AP message handler functions */
  20 #include "common_def.h"
  21 #include "lrg.h"
  22 #include "legtp.h"
  23 #include "lkw.x"
  24 #include "lrg.x"
  25 #include "du_app_mac_inf.h"
  26 #include "du_cfg.h"
  27 #include "du_app_rlc_inf.h"
  28 #include "du_mgr_main.h"
  29 #include "du_utils.h"
  30 #include "RAT-Type.h"
  31 #include "FeatureSetUplinkPerCC.h"
  32 #include "FeatureSetDownlinkPerCC.h"
  33 #include "FeatureSets.h"
  34 #include "UE-NR-Capability.h"
  35 #include "UE-CapabilityRAT-Container.h"
  36 #include "UE-CapabilityRAT-ContainerListRRC.h"
  37 #include "GNB-DU-System-Information.h"
  38 #include "CellGroupConfigRrc.h"
  39 #include "MAC-CellGroupConfig.h"
  40 #include "SchedulingRequestConfig.h"
  41 #include "SchedulingRequestToAddMod.h"
  42 #include "BSR-Config.h"
  43 #include "TAG-Config.h"
  44 #include "TAG.h"
  45 #include "PHR-Config.h"
  46 #include "RLC-Config.h"
  47 #include "UL-AM-RLC.h"
  48 #include "DL-AM-RLC.h"
  49 #include "LogicalChannelConfig.h"
  50 #include "RLC-BearerConfig.h"
  51 #include "PhysicalCellGroupConfig.h"
  52 #include "SpCellConfig.h"
  53 #include "TDD-UL-DL-ConfigDedicated.h"
  54 #include "ServingCellConfig.h"
  55 #include "ControlResourceSet.h"
  56 #include "SearchSpace.h"
  57 #include "PDCCH-Config.h"
  58 #include "PDSCH-TimeDomainResourceAllocation.h"
  59 #include "PDSCH-TimeDomainResourceAllocationList.h"
  60 #include "PDSCH-CodeBlockGroupTransmission.h"
  61 #include "PDSCH-ServingCellConfig.h"
  62 #include "DMRS-DownlinkConfig.h"
  63 #include "PDSCH-Config.h"
  64 #include "BWP-DownlinkDedicated.h"
  65 #include "PUSCH-TimeDomainResourceAllocation.h"
  66 #include "PUSCH-TimeDomainResourceAllocationList.h"
  67 #include "DMRS-UplinkConfig.h"
  68 #include "PUSCH-Config.h"
  69 #include "SRS-ResourceId.h"
  70 #include "SRS-Resource.h"
  71 #include "SRS-ResourceSet.h"
  72 #include "SRS-Config.h"
  73 #include "BWP-UplinkDedicated.h"
  74 #include "PUSCH-ServingCellConfig.h"
  75 #include "UplinkConfig.h"
  76 #include "DUtoCURRCContainer.h"
  77 #include "GBR-QoSFlowInformation.h"
  78 #include "QoSFlowLevelQoSParameters.h"
  79 #include "PUCCH-Config.h"
  80 #include "PUCCH-ResourceSet.h"
  81 #include "PUCCH-Resource.h"
  82 #include "PUCCH-PowerControl.h"
  83 #include "P0-PUCCH.h"
  84 #include "PUCCH-PathlossReferenceRS.h"
  85 #include "PUCCH-format0.h"
  86 #include "PUCCH-format1.h"
  87 #include "PUCCH-format2.h"
  88 #include "PUCCH-format3.h"
  89 #include "PUCCH-format4.h"
  90 #include "PUCCH-FormatConfig.h"
  91 #include "SchedulingRequestResourceConfig.h"
  92 #include<ProtocolIE-Field.h>
  93 #include "ProtocolExtensionField.h"
  94 #include "F1AP-PDU.h"
  95 #include "odu_common_codec.h"
  96 #include "du_mgr.h"
  97 #include "du_cell_mgr.h"
  98 #include "du_f1ap_msg_hdl.h"
  99 #include "DRBs-Setup-Item.h"
 100 #include "DLUPTNLInformation-ToBeSetup-List.h"
 101 #include "DLUPTNLInformation-ToBeSetup-Item.h"
 102 #include "UPTransportLayerInformation.h"
 103 #include "GTPTunnel.h"
 104
 105 #ifdef O1_ENABLE
 106 #include "ConfigInterface.h"
 107 extern StartupConfig g_cfg;
 108 #endif
 109
 110 DuCfgParams duCfgParam;
 111
 112 /************************************************************************
 113  *
 114  * @brief Converts enum values into actual value of Poll retransmit timer
 115  *
 116  * @details
 117  *
 118  *    Function : getPollPdu
 119  *
 120  *    Functionality: Converts enum values into actual value of poll
 121  *    retransmit timer
 122  *
 123  * @params[in] Enum value of pollPdu
 124  * @return Actual value of pollPdu
 125  *
 126  * **********************************************************************/
 127
 128 uint16_t getPollRetxTmr(uint8_t pollRetxTmrCfg)
 129 {
 130    uint16_t pollRetxTmr;
 131
 132    /* All values of poll retx timer are at interval of 5ms.
 133     * This is valid upto 250ms
 134     * Hence converting the enum value to actual value by multiplying it to 5
 135     */
 136    if(pollRetxTmrCfg <= T_PollRetransmit_ms250)
 137       pollRetxTmr = (pollRetxTmrCfg + 1) * 5;
 138    else
 139    {
 140       switch(pollRetxTmrCfg)
 141       {
 142          case T_PollRetransmit_ms300:
 143             pollRetxTmr = 300;
 144             break;
 145          case T_PollRetransmit_ms350:
 146             pollRetxTmr = 350;
 147             break;
 148          case T_PollRetransmit_ms400:
 149             pollRetxTmr = 400;
 150             break;
 151          case T_PollRetransmit_ms450:
 152             pollRetxTmr = 450;
 153             break;
 154          case T_PollRetransmit_ms500:
 155             pollRetxTmr = 500;
 156             break;
 157          case T_PollRetransmit_ms800:
 158             pollRetxTmr = 800;
 159             break;
 160          default:
 161             DU_LOG("\nERROR  -->  F1AP: Invalid value of Poll Retransmit timer");
 162             pollRetxTmr = 0;
 163       }
 164    }
 165    return pollRetxTmr;
 166 }
 167
 168 /*******************************************************************
 169  *
 170  * @brief Converts enum values into actual value of PollPdu
 171  *
 172  * @details
 173  *
 174  *    Function : getPollPdu
 175  *
 176  *    Functionality: Converts enum values into actual value of PollPdu
 177  *
 178  * @params[in] Enum value of pollPdu
 179  * @return Actual value of pollPdu
 180  *
 181  * ****************************************************************/
 182 int32_t getPollPdu(uint8_t pollPduCfg)
 183 {
 184    int32_t pollPdu;
 185    switch(pollPduCfg)
 186    {
 187       case PollPDU_p4:
 188          pollPdu = 4;
 189          break;
 190       case PollPDU_p8:
 191          pollPdu = 8;
 192          break;
 193       case PollPDU_p16:
 194          pollPdu = 16;
 195          break;
 196       case PollPDU_p32:
 197          pollPdu = 32;
 198          break;
 199       case PollPDU_p64:
 200          pollPdu = 64;
 201          break;
 202       case PollPDU_p128:
 203          pollPdu = 128;
 204          break;
 205       case PollPDU_p256:
 206          pollPdu = 256;
 207          break;
 208       case PollPDU_p512:
 209          pollPdu = 512;
 210          break;
 211       case PollPDU_p1024:
 212          pollPdu = 1024;
 213          break;
 214       case PollPDU_p2048:
 215          pollPdu = 2048;
 216          break;
 217       case PollPDU_p4096:
 218          pollPdu = 4096;
 219          break;
 220       case PollPDU_p6144:
 221          pollPdu = 6144;
 222          break;
 223       case PollPDU_p8192:
 224          pollPdu = 8192;
 225          break;
 226       case PollPDU_p12288:
 227          pollPdu = 12288;
 228          break;
 229       case PollPDU_p16384:
 230          pollPdu = 16384;
 231          break;
 232       case PollPDU_p20480:
 233          pollPdu = 20480;
 234          break;
 235       case PollPDU_p24576:
 236          pollPdu = 24576;
 237          break;
 238       case PollPDU_p28672:
 239          pollPdu = 28672;
 240          break;
 241       case PollPDU_p32768:
 242          pollPdu = 32768;
 243          break;
 244       case PollPDU_p40960:
 245          pollPdu = 40960;
 246          break;
 247       case PollPDU_p49152:
 248          pollPdu = 49152;
 249          break;
 250       case PollPDU_p57344:
 251          pollPdu = 57344;
 252          break;
 253       case PollPDU_p65536:
 254          pollPdu = 65536;
 255          break;
 256       case PollPDU_infinity:
 257          pollPdu = -1;
 258          break;
 259       default:
 260          DU_LOG("\nERROR  -->  F1AP: Invalid value of poll pdu");
 261          pollPdu = 0;
 262          break;
 263    }
 264    return pollPdu;
 265 }
 266
 267 /*******************************************************************
 268  *
 269  * @brief Converts enum values into actual value of poll bytes
 270  *
 271  * @details
 272  *
 273  *    Function : getPollByte
 274  *
 275  *    Functionality: Converts enum values into actual value of pollBytes
 276  *
 277  * @params[in] Enum value
 278  * @return Actual value
 279  *
 280  * ****************************************************************/
 281 int32_t getPollByte(uint16_t pollBytesCfg)
 282 {
 283    int32_t pollBytes;
 284    switch(pollBytesCfg)
 285    {
 286       case PollByte_kB1:
 287          pollBytes = 1000;
 288          break;
 289       case PollByte_kB2:
 290          pollBytes = 2000;
 291          break;
 292       case PollByte_kB5:
 293          pollBytes = 5000;
 294          break;
 295       case PollByte_kB8:
 296          pollBytes = 8000;
 297          break;
 298       case PollByte_kB10:
 299          pollBytes = 10000;
 300          break;
 301       case PollByte_kB15:
 302          pollBytes = 15000;
 303          break;
 304       case PollByte_kB25:
 305          pollBytes = 25000;
 306          break;
 307       case PollByte_kB50:
 308          pollBytes = 50000;
 309          break;
 310       case PollByte_kB75:
 311          pollBytes = 75000;
 312          break;
 313       case PollByte_kB100:
 314          pollBytes = 100000;
 315          break;
 316       case PollByte_kB125:
 317          pollBytes = 125000;
 318          break;
 319       case PollByte_kB250:
 320          pollBytes = 250000;
 321          break;
 322       case PollByte_kB375:
 323          pollBytes = 375000;
 324          break;
 325       case PollByte_kB500:
 326          pollBytes = 500000;
 327          break;
 328       case PollByte_kB750:
 329          pollBytes = 750000;
 330          break;
 331       case PollByte_kB1000:
 332          pollBytes = 1000000;
 333          break;
 334       case PollByte_kB1250:
 335          pollBytes = 1250000;
 336          break;
 337       case PollByte_kB1500:
 338          pollBytes = 1500000;
 339          break;
 340       case PollByte_kB2000:
 341          pollBytes = 2000000;
 342          break;
 343       case PollByte_kB3000:
 344          pollBytes = 3000000;
 345          break;
 346       case PollByte_kB4000:
 347          pollBytes = 4000000;
 348          break;
 349       case PollByte_kB4500:
 350          pollBytes = 4500000;
 351          break;
 352       case PollByte_kB5000:
 353          pollBytes = 5000000;
 354          break;
 355       case PollByte_kB5500:
 356          pollBytes = 5500000;
 357          break;
 358       case PollByte_kB6000:
 359          pollBytes = 6000000;
 360          break;
 361       case PollByte_kB6500:
 362          pollBytes = 6500000;
 363          break;
 364       case PollByte_kB7000:
 365          pollBytes = 7000000;
 366          break;
 367       case PollByte_kB7500:
 368          pollBytes = 7500000;
 369          break;
 370       case PollByte_mB8:
 371          pollBytes = 8000000;
 372          break;
 373       case PollByte_mB9:
 374          pollBytes = 9000000;
 375          break;
 376       case PollByte_mB10:
 377          pollBytes = 10000000;
 378          break;
 379       case PollByte_mB11:
 380          pollBytes = 11000000;
 381          break;
 382       case PollByte_mB12:
 383          pollBytes = 12000000;
 384          break;
 385       case PollByte_mB13:
 386          pollBytes = 13000000;
 387          break;
 388       case PollByte_mB14:
 389          pollBytes = 14000000;
 390          break;
 391       case PollByte_mB15:
 392          pollBytes = 15000000;
 393          break;
 394       case PollByte_mB16:
 395          pollBytes = 16000000;
 396          break;
 397       case PollByte_mB17:
 398          pollBytes = 17000000;
 399          break;
 400       case PollByte_mB18:
 401          pollBytes = 18000000;
 402          break;
 403       case PollByte_mB20:
 404          pollBytes = 20000000;
 405          break;
 406       case PollByte_mB25:
 407          pollBytes = 25000000;
 408          break;
 409       case PollByte_mB30:
 410          pollBytes = 30000000;
 411          break;
 412       case PollByte_mB40:
 413          pollBytes = 40000000;
 414          break;
 415       case PollByte_infinity:
 416          pollBytes = -1;
 417          break;
 418       default:
 419          DU_LOG("\nERROR  -->  F1AP: Invalid value of poll bytes");
 420          pollBytes = 0;
 421    }
 422    return pollBytes;
 423 }
 424
 425 /*******************************************************************
 426  *
 427  * @brief Converts enum values into actual value of maxRetx
 428  *
 429  * @details
 430  *
 431  *    Function : getMaxRetx
 432  *
 433  *    Functionality: Converts enum values into actual value of maxRetx
 434  *
 435  * @params[in] Enum value
 436  * @return Actual value
 437  *
 438  * ****************************************************************/
 439 uint8_t getMaxRetx(uint8_t maxRetxCfg)
 440 {
 441    uint8_t maxRetx;
 442    switch(maxRetxCfg)
 443    {
 444       case UL_AM_RLC__maxRetxThreshold_t1:
 445          maxRetx = 1;
 446          break;
 447       case UL_AM_RLC__maxRetxThreshold_t2:
 448          maxRetx = 2;
 449          break;
 450       case UL_AM_RLC__maxRetxThreshold_t3:
 451          maxRetx = 3;
 452          break;
 453       case UL_AM_RLC__maxRetxThreshold_t4:
 454          maxRetx = 4;
 455          break;
 456       case UL_AM_RLC__maxRetxThreshold_t6:
 457          maxRetx = 6;
 458          break;
 459       case UL_AM_RLC__maxRetxThreshold_t8:
 460          maxRetx = 8;
 461          break;
 462       case UL_AM_RLC__maxRetxThreshold_t16:
 463          maxRetx = 16;
 464          break;
 465       case UL_AM_RLC__maxRetxThreshold_t32:
 466          maxRetx = 32;
 467          break;
 468       default:
 469          DU_LOG("\nERROR  -->  F1AP: Invalid configuration for Max retransmission threshold");
 470          maxRetx = 0;
 471    }
 472    return maxRetx;
 473 }
 474
 475 /*******************************************************************
 476  * @brief Converts enum values into actual value of reassembly timer
 477  *
 478  * @details
 479  *
 480  *    Function : getReAsmblTmr
 481  *
 482  *    Functionality: Converts enum values into actual value of reassembly
 483  *    timer
 484  *
 485  * @params[in] Enum value of reassembly timer
 486  * @return Actual value of reassembly timer
 487  *
 488  * **********************************************************************/
 489
 490 int8_t getReAsmblTmr(uint8_t reAsmblTmrCfg)
 491 {
 492    int8_t reAsmblTmr = 0;
 493
 494    if(reAsmblTmrCfg == T_Reassembly_ms0)
 495    {
 496       reAsmblTmr = 0;
 497    }
 498    else if(reAsmblTmrCfg >= T_Reassembly_ms5 || reAsmblTmrCfg <= T_Reassembly_ms100)
 499    {
 500      /* All values of re assembly timer are at interval of 5ms.
 501       * This is valid upto 100ms
 502       * Hence converting the enum value to actual value by multiplying it to 5
 503       */
 504       reAsmblTmr = reAsmblTmrCfg * 5;
 505    }
 506    else if(reAsmblTmrCfg >= T_Reassembly_ms110 || reAsmblTmrCfg <= T_Reassembly_ms200)
 507    {
 508      /* All values of re assembly timer are at interval of 10ms.
 509       * This is valid upto 200ms
 510       * since enum value starts from 20 for 100ms, subtracting 10 and
 511       * converting the enum value to actual value by multiplying it to 10
 512       */
 513       reAsmblTmr = ((reAsmblTmrCfg-10) * 10);
 514    }
 515    else
 516    {
 517       DU_LOG("\nERROR  -->  F1AP : Invalid value of Re Assembly timer %d", reAsmblTmrCfg);
 518       reAsmblTmr = -1;
 519    }
 520    return reAsmblTmr;
 521 }
 522
 523 /************************************************************************
 524  *
 525  * @brief Converts enum values into actual value of status prohibit timer
 526  *
 527  * @details
 528  *
 529  *    Function : getStatProhTmr
 530  *
 531  *    Functionality: Converts enum values into actual value of status prohibit
 532  *    timer
 533  *
 534  * @params[in] Enum value of status prohibit timer
 535  * @return Actual value of status prohibit timer
 536  *
 537  * **********************************************************************/
 538
 539 int16_t getStatProhTmr(uint8_t statProhTmrCfg)
 540 {
 541    int16_t statProhTmr =0;
 542
 543    if(statProhTmrCfg == T_StatusProhibit_ms0)
 544    {
 545       statProhTmr = 0;
 546    }
 547    else if(statProhTmrCfg >= T_StatusProhibit_ms5 || statProhTmrCfg <= T_StatusProhibit_ms250)
 548    {
 549       /* All values of re assembly timer are at interval of 5ms.
 550        * This is valid upto 250ms
 551        * Hence converting the enum value to actual value by multiplying it to 5
 552        */
 553       statProhTmr = statProhTmrCfg * 5;
 554    }
 555    else
 556    {
 557       switch(statProhTmrCfg)
 558       {
 559          case T_StatusProhibit_ms300:
 560             statProhTmr = 300;
 561             break;
 562          case T_StatusProhibit_ms350:
 563             statProhTmr = 350;
 564             break;
 565          case T_StatusProhibit_ms400:
 566             statProhTmr = 400;
 567             break;
 568          case T_StatusProhibit_ms450:
 569             statProhTmr = 450;
 570             break;
 571          case T_StatusProhibit_ms500:
 572             statProhTmr = 500;
 573             break;
 574          case T_StatusProhibit_ms800:
 575             statProhTmr = 800;
 576             break;
 577          case T_StatusProhibit_ms1000:
 578             statProhTmr = 1000;
 579             break;
 580          case T_StatusProhibit_ms1200:
 581             statProhTmr = 1200;
 582             break;
 583          case T_StatusProhibit_ms1600:
 584             statProhTmr = 1600;
 585             break;
 586          case T_StatusProhibit_ms2000:
 587             statProhTmr = 2000;
 588             break;
 589          case T_StatusProhibit_ms2400:
 590             statProhTmr = 2400;
 591             break;
 592          default:
 593             DU_LOG("\nInvalid value of Status Prohibit timer %d", statProhTmrCfg);
 594             statProhTmr = -1;
 595             break;
 596       }
 597    }
 598    return statProhTmr;
 599 }
 600
 601 /*******************************************************************
 602  *
 603  * @brief Builds Uplink Info for NR
 604  *
 605  * @details
 606  *
 607  *    Function : BuildULNRInfo
 608  *
 609  *    Functionality: Building NR Uplink Info
 610  *
 611  * @params[in] NRFreqInfo_t *ulnrfreq
 612  * @return ROK     - success
 613  *         RFAILED - failure
 614  *
 615  * ****************************************************************/
 616 uint8_t BuildULNRInfo(NRFreqInfo_t *ulnrfreq)
 617 {
 618    uint8_t idx=0;
 619    ulnrfreq->nRARFCN = duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.\
 620                        fdd.ulNrFreqInfo.nrArfcn;
 621    ulnrfreq->freqBandListNr.list.count = 1;
 622    ulnrfreq->freqBandListNr.list.size = sizeof(FreqBandNrItem_t *);
 623    DU_ALLOC(ulnrfreq->freqBandListNr.list.array,ulnrfreq->freqBandListNr.list.size);
 624    if(ulnrfreq->freqBandListNr.list.array == NULLP)
 625    {
 626       return RFAILED;
 627    }
 628    for(idx=0;idx<ulnrfreq->freqBandListNr.list.count;idx++)
 629    {
 630       DU_ALLOC(ulnrfreq->freqBandListNr.list.array[idx],sizeof(FreqBandNrItem_t));
 631       if(ulnrfreq->freqBandListNr.list.array[idx] == NULLP)
 632       {
 633          return RFAILED;
 634       }
 635    }
 636    ulnrfreq->freqBandListNr.list.array[0]->freqBandIndicatorNr = \
 637                                                                  duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.fdd.ulNrFreqInfo.\
 638                                                                  freqBand[0].nrFreqBand;
 639    ulnrfreq->freqBandListNr.list.array[0]->supportedSULBandList.list.count = SUL_BAND_COUNT;
 640    return ROK;
 641 }
 642 /*******************************************************************
 643  *
 644  * @brief Builds Downlink NR Info
 645  *
 646  * @details
 647  *
 648  *    Function : BuildDLNRInfo
 649  *
 650  *    Functionality: Building Downlink NR Info
 651  *
 652  * @params[in] NRFreqInfo_t *dlnrfreq
 653  * @return ROK     - success
 654  *         RFAILED - failure
 655  *
 656  * ****************************************************************/
 657 uint8_t BuildDLNRInfo(NRFreqInfo_t *dlnrfreq)
 658 {
 659    uint8_t idx=0;
 660    dlnrfreq->nRARFCN = duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.\
 661                        fdd.dlNrFreqInfo.nrArfcn;
 662    dlnrfreq->freqBandListNr.list.count = 1;
 663    dlnrfreq->freqBandListNr.list.size = sizeof(FreqBandNrItem_t *);
 664    DU_ALLOC(dlnrfreq->freqBandListNr.list.array,dlnrfreq->freqBandListNr.list.size);
 665    if(dlnrfreq->freqBandListNr.list.array == NULLP)
 666    {
 667       return RFAILED;
 668    }
 669    for(idx=0;idx< dlnrfreq->freqBandListNr.list.count;idx++)
 670    {
 671       DU_ALLOC(dlnrfreq->freqBandListNr.list.array[idx],sizeof(FreqBandNrItem_t));
 672       if(dlnrfreq->freqBandListNr.list.array[idx] == NULLP)
 673       {
 674          return RFAILED;
 675       }
 676    }
 677    dlnrfreq->freqBandListNr.list.array[0]->freqBandIndicatorNr = \
 678                                                                  duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.fdd.dlNrFreqInfo.\
 679                                                                  freqBand[0].nrFreqBand;
 680    dlnrfreq->freqBandListNr.list.array[0]->supportedSULBandList.list.count = SUL_BAND_COUNT;
 681
 682    return ROK;
 683 }
 684
 685 /*******************************************************************
 686  *
 687  * @brief Builds NRCell ID
 688  *
 689  * @details
 690  *
 691  *    Function : BuildNrCellId
 692  *
 693  *    Functionality: Building the NR Cell ID
 694  *
 695  * @params[in] BIT_STRING_t *nrcell
 696  * @return ROK     - success
 697  *         RFAILED - failure
 698  *
 699  * ****************************************************************/
 700
 701 S16 BuildNrCellId(BIT_STRING_t *nrcell)
 702 {
 703    memset(nrcell->buf, 0, nrcell->size);
 704    nrcell->buf[4]   = 16;
 705    nrcell->bits_unused = 4;
 706    return ROK;
 707 }
 708
 709 /*******************************************************************
 710  *
 711  * @brief Builds Nrcgi
 712  *
 713  * @details
 714  *
 715  *    Function : BuildNrcgi
 716  *
 717  *    Functionality: Building the PLMN ID and NR Cell id
 718  *
 719  * @params[in] NRCGI_t *nrcgi
 720  * @return ROK     - success
 721  *         RFAILED - failure
 722  *
 723  * ****************************************************************/
 724 uint8_t BuildNrcgi(NRCGI_t *nrcgi)
 725 {
 726    uint8_t ret;
 727    uint8_t byteSize = 5;
 728    /* Allocate Buffer Memory */
 729    nrcgi->pLMN_Identity.size = PLMN_SIZE * sizeof(uint8_t);
 730    DU_ALLOC(nrcgi->pLMN_Identity.buf, nrcgi->pLMN_Identity.size);
 731    if(nrcgi->pLMN_Identity.buf == NULLP)
 732    {
 733       return RFAILED;
 734    }
 735    ret = buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrCgi.plmn,\
 736          nrcgi->pLMN_Identity.buf); // Building PLMN function
 737    if(ret != ROK)
 738    {
 739       return RFAILED;
 740    }
 741    /*nrCellIdentity*/
 742    nrcgi->nRCellIdentity.size = byteSize * sizeof(uint8_t);
 743    DU_ALLOC(nrcgi->nRCellIdentity.buf, nrcgi->nRCellIdentity.size);
 744    if(nrcgi->nRCellIdentity.buf == NULLP)
 745    {
 746       return RFAILED;
 747    }
 748    BuildNrCellId(&nrcgi->nRCellIdentity);
 749
 750    return ROK;
 751 }
 752 /*******************************************************************
 753  *
 754  * @brief Builds FiveGStac
 755  *
 756  * @details
 757  *
 758  *    Function : BuildFiveGSTac
 759  *
 760  *    Functionality: Building the FiveGSTac
 761  *
 762  * @params[in] OCTET_STRING_t *fivegsTac
 763  * @return ROK     - success
 764  *         RFAILED - failure
 765  *
 766  * ****************************************************************/
 767 uint8_t BuildFiveGSTac(Served_Cell_Information_t *servcell)
 768 {
 769    DU_ALLOC(servcell->fiveGS_TAC,sizeof(FiveGS_TAC_t));
 770    if(servcell->fiveGS_TAC == NULLP)
 771    {
 772       return RFAILED;
 773    }
 774    servcell->fiveGS_TAC->size = 3 * sizeof(uint8_t);
 775    DU_ALLOC(servcell->fiveGS_TAC->buf,\
 776          sizeof(servcell->fiveGS_TAC->size));
 777    if(servcell->fiveGS_TAC->buf == NULLP)
 778    {
 779       return RFAILED;
 780    }
 781    servcell->fiveGS_TAC->buf[0] = 0;
 782    servcell->fiveGS_TAC->buf[1] = 0;
 783    servcell->fiveGS_TAC->buf[2] = duCfgParam.srvdCellLst[0].duCellInfo.tac;
 784    return ROK;
 785 }
 786 /*******************************************************************
 787  *
 788  * @brief Builds NR Mode
 789  *
 790  * @details
 791  *
 792  *    Function : BuildNrMode
 793  *
 794  *    Functionality: Building the NR Mode
 795  *
 796  * @params[in] NR_Mode_Info_t *fdd
 797  * @return ROK     - success
 798  *         RFAILED - failure
 799  *
 800  * ****************************************************************/
 801 uint8_t BuildNrMode(NR_Mode_Info_t *mode)
 802 {
 803    uint8_t BuildDLNRInforet=0;
 804    uint8_t BuildULNRInforet=0;
 805    /* FDD Mode */
 806    mode->present = NR_Mode_Info_PR_fDD;
 807    if(mode->present == NR_Mode_Info_PR_fDD)
 808    {
 809       DU_ALLOC(mode->choice.fDD,sizeof(FDD_Info_t));
 810       if(mode->choice.fDD == NULLP)
 811       {
 812          return RFAILED;
 813       }
 814       BuildULNRInforet = BuildULNRInfo(&mode->choice.fDD->uL_NRFreqInfo);
 815       if(BuildULNRInforet != ROK)
 816       {
 817          return RFAILED;
 818       }
 819       BuildDLNRInforet = BuildDLNRInfo(&mode->choice.fDD->dL_NRFreqInfo);
 820       if(BuildDLNRInforet != ROK)
 821       {
 822          return RFAILED;
 823       }
 824    }
 825    mode->choice.fDD->uL_Transmission_Bandwidth.nRSCS = \
 826                                                        duCfgParam.srvdCellLst[0].duCellInfo.\
 827                                                        f1Mode.mode.fdd.ulTxBw.nrScs;
 828    mode->choice.fDD->uL_Transmission_Bandwidth.nRNRB = \
 829                                                        duCfgParam.srvdCellLst[0].duCellInfo.\
 830                                                        f1Mode.mode.fdd.ulTxBw.nrb;
 831    mode->choice.fDD->dL_Transmission_Bandwidth.nRSCS = \
 832                                                        duCfgParam.srvdCellLst[0].duCellInfo.\
 833                                                        f1Mode.mode.fdd.dlTxBw.nrScs;
 834    mode->choice.fDD->dL_Transmission_Bandwidth.nRNRB = \
 835                                                        duCfgParam.srvdCellLst[0].duCellInfo.\
 836                                                        f1Mode.mode.fdd.dlTxBw.nrb;
 837    return ROK;
 838 }
 839 /*******************************************************************
 840  *
 841  * @brief Builds IE Extensions for Served PLMNs
 842  *
 843  * @details
 844  *
 845  *    Function : BuildExtensions
 846  *
 847  *    Functionality: Building the IE Extensions
 848  *
 849  * @params[in] struct ProtocolExtensionContainer_4624P3 *buildextend
 850  * @return ROK     - success
 851  *         RFAILED - failure
 852  *
 853  * ****************************************************************/
 854 uint8_t BuildExtensions(ProtocolExtensionContainer_4624P3_t **ieExtend)
 855 {
 856    uint8_t idx;
 857    uint8_t plmnidx;
 858    uint8_t extensionCnt=1;
 859    uint8_t sliceId=0;
 860    uint8_t sdId;
 861    DU_ALLOC(*ieExtend,sizeof(ProtocolExtensionContainer_4624P3_t));
 862    if((*ieExtend) == NULLP)
 863    {
 864       return RFAILED;
 865    }
 866    (*ieExtend)->list.count = extensionCnt;
 867    (*ieExtend)->list.size = \
 868                             extensionCnt * sizeof(ServedPLMNs_ItemExtIEs_t *);
 869    DU_ALLOC((*ieExtend)->list.array,(*ieExtend)->list.size);
 870    if((*ieExtend)->list.array == NULLP)
 871    {
 872       return RFAILED;
 873    }
 874    for(plmnidx=0;plmnidx<extensionCnt;plmnidx++)
 875    {
 876       DU_ALLOC((*ieExtend)->list.array[plmnidx],\
 877             sizeof(ServedPLMNs_ItemExtIEs_t));
 878       if((*ieExtend)->list.array[plmnidx] == NULLP)
 879       {
 880          return RFAILED;
 881       }
 882    }
 883    idx = 0;
 884    (*ieExtend)->list.array[idx]->id = ProtocolIE_ID_id_TAISliceSupportList;
 885    (*ieExtend)->list.array[idx]->criticality = Criticality_ignore;
 886    (*ieExtend)->list.array[idx]->extensionValue.present = \
 887                                                           ServedPLMNs_ItemExtIEs__extensionValue_PR_SliceSupportList;
 888    (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 889       list.count = 1;
 890    (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 891       list.size = sizeof(SliceSupportItem_t *);
 892    DU_ALLOC((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 893          list.array,sizeof(SliceSupportItem_t *));
 894    if((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 895          list.array == NULLP)
 896    {
 897       return RFAILED;
 898    }
 899    DU_ALLOC((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 900          list.array[sliceId],sizeof(SliceSupportItem_t));
 901    if((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 902          list.array[sliceId] == NULLP)
 903    {
 904       return RFAILED;
 905    }
 906    (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 907       list.array[sliceId]->sNSSAI.sST.size = sizeof(uint8_t);
 908    DU_ALLOC((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList\
 909          .list.array[sliceId]->sNSSAI.sST.buf,(*ieExtend)->list.array[idx]->\
 910          extensionValue.choice.SliceSupportList.\
 911          list.array[sliceId]->sNSSAI.sST.size);
 912    if((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList\
 913          .list.array[sliceId]->sNSSAI.sST.buf == NULLP)
 914    {
 915       return RFAILED;
 916    }
 917    (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 918       list.array[sliceId]->sNSSAI.sST.buf[0] = 3;
 919    DU_ALLOC((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 920          list.array[sliceId]->sNSSAI.sD,sizeof(OCTET_STRING_t));
 921    if((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 922          list.array[sliceId]->sNSSAI.sD == NULLP)
 923    {
 924       return RFAILED;
 925    }
 926    (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 927       list.array[sliceId]->sNSSAI.sD->size = 3*sizeof(uint8_t);
 928    DU_ALLOC((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 929          list.array[sliceId]->sNSSAI.sD->buf,(*ieExtend)->list.array[idx]->extensionValue.choice.\
 930          SliceSupportList.list.array[sliceId]->sNSSAI.sD->size);
 931    if((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 932          list.array[sliceId]->sNSSAI.sD->buf == NULLP)
 933    {
 934       return RFAILED;
 935    }
 936    sdId = 0;
 937    (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 938       list.array[sliceId]->sNSSAI.sD->buf[sdId] = 3;
 939    sdId++;
 940    (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 941       list.array[sliceId]->sNSSAI.sD->buf[sdId] = 6;
 942    sdId++;
 943    (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 944       list.array[sliceId]->sNSSAI.sD->buf[sdId] = 9;
 945    return ROK;
 946 }
 947 /*******************************************************************
 948  *
 949  * @brief Builds Served PLMN
 950  *
 951  * @details
 952  *
 953  *    Function : BuildServedPlmn
 954  *
 955  *    Functionality: Building the Served PLMN
 956  *
 957  * @params[in] GNB_DU_Served_Cells_Item_t *srvCellItem
 958  * @return ROK     - success
 959  *         RFAILED - failure
 960  *
 961  * ****************************************************************/
 962 uint8_t  BuildServedPlmn(ServedPLMNs_List_t *srvplmn)
 963 {
 964    uint8_t  plmnidx;
 965    uint8_t  servPlmnCnt=1;
 966    uint8_t buildPlmnIdret=0;
 967    uint8_t BuildExtensionsret=0;
 968    srvplmn->list.count = servPlmnCnt;
 969    srvplmn->list.size = \
 970                         servPlmnCnt*sizeof(ServedPLMNs_Item_t *);
 971    DU_ALLOC(srvplmn->list.array,srvplmn->list.size);
 972    if(srvplmn->list.array == NULLP)
 973    {
 974       return RFAILED;
 975    }
 976    for(plmnidx=0; plmnidx<servPlmnCnt; plmnidx++)
 977    {
 978       DU_ALLOC(srvplmn->list.array[plmnidx],\
 979             sizeof(ServedPLMNs_Item_t));
 980       if(srvplmn->list.array[plmnidx] == NULLP)
 981       {
 982          return RFAILED;
 983       }
 984    }
 985    srvplmn->list.array[0]->pLMN_Identity.size = PLMN_SIZE * sizeof(uint8_t);
 986    DU_ALLOC(srvplmn->list.array[0]->pLMN_Identity.buf, srvplmn->list.array[0]->pLMN_Identity.size);
 987    buildPlmnIdret = buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrCgi.plmn,\
 988          srvplmn->list.array[0]->pLMN_Identity.buf);
 989    if(buildPlmnIdret!= ROK)
 990    {
 991       return RFAILED;
 992    }
 993    BuildExtensionsret = BuildExtensions(&srvplmn->list.array[0]->iE_Extensions);
 994    if(BuildExtensionsret!= ROK)
 995    {
 996       return RFAILED;
 997    }
 998    return ROK;
 999 }
1000 /*******************************************************************
1001  *
1002  * @brief Builds Served Cell List
1003  *
1004  * @details
1005  *
1006  *    Function : BuildServedCellList
1007  *
1008  *    Functionality: Building Served Cell List
1009  *
1010  * @params[in] PLMNID plmn
1011  * @return ROK     - success
1012  *         RFAILED - failure
1013  *
1014  * ****************************************************************/
1015
1016 uint8_t BuildServedCellList(GNB_DU_Served_Cells_List_t *duServedCell)
1017 {
1018    uint8_t  BuildNrcgiret=0;
1019    uint8_t  BuildFiveGSTacret=0;
1020    uint8_t  BuildServedPlmnret=0;
1021    uint8_t  BuildNrModeret=0;
1022    uint8_t  idx;
1023    uint8_t  plmnidx;
1024    uint8_t  plmnCnt=1;
1025    GNB_DU_Served_Cells_Item_t *srvCellItem;
1026    duServedCell->list.size = plmnCnt * sizeof(GNB_DU_Served_Cells_ItemIEs_t *);
1027    duServedCell->list.count = plmnCnt;
1028
1029    DU_ALLOC(duServedCell->list.array, duServedCell->list.size);
1030    if(duServedCell->list.array == NULLP)
1031    {
1032       return RFAILED;
1033    }
1034    for(plmnidx=0; plmnidx<plmnCnt; plmnidx++)
1035    {
1036       DU_ALLOC(duServedCell->list.array[plmnidx],\
1037             sizeof(GNB_DU_Served_Cells_ItemIEs_t));
1038       if(duServedCell->list.array[plmnidx] == NULLP)
1039       {
1040          return RFAILED;
1041       }
1042    }
1043    idx = 0;
1044    duServedCell->list.array[idx]->id = ProtocolIE_ID_id_GNB_DU_Served_Cells_Item;
1045    duServedCell->list.array[idx]->criticality = Criticality_reject;
1046    duServedCell->list.array[idx]->value.present = \
1047                                                   GNB_DU_Served_Cells_ItemIEs__value_PR_GNB_DU_Served_Cells_Item;
1048    srvCellItem = \
1049                  &duServedCell->list.array[idx]->value.choice.GNB_DU_Served_Cells_Item;
1050    /*nRCGI*/
1051    BuildNrcgiret = BuildNrcgi(&srvCellItem->served_Cell_Information.nRCGI);
1052    if(BuildNrcgiret != ROK)
1053    {
1054       return RFAILED;
1055    }
1056    /*nRPCI*/
1057    srvCellItem->served_Cell_Information.nRPCI = \
1058                                                 duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrPci;
1059
1060    /*fiveGS_TAC*/
1061    BuildFiveGSTacret = BuildFiveGSTac(&srvCellItem->served_Cell_Information);
1062    if(BuildFiveGSTacret != ROK)
1063    {
1064       return RFAILED;
1065    }
1066    /*Served PLMNs*/
1067    BuildServedPlmnret = BuildServedPlmn(&srvCellItem->served_Cell_Information.servedPLMNs);
1068    if(BuildServedPlmnret !=ROK)
1069    {
1070       return RFAILED;
1071    }
1072    /*nR Mode Info with FDD*/
1073    BuildNrModeret = BuildNrMode(&srvCellItem->served_Cell_Information.nR_Mode_Info);
1074    if(BuildNrModeret != ROK)
1075    {
1076       return RFAILED;
1077    }
1078    /*Measurement timing Config*/
1079    srvCellItem->served_Cell_Information.measurementTimingConfiguration.\
1080       size = sizeof(uint8_t);
1081    DU_ALLOC(srvCellItem->served_Cell_Information.\
1082          measurementTimingConfiguration.buf,srvCellItem->served_Cell_Information.measurementTimingConfiguration.size);
1083    if(srvCellItem->served_Cell_Information.\
1084          measurementTimingConfiguration.buf == NULLP)
1085    {
1086       return RFAILED;
1087    }
1088    srvCellItem->served_Cell_Information.measurementTimingConfiguration.buf[0] = \
1089                                                                                 duCfgParam.srvdCellLst[0].duCellInfo.measTimeCfg;
1090
1091    /* GNB DU System Information */
1092    DU_ALLOC(srvCellItem->gNB_DU_System_Information,
1093          sizeof(GNB_DU_System_Information_t));
1094    if(!srvCellItem->gNB_DU_System_Information)
1095    {
1096       return RFAILED;
1097    }
1098    /* MIB */
1099    srvCellItem->gNB_DU_System_Information->mIB_message.size = duCfgParam.srvdCellLst[0].duSysInfo.mibLen;
1100    DU_ALLOC(srvCellItem->gNB_DU_System_Information->mIB_message.buf,
1101          srvCellItem->gNB_DU_System_Information->mIB_message.size);
1102    if(!srvCellItem->gNB_DU_System_Information->mIB_message.buf)
1103    {
1104       return RFAILED;
1105    }
1106    memcpy(srvCellItem->gNB_DU_System_Information->mIB_message.buf, duCfgParam.srvdCellLst[0].duSysInfo.mibMsg, \
1107                    srvCellItem->gNB_DU_System_Information->mIB_message.size);
1108
1109    /* SIB1 */
1110    srvCellItem->gNB_DU_System_Information->sIB1_message.size =\
1111                                                               duCfgParam.srvdCellLst[0].duSysInfo.sib1Len;
1112
1113    DU_ALLOC(srvCellItem->gNB_DU_System_Information->sIB1_message.buf,
1114          srvCellItem->gNB_DU_System_Information->sIB1_message.size);
1115    if(!srvCellItem->gNB_DU_System_Information->sIB1_message.buf)
1116    {
1117       return RFAILED;
1118    }
1119    for(int x=0; x<srvCellItem->gNB_DU_System_Information->sIB1_message.size; x++)
1120    {
1121       srvCellItem->gNB_DU_System_Information->sIB1_message.buf[x]=\
1122                                                                   duCfgParam.srvdCellLst[0].duSysInfo.sib1Msg[x];
1123    }
1124    return ROK;
1125 }
1126 /*******************************************************************
1127  *
1128  * @brief Builds RRC Version
1129  *
1130  * @details
1131  *
1132  *    Function : BuildRrcVer
1133  *
1134  *    Functionality: Building RRC Version
1135  *
1136  * @params[in] int idx,int elementCnt,RRC_Version_t *rrcver
1137  * @return ROK     - success
1138  *         RFAILED - failure
1139  *
1140  * ****************************************************************/
1141 uint8_t BuildRrcVer(RRC_Version_t *rrcVer)
1142 {
1143    uint8_t rrcExt;
1144    uint8_t rrcLatest;
1145    rrcVer->latest_RRC_Version.size = sizeof(uint8_t);
1146    DU_ALLOC(rrcVer->latest_RRC_Version.buf,sizeof(uint8_t));
1147    if(rrcVer->latest_RRC_Version.buf == NULLP)
1148    {
1149       return RFAILED;
1150    }
1151    rrcVer->latest_RRC_Version.buf[0] = 0;
1152    rrcVer->latest_RRC_Version.bits_unused = 5;
1153    DU_ALLOC(rrcVer->iE_Extensions,sizeof(ProtocolExtensionContainer_4624P81_t));
1154    if(rrcVer->iE_Extensions == NULLP)
1155    {
1156       return RFAILED;
1157    }
1158    rrcVer->iE_Extensions->list.count = 1;
1159    rrcVer->iE_Extensions->list.size = sizeof(RRC_Version_ExtIEs_t *);
1160    DU_ALLOC(rrcVer->iE_Extensions->list.array,rrcVer->iE_Extensions->list.size);
1161    if(rrcVer->iE_Extensions->list.array == NULLP)
1162    {
1163       return RFAILED;
1164    }
1165    rrcExt = 0;
1166    DU_ALLOC(rrcVer->iE_Extensions->list.array[0],\
1167          sizeof(RRC_Version_ExtIEs_t));
1168    if(rrcVer->iE_Extensions->list.array[0] == NULLP)
1169    {
1170       return RFAILED;
1171    }
1172    rrcVer->iE_Extensions->list.array[rrcExt]->id = \
1173                                                    ProtocolIE_ID_id_latest_RRC_Version_Enhanced;
1174    rrcVer->iE_Extensions->list.array[rrcExt]->criticality = Criticality_reject;
1175    rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.present =\
1176                                                                       RRC_Version_ExtIEs__extensionValue_PR_Latest_RRC_Version_Enhanced;
1177    rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.choice\
1178       .Latest_RRC_Version_Enhanced.size = 3*sizeof(uint8_t);
1179    DU_ALLOC(rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.choice\
1180          .Latest_RRC_Version_Enhanced.buf,rrcVer->iE_Extensions->list.\
1181          array[rrcExt]->extensionValue.choice.Latest_RRC_Version_Enhanced.size);
1182    if(rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.choice\
1183          .Latest_RRC_Version_Enhanced.buf == NULLP)
1184    {
1185       return RFAILED;
1186    }
1187    rrcLatest = 0;
1188    rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.choice.\
1189       Latest_RRC_Version_Enhanced.buf[rrcLatest] = 15;
1190    rrcLatest++;
1191    rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.choice.\
1192       Latest_RRC_Version_Enhanced.buf[rrcLatest] = 5;
1193    rrcLatest++;
1194    rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.choice.\
1195       Latest_RRC_Version_Enhanced.buf[rrcLatest] = 0;
1196    return ROK;
1197 }
1198 /*******************************************************************
1199  *
1200  * @brief Sends F1 msg over SCTP
1201  *
1202  * @details
1203  *
1204  *    Function : SendF1APMsg
1205  *
1206  *    Functionality: Sends F1 msg over SCTP
1207  *
1208  * @params[in] Region region
1209  *             Pool pool
1210  * @return ROK     - success
1211  *         RFAILED - failure
1212  *
1213  * ****************************************************************/
1214 uint8_t SendF1APMsg(Region region, Pool pool)
1215 {
1216    Buffer *mBuf = NULLP;
1217
1218    if(ODU_GET_MSG_BUF(region, pool, &mBuf) == ROK)
1219    {
1220       if(ODU_ADD_POST_MSG_MULT((Data *)encBuf, encBufSize, mBuf) == ROK)
1221       {
1222             ODU_PRINT_MSG(mBuf, 0,0);
1223
1224             if(sctpSend(mBuf, F1_INTERFACE) != ROK)
1225             {
1226                DU_LOG("\nERROR  -->  F1AP : SCTP Send failed");
1227                ODU_PUT_MSG_BUF(mBuf);
1228                return RFAILED;
1229             }
1230       }
1231       else
1232       {
1233          DU_LOG("\nERROR  -->  F1AP : ODU_ADD_POST_MSG_MULT failed");
1234          ODU_PUT_MSG_BUF(mBuf);
1235          return RFAILED;
1236       }
1237       ODU_PUT_MSG_BUF(mBuf);
1238    }
1239    else
1240    {
1241       DU_LOG("\nERROR  -->  F1AP : Failed to allocate memory");
1242       return RFAILED;
1243    }
1244    return ROK;
1245 } /* SendF1APMsg */
1246
1247 /*******************************************************************
1248  *
1249  * @brief  deallocating the memory of function BuildAndSendF1SetupReq()
1250  *
1251  * @details
1252  *
1253  *    Function :  FreeRrcVer
1254  *
1255  *    Functionality: deallocating the memory of function BuildRrcVer
1256  *
1257  * @params[in] RRC_Version_t *rrcVer
1258  *
1259  * @return void
1260  *
1261  *****************************************************************/
1262 void FreeRrcVer(RRC_Version_t *rrcVer)
1263 {
1264    if(rrcVer->latest_RRC_Version.buf != NULLP)
1265    {
1266       if(rrcVer->iE_Extensions != NULLP)
1267       {
1268          if(rrcVer->iE_Extensions->list.array != NULLP)
1269          {
1270             if(rrcVer->iE_Extensions->list.array[0] != NULLP)
1271             {
1272                if(rrcVer->iE_Extensions->list.array[0]->extensionValue.choice.Latest_RRC_Version_Enhanced.buf
1273                      != NULLP)
1274                {
1275                   DU_FREE(rrcVer->iE_Extensions->list.array[0]->extensionValue.choice\
1276                         .Latest_RRC_Version_Enhanced.buf,rrcVer->iE_Extensions->list.\
1277                         array[0]->extensionValue.choice.Latest_RRC_Version_Enhanced.size);
1278                }
1279                DU_FREE(rrcVer->iE_Extensions->list.array[0],sizeof(RRC_Version_ExtIEs_t));
1280             }
1281             DU_FREE(rrcVer->iE_Extensions->list.array,sizeof(RRC_Version_ExtIEs_t*));
1282          }
1283          DU_FREE(rrcVer->iE_Extensions,sizeof(ProtocolExtensionContainer_4624P81_t));
1284       }
1285       DU_FREE(rrcVer->latest_RRC_Version.buf,rrcVer->latest_RRC_Version.size);
1286    }
1287 }
1288 /*******************************************************************
1289  *
1290  * @brief  deallocating the memory of function BuildAndSendF1SetupReq()
1291  *
1292  * @details
1293  *
1294  *    Function :  FreeServedCellList
1295  *
1296  *    Functionality:  deallocating the memory of function BuildServedCellList
1297
1298  *
1299  * @params[in] GNB_DU_Served_Cells_List_t *duServedCell
1300  *
1301  * @return void
1302  *
1303  * ****************************************************************/
1304 void FreeServedCellList( GNB_DU_Served_Cells_List_t *duServedCell)
1305 {
1306    uint8_t   plmnCnt=1;
1307    uint8_t  servId=0;
1308    uint8_t sliceId=0;
1309    uint8_t  ieId=0;
1310    uint8_t   extensionCnt=1;
1311    uint8_t plmnidx=0;
1312    GNB_DU_Served_Cells_Item_t *srvCellItem= &duServedCell->list.array[0]->value.choice.GNB_DU_Served_Cells_Item;
1313    if(duServedCell->list.array!=NULLP)
1314    {
1315       if(duServedCell->list.array[0]!=NULLP)
1316       {
1317          if(srvCellItem->served_Cell_Information.nRCGI.pLMN_Identity.buf!=NULLP)
1318          {
1319             if(srvCellItem->served_Cell_Information.nRCGI.nRCellIdentity.buf !=NULLP)
1320             {
1321                if(srvCellItem->served_Cell_Information.fiveGS_TAC!=NULLP)
1322                {
1323                   if(srvCellItem->served_Cell_Information.fiveGS_TAC->buf!=NULLP)
1324                   {
1325                      if(srvCellItem->served_Cell_Information.servedPLMNs.list.array!=NULLP)
1326                      {
1327                         if(srvCellItem->served_Cell_Information.servedPLMNs.list.array[0]!=NULLP)
1328                         {
1329                            if(srvCellItem->served_Cell_Information.servedPLMNs.list.array[servId]->pLMN_Identity.buf!=NULLP)
1330                            {
1331                               if(srvCellItem->served_Cell_Information.servedPLMNs.list.array[servId]->iE_Extensions!=NULLP)
1332                               {
1333                                  if(srvCellItem->served_Cell_Information.servedPLMNs.list.array[servId]->iE_Extensions->list.array!=NULLP)
1334                                  {
1335                                     if(srvCellItem->served_Cell_Information.servedPLMNs.list.array[servId]->iE_Extensions->list.array[0]!=NULLP)
1336                                     {
1337                                        if(srvCellItem->served_Cell_Information.servedPLMNs.list.array[servId]->iE_Extensions->list.array[0]->\
1338                                              extensionValue.choice.SliceSupportList.list.array!=NULLP)
1339                                        {
1340                                           if(srvCellItem->served_Cell_Information.servedPLMNs.list.array[servId]->iE_Extensions->list.array[0]->\
1341                                                 extensionValue.choice.SliceSupportList.list.array[sliceId]!= NULLP)
1342                                           {
1343                                              if(srvCellItem->served_Cell_Information.servedPLMNs.list.array[servId]->iE_Extensions->list.array[0]->\
1344                                                    extensionValue.choice.SliceSupportList.list.array[sliceId]->sNSSAI.sST.buf!=NULLP)
1345                                              {
1346                                                 if(srvCellItem->served_Cell_Information.servedPLMNs.list.array[servId]->iE_Extensions->list.array[0]->\
1347                                                       extensionValue.choice.SliceSupportList.list.array[sliceId]->sNSSAI.sD!=NULLP)
1348                                                 {
1349                                                    if(srvCellItem->served_Cell_Information.servedPLMNs.list.array[servId]->iE_Extensions->\
1350                                                          list.array[0]->extensionValue.choice.SliceSupportList.list.array[sliceId]->sNSSAI.sD->buf!=NULLP)
1351                                                    {
1352                                                       if(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD!=NULLP)
1353                                                       {
1354                                                          if(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD->uL_NRFreqInfo.\
1355                                                                freqBandListNr.list.array!=NULLP)
1356                                                          {
1357                                                             if(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD->uL_NRFreqInfo.\
1358                                                                   freqBandListNr.list.array[0]!=NULLP)
1359                                                             {
1360                                                                if(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD->dL_NRFreqInfo.\
1361                                                                      freqBandListNr.list.array)
1362                                                                {
1363                                                                   if(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD->dL_NRFreqInfo.\
1364                                                                         freqBandListNr.list.array[0]!=NULLP)
1365                                                                   {
1366                                                                      if(srvCellItem->served_Cell_Information.measurementTimingConfiguration.buf!=NULLP)
1367                                                                      {
1368                                                                         if(!srvCellItem->gNB_DU_System_Information)
1369                                                                         {
1370                                                                            if(srvCellItem->gNB_DU_System_Information->mIB_message.buf!=NULLP)
1371                                                                            {
1372                                                                               if(srvCellItem->gNB_DU_System_Information->sIB1_message.buf!=NULLP)
1373                                                                               {
1374                                                                                  DU_FREE(srvCellItem->gNB_DU_System_Information->sIB1_message.buf,\
1375                                                                                        srvCellItem->gNB_DU_System_Information->sIB1_message.size);
1376                                                                                  DU_FREE(duCfgParam.srvdCellLst[0].duSysInfo.sib1Msg,\
1377                                                                                        srvCellItem->gNB_DU_System_Information->sIB1_message.size);
1378                                                                               }
1379                                                                               DU_FREE(srvCellItem->gNB_DU_System_Information->mIB_message.buf,\
1380                                                                                     srvCellItem->gNB_DU_System_Information->mIB_message.size);
1381                                                                               DU_FREE(duCfgParam.srvdCellLst[0].duSysInfo.mibMsg,\
1382                                                                                     strlen((char*)duCfgParam.srvdCellLst[0].duSysInfo.mibMsg));
1383                                                                            }
1384                                                                            DU_FREE(srvCellItem->gNB_DU_System_Information,sizeof(GNB_DU_System_Information_t));
1385                                                                         }
1386                                                                         DU_FREE(srvCellItem->served_Cell_Information.measurementTimingConfiguration.buf,\
1387                                                                               srvCellItem->served_Cell_Information.measurementTimingConfiguration.size);
1388                                                                      }
1389                                                                      DU_FREE(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD->dL_NRFreqInfo.\
1390                                                                            freqBandListNr.list.array[0],sizeof(FreqBandNrItem_t));
1391                                                                   }
1392                                                                   DU_FREE(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD->dL_NRFreqInfo.\
1393                                                                         freqBandListNr.list.array,sizeof(FreqBandNrItem_t *));
1394                                                                }
1395                                                                DU_FREE(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD->uL_NRFreqInfo.freqBandListNr.\
1396                                                                      list.array[0],sizeof(FreqBandNrItem_t));
1397                                                             }
1398                                                             DU_FREE(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD->uL_NRFreqInfo.freqBandListNr.\
1399                                                                   list.array,sizeof(FreqBandNrItem_t*));
1400                                                          }
1401                                                          DU_FREE(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD,sizeof(FDD_Info_t));
1402                                                       }
1403                                                       DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.array[servId]->\
1404                                                             iE_Extensions->list.array[ieId]->extensionValue.choice.SliceSupportList.list.array[sliceId]->\
1405                                                             sNSSAI.sD->buf,srvCellItem->served_Cell_Information.servedPLMNs.list.array[servId]->iE_Extensions->
1406                                                             list.array[ieId]->extensionValue.choice.SliceSupportList.list.array[sliceId]->sNSSAI.sD->size);
1407                                                    }
1408                                                    DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.array[servId]->\
1409                                                          iE_Extensions->list.array[ieId]->extensionValue.choice.SliceSupportList.\
1410                                                          list.array[sliceId]->sNSSAI.sD,sizeof(OCTET_STRING_t));
1411                                                 }
1412                                                 DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.array[servId]->\
1413                                                       iE_Extensions->list.array[ieId]->extensionValue.choice.SliceSupportList.list.array[sliceId]->\
1414                                                       sNSSAI.sST.buf,sizeof(uint8_t));
1415                                              }
1416                                              DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.array[servId]->iE_Extensions->list.array[0]->\
1417                                                    extensionValue.choice.SliceSupportList.list.array[sliceId],sizeof(SliceSupportItem_t));
1418                                           }
1419                                           DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.array[servId]->iE_Extensions->list.array[0]->\
1420                                                 extensionValue.choice.SliceSupportList.list.array,sizeof(SliceSupportItem_t*));
1421                                        }
1422                                        DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.\
1423                                              array[servId]->iE_Extensions->list.array[plmnidx],sizeof(ServedPLMNs_ItemExtIEs_t));
1424                                     }
1425                                     DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.\
1426                                           array[servId]->iE_Extensions->list.array,\
1427                                           extensionCnt*sizeof(ServedPLMNs_ItemExtIEs_t*));
1428                                  }
1429                                  DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.\
1430                                        array[servId]->iE_Extensions,sizeof(ProtocolExtensionContainer_4624P3_t));
1431                               }
1432                               DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.\
1433                                     array[servId]->pLMN_Identity.buf,srvCellItem->served_Cell_Information.\
1434                                     servedPLMNs.list.array[servId]->pLMN_Identity.size
1435                                     * sizeof(uint8_t));
1436                            }
1437                            DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.array[plmnidx],\
1438                                  sizeof(ServedPLMNs_Item_t *));
1439                         }
1440                         DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.array,\
1441                               sizeof(ServedPLMNs_Item_t *));
1442                      }
1443                      DU_FREE(srvCellItem->served_Cell_Information.fiveGS_TAC->buf,\
1444                            sizeof(srvCellItem->served_Cell_Information.fiveGS_TAC->size));
1445                   }
1446                   DU_FREE(srvCellItem->served_Cell_Information.fiveGS_TAC,sizeof(FiveGS_TAC_t));
1447                }
1448                DU_FREE(srvCellItem->served_Cell_Information.nRCGI.nRCellIdentity.buf,\
1449                      srvCellItem->served_Cell_Information.nRCGI.nRCellIdentity.size *
1450                      sizeof(uint8_t));
1451             }
1452             DU_FREE(srvCellItem->served_Cell_Information.nRCGI.pLMN_Identity.buf,\
1453                   srvCellItem->served_Cell_Information.nRCGI.pLMN_Identity.size *
1454                   sizeof(uint8_t));
1455          }
1456          DU_FREE(duServedCell->list.array[plmnidx],sizeof(GNB_DU_Served_Cells_ItemIEs_t));
1457       }
1458       DU_FREE(duServedCell->list.array,plmnCnt*sizeof(GNB_DU_Served_Cells_ItemIEs_t*));
1459    }
1460 }
1461 /*******************************************************************
1462  *
1463  * @brief  deallocating the memory of function BuildAndSendF1SetupReq()
1464  *
1465  * @details
1466  *
1467  *    Function :  FreeF1SetupReq
1468  *
1469  *    Functionality:  deallocating the memory of function BuildAndSendF1SetupReq
1470  *
1471  * @params[in] F1AP_PDU_t *f1apMsg
1472  *
1473  * @return void
1474  *
1475  * ****************************************************************/
1476 void FreeF1SetupReq(F1AP_PDU_t *f1apMsg)
1477 {
1478    uint8_t ieIdx, ieIdx2;
1479    F1SetupRequest_t *f1SetupReq=NULLP;
1480
1481    if(f1apMsg != NULLP)
1482    {
1483       if(f1apMsg->choice.initiatingMessage != NULLP)
1484       {
1485          f1SetupReq = &f1apMsg->choice.initiatingMessage->value.choice.F1SetupRequest;
1486          if(f1SetupReq->protocolIEs.list.array != NULLP)
1487          {
1488             for(ieIdx = 0; ieIdx < f1SetupReq->protocolIEs.list.count; ieIdx++)
1489             {
1490                if(f1SetupReq->protocolIEs.list.array[ieIdx] != NULLP)
1491                {
1492                   switch(f1SetupReq->protocolIEs.list.array[ieIdx]->id)
1493                   {
1494                      case ProtocolIE_ID_id_TransactionID:
1495                         break;
1496                      case ProtocolIE_ID_id_gNB_DU_ID:
1497                         DU_FREE(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf,\
1498                               f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.size);
1499                         break;
1500                      case ProtocolIE_ID_id_gNB_DU_Name:
1501                         DU_FREE(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_Name.buf,\
1502                               strlen((char *)duCfgParam.duName));
1503                         break;
1504                      case ProtocolIE_ID_id_gNB_DU_Served_Cells_List:
1505                         FreeServedCellList(&f1SetupReq->protocolIEs.list.\
1506                               array[ieIdx]->value.choice.GNB_DU_Served_Cells_List);
1507                         break;
1508                      case ProtocolIE_ID_id_GNB_DU_RRC_Version:
1509                         FreeRrcVer(&f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.RRC_Version);
1510                         break;
1511                      default:
1512                         DU_LOG("\nERROR  -->  Invalid Event Type %ld", f1SetupReq->protocolIEs.list.array[ieIdx]->id);
1513                         break;
1514                   }
1515                }
1516                break;
1517             }
1518             for(ieIdx2=0; ieIdx2< ieIdx; ieIdx2++)
1519             {
1520                DU_FREE(f1SetupReq->protocolIEs.list.array[ieIdx2],sizeof(F1SetupRequestIEs_t));
1521             }
1522             DU_FREE(f1SetupReq->protocolIEs.list.array,\
1523                   f1SetupReq->protocolIEs.list.size);
1524          }
1525          DU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
1526       }
1527       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
1528    }
1529 }
1530 /*******************************************************************
1531  *
1532  * @brief Builds and Send the F1SetupRequest
1533  *
1534  * @details
1535  *
1536  *    Function : BuildAndSendF1SetupReq
1537  *
1538  * Functionality:Fills the F1SetupRequest
1539  *
1540  * @return ROK     - success
1541  *         RFAILED - failure
1542  *
1543  ******************************************************************/
1544 uint8_t BuildAndSendF1SetupReq()
1545 {
1546    uint8_t   ret, ieIdx, elementCnt;
1547    F1AP_PDU_t                 *f1apMsg = NULLP;
1548    F1SetupRequest_t           *f1SetupReq=NULLP;
1549    GNB_DU_Served_Cells_List_t *duServedCell=NULLP;
1550    RRC_Version_t              *rrcVer=NULLP;
1551    asn_enc_rval_t             encRetVal;        /* Encoder return value */
1552    ret= RFAILED;
1553
1554    DU_LOG("\nINFO   -->  F1AP : Building F1 Setup Request\n");
1555    do
1556    {
1557       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
1558       if(f1apMsg == NULLP)
1559       {
1560          break;
1561       }
1562       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
1563       DU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
1564       if(f1apMsg->choice.initiatingMessage == NULLP)
1565       {
1566          break;
1567       }
1568       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_F1Setup;
1569       f1apMsg->choice.initiatingMessage->criticality = Criticality_reject;
1570       f1apMsg->choice.initiatingMessage->value.present = \
1571                                                          InitiatingMessage__value_PR_F1SetupRequest;
1572
1573       f1SetupReq = &f1apMsg->choice.initiatingMessage->value.choice.F1SetupRequest;
1574
1575       elementCnt = (duCfgParam.duName != NULL) ? 5 : 4;
1576
1577       f1SetupReq->protocolIEs.list.count = elementCnt;
1578       f1SetupReq->protocolIEs.list.size = elementCnt * sizeof(F1SetupRequestIEs_t );
1579
1580       /* Initialize the F1Setup members */
1581       DU_ALLOC(f1SetupReq->protocolIEs.list.array,f1SetupReq->protocolIEs.list.size);
1582       if(f1SetupReq->protocolIEs.list.array == NULLP)
1583       {
1584          break;
1585       }
1586       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
1587       {
1588          DU_ALLOC(f1SetupReq->protocolIEs.list.array[ieIdx],\
1589                sizeof(F1SetupRequestIEs_t));
1590          if(f1SetupReq->protocolIEs.list.array[ieIdx] == NULLP)
1591          {
1592             break;
1593          }
1594       }
1595
1596       ieIdx = 0;
1597       /*TransactionID*/
1598       f1SetupReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_TransactionID;
1599       f1SetupReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
1600       f1SetupReq->protocolIEs.list.array[ieIdx]->value.present =\
1601                                                                F1SetupRequestIEs__value_PR_TransactionID;
1602       f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.TransactionID = \
1603                                                                              TRANS_ID;
1604
1605       /*DU ID*/
1606       ieIdx++;
1607       f1SetupReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_ID;
1608       f1SetupReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
1609       f1SetupReq->protocolIEs.list.array[ieIdx]->value.present = \
1610                                                                 F1SetupRequestIEs__value_PR_GNB_DU_ID;
1611       f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.size =\
1612                                                                              sizeof(uint8_t);
1613
1614       DU_ALLOC(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf,\
1615             f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.size);
1616       if(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf == \
1617             NULLP)
1618       {
1619          break;
1620       }
1621
1622       f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf[0] =\
1623          duCfgParam.duId;
1624
1625       /*DU Name*/
1626       if(duCfgParam.duName != NULL)
1627       {
1628          ieIdx++;
1629          f1SetupReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_Name;
1630          f1SetupReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_ignore;
1631          f1SetupReq->protocolIEs.list.array[ieIdx]->value.present = F1SetupRequestIEs__value_PR_GNB_DU_Name;
1632          f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_Name.size =\
1633             strlen((char *)duCfgParam.duName);
1634          DU_ALLOC(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.\
1635                GNB_DU_Name.buf, strlen((char *)duCfgParam.duName));
1636          if(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_Name.\
1637                buf == NULLP)
1638          {
1639             break;
1640          }
1641          strcpy((char*)f1SetupReq->protocolIEs.list.array[ieIdx]->value.\
1642                choice.GNB_DU_Name.buf,
1643                (char*)&duCfgParam.duName);
1644
1645       }
1646
1647       /*Served Cell list */
1648       ieIdx++;
1649       f1SetupReq->protocolIEs.list.array[ieIdx]->id = \
1650                                                      ProtocolIE_ID_id_gNB_DU_Served_Cells_List;
1651       f1SetupReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
1652       f1SetupReq->protocolIEs.list.array[ieIdx]->value.present = \
1653                                                                 F1SetupRequestIEs__value_PR_GNB_DU_Served_Cells_List;
1654       duServedCell = &f1SetupReq->protocolIEs.list.\
1655                      array[ieIdx]->value.choice.GNB_DU_Served_Cells_List;
1656       if(BuildServedCellList(duServedCell))
1657       {
1658          break;
1659       }
1660       /*RRC Version*/
1661       ieIdx++;
1662       f1SetupReq->protocolIEs.list.array[ieIdx]->id = \
1663                                                      ProtocolIE_ID_id_GNB_DU_RRC_Version ;
1664       f1SetupReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
1665       f1SetupReq->protocolIEs.list.array[ieIdx]->value.present = \
1666                                                                 F1SetupRequestIEs__value_PR_RRC_Version;
1667       rrcVer = &f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.RRC_Version;
1668       if(BuildRrcVer(rrcVer))
1669       {
1670          break;
1671       }
1672       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
1673
1674       /* Encode the F1SetupRequest type as APER */
1675       memset(encBuf, 0, ENC_BUF_MAX_LEN);
1676       encBufSize = 0;
1677       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
1678             encBuf);
1679
1680       /* Encode results */
1681       if(encRetVal.encoded == ENCODE_FAIL)
1682       {
1683          DU_LOG("\nERROR  -->  F1AP : Could not encode F1SetupRequest structure (at %s)\n",\
1684                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
1685          break;
1686       }
1687       else
1688       {
1689          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for F1SetupRequest\n");
1690          for(ieIdx=0; ieIdx< encBufSize; ieIdx++)
1691          {
1692             printf("%x",encBuf[ieIdx]);
1693          }
1694       }
1695
1696       /* Sending msg */
1697       if(SendF1APMsg(DU_APP_MEM_REGION, DU_POOL) != ROK)
1698       {
1699          DU_LOG("\nERROR  -->  F1AP : Sending F1 Setup request failed");
1700          break;
1701       }
1702
1703       ret=ROK;
1704       break;
1705    }while(true);
1706
1707    FreeF1SetupReq(f1apMsg);
1708
1709    return ret;
1710 }/* End of BuildAndSendF1SetupReq */
1711
1712 /*******************************************************************
1713  *
1714  * @brief Deallocating memory of BuildAndSendDUConfigUpdate
1715  *
1716  * @details
1717  *
1718  *    Function : FreeDUConfigUpdate
1719  *
1720  *    Functionality: Deallocating memory of variables allocated in
1721  *                    BuildAndSendDUConfigUpdate function
1722  *
1723  * @params[in]  F1AP_PDU_t *f1apDuCfg
1724  *
1725  * @return ROK     - void
1726  *
1727  * ****************************************************************/
1728 void FreeDUConfigUpdate(F1AP_PDU_t *f1apDuCfg)
1729 {
1730    uint8_t  i;
1731    uint8_t  idx;
1732    GNBDUConfigurationUpdate_t *duCfgUpdate = NULLP;
1733    Served_Cells_To_Modify_List_t  *cellsToModify;
1734    Served_Cells_To_Modify_Item_t *modifyItem;
1735    idx=0;
1736    i=1;
1737    if(f1apDuCfg != NULLP)
1738    {
1739       if(f1apDuCfg->choice.initiatingMessage != NULLP)
1740       {
1741          duCfgUpdate = &f1apDuCfg->choice.initiatingMessage->\
1742                        value.choice.GNBDUConfigurationUpdate;
1743          if(duCfgUpdate->protocolIEs.list.array != NULLP)
1744          {
1745             if(duCfgUpdate->protocolIEs.list.array[i] != NULLP)
1746             {
1747                cellsToModify = &duCfgUpdate->protocolIEs.list.array[i]->\
1748                                value.choice.Served_Cells_To_Modify_List;
1749                if(cellsToModify->list.array != NULLP)
1750                {
1751                   if(cellsToModify->list.array[idx] != NULLP)
1752                   {
1753                      modifyItem=&cellsToModify->list.array[idx]->value.choice.\
1754                                 Served_Cells_To_Modify_Item;
1755                      if(modifyItem->oldNRCGI.pLMN_Identity.buf != NULLP)
1756                      {
1757                         if(modifyItem->oldNRCGI.nRCellIdentity.buf != NULLP)
1758                         {
1759                            if(modifyItem->served_Cell_Information.nRCGI.pLMN_Identity.buf != NULLP)
1760                            {
1761                               if(modifyItem->served_Cell_Information.nRCGI.nRCellIdentity.buf
1762                                     != NULLP)
1763                               {
1764                                  if(modifyItem->served_Cell_Information.servedPLMNs.list.array\
1765                                        != NULLP)
1766                                  {
1767                                     if(!modifyItem->served_Cell_Information.servedPLMNs.list.array[idx])
1768                                     {
1769                                        if(modifyItem->served_Cell_Information.servedPLMNs.list.\
1770                                              array[idx]->pLMN_Identity.buf != NULLP)
1771                                        {
1772                                           if(modifyItem->served_Cell_Information.servedPLMNs.list.\
1773                                                 array[idx]->iE_Extensions!= NULLP)
1774                                           {
1775                                              if(modifyItem->served_Cell_Information.servedPLMNs.list.\
1776                                                    array[idx]->iE_Extensions->list.array != NULLP)
1777                                              {
1778                                                 if(modifyItem->served_Cell_Information.servedPLMNs.list.\
1779                                                       array[idx]->iE_Extensions->list.array[idx])
1780                                                 {
1781                                                    if(modifyItem->served_Cell_Information.servedPLMNs.list.array[idx]->\
1782                                                          iE_Extensions->list.array[idx]->extensionValue.choice.SliceSupportList.\
1783                                                          list.array !=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]!=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.sST.buf!=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 != NULLP)
1796                                                             {
1797                                                                if(modifyItem->served_Cell_Information.servedPLMNs.list.array[idx]->\
1798                                                                      iE_Extensions->list.array[idx]->extensionValue.choice.SliceSupportList.\
1799                                                                      list.array[idx]->sNSSAI.sD->buf!=NULLP)
1800                                                                {
1801                                                                   if(modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD
1802                                                                         !=NULLP)
1803                                                                   {
1804                                                                      if(modifyItem->served_Cell_Information.nR_Mode_Info.choice.\
1805                                                                            fDD->uL_NRFreqInfo.freqBandListNr.list.array!=NULLP)
1806                                                                      {
1807                                                                         if(modifyItem->served_Cell_Information.nR_Mode_Info.choice.\
1808                                                                               fDD->uL_NRFreqInfo.freqBandListNr.list.array[idx]!=NULLP)
1809                                                                         {
1810                                                                            if(modifyItem->served_Cell_Information.nR_Mode_Info.choice.\
1811                                                                                  fDD->dL_NRFreqInfo.freqBandListNr.list.array !=NULLP)
1812                                                                            {
1813                                                                               if(modifyItem->served_Cell_Information.nR_Mode_Info.\
1814                                                                                     choice.fDD->dL_NRFreqInfo.freqBandListNr.list.\
1815                                                                                     array[idx]!= NULLP)
1816                                                                               {
1817                                                                                  if(modifyItem->served_Cell_Information.\
1818                                                                                        measurementTimingConfiguration.buf !=NULLP)
1819                                                                                  {
1820                                                                                     idx=2;
1821                                                                                     if(duCfgUpdate->protocolIEs.list.array[idx]->value.\
1822                                                                                           choice.GNB_DU_ID.buf!=NULLP)
1823                                                                                     {
1824                                                                                        DU_FREE(duCfgUpdate->protocolIEs.list.\
1825                                                                                              array[idx]->value.choice.GNB_DU_ID.buf,\
1826                                                                                              duCfgUpdate->protocolIEs.list.array[idx]->\
1827                                                                                              value.choice.GNB_DU_ID.size);
1828                                                                                     }
1829                                                                                     idx=0;
1830                                                                                     DU_FREE(modifyItem->served_Cell_Information.\
1831                                                                                           measurementTimingConfiguration.\
1832                                                                                           buf,modifyItem->served_Cell_Information.\
1833                                                                                           measurementTimingConfiguration.size);
1834                                                                                  }
1835                                                                                  DU_FREE(modifyItem->served_Cell_Information.\
1836                                                                                        nR_Mode_Info.choice.fDD->dL_NRFreqInfo.freqBandListNr.\
1837                                                                                        list.array[idx],sizeof(FreqBandNrItem_t));
1838                                                                               }
1839                                                                               DU_FREE(modifyItem->served_Cell_Information.nR_Mode_Info\
1840                                                                                     .choice.fDD->dL_NRFreqInfo.freqBandListNr.list.array,\
1841                                                                                     modifyItem->served_Cell_Information.nR_Mode_Info.\
1842                                                                                     choice.fDD->dL_NRFreqInfo.freqBandListNr.list.size);
1843                                                                            }
1844                                                                            DU_FREE(modifyItem->served_Cell_Information.nR_Mode_Info.\
1845                                                                                  choice.fDD->uL_NRFreqInfo.freqBandListNr.list.\
1846                                                                                  array[idx],sizeof(FreqBandNrItem_t));
1847                                                                         }
1848                                                                         DU_FREE(modifyItem->served_Cell_Information.nR_Mode_Info.\
1849                                                                               choice.\
1850                                                                               fDD->uL_NRFreqInfo.freqBandListNr.list.\
1851                                                                               array,modifyItem->served_Cell_Information.nR_Mode_Info.choice.\
1852                                                                               fDD->uL_NRFreqInfo.freqBandListNr.list.size);
1853                                                                      }
1854                                                                      DU_FREE(modifyItem->served_Cell_Information.nR_Mode_Info.choice.\
1855                                                                            fDD,sizeof(FDD_Info_t));
1856                                                                   }
1857                                                                   DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.\
1858                                                                         array[idx]->iE_Extensions->list.array[idx]->extensionValue.choice.\
1859                                                                         SliceSupportList.\
1860                                                                         list.array[idx]->sNSSAI.sD->buf,modifyItem->served_Cell_Information.\
1861                                                                         servedPLMNs.list.array[idx]->iE_Extensions->list.array[idx]->\
1862                                                                         extensionValue.choice.SliceSupportList.list.array[idx]->\
1863                                                                         sNSSAI.sD->size);
1864
1865                                                                }
1866                                                                DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.\
1867                                                                      array[idx]->\
1868                                                                      iE_Extensions->list.array[idx]->extensionValue.choice.SliceSupportList.\
1869                                                                      list.array[idx]->sNSSAI.sD,sizeof(OCTET_STRING_t));
1870                                                             }
1871                                                             DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.array[idx]->\
1872                                                                   iE_Extensions->list.array[idx]->extensionValue.choice.SliceSupportList.\
1873                                                                   list.array[idx]->sNSSAI.sST.buf,modifyItem->served_Cell_Information.\
1874                                                                   servedPLMNs.\
1875                                                                   list.array[idx]->iE_Extensions->list.array[idx]->extensionValue.choice.\
1876                                                                   SliceSupportList.list.array[idx]->sNSSAI.sST.size);
1877                                                          }
1878                                                          DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.array[idx]->\
1879                                                                iE_Extensions->list.array[idx]->extensionValue.choice.SliceSupportList.\
1880                                                                list.array[idx],sizeof(SliceSupportItem_t));
1881                                                       }
1882                                                       DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.array[idx]->\
1883                                                             iE_Extensions->list.array[idx]->extensionValue.choice.SliceSupportList.\
1884                                                             list.array,\
1885                                                             modifyItem->served_Cell_Information.servedPLMNs.list.array[idx]->\
1886                                                             iE_Extensions->list.array[idx]->extensionValue.choice.SliceSupportList.list.size);
1887                                                    }
1888                                                 }
1889                                                 for(i=0;i<modifyItem->served_Cell_Information.servedPLMNs.list.\
1890                                                       array[idx]->iE_Extensions->list.count;i++)
1891                                                 {
1892                                                    DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.\
1893                                                          array[idx]->iE_Extensions->list.array[i],\
1894                                                          sizeof(ServedPLMNs_ItemExtIEs_t ));
1895                                                 }
1896                                                 DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.\
1897                                                       array[idx]->iE_Extensions->list.array,modifyItem->served_Cell_Information.servedPLMNs.
1898                                                       list.array[idx]->iE_Extensions->list.size);
1899                                              }
1900                                              DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.\
1901                                                    array[idx]->iE_Extensions,sizeof(ProtocolExtensionContainer_4624P3_t));
1902                                           }
1903                                           DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.\
1904                                                 array[idx]->pLMN_Identity.buf,
1905                                                 modifyItem->served_Cell_Information.servedPLMNs.list.array[idx]->pLMN_Identity.size);
1906                                        }
1907                                     }
1908                                     for(i=0;i<modifyItem->served_Cell_Information.servedPLMNs.list.count;i++)
1909                                     {
1910                                        if(modifyItem->served_Cell_Information.servedPLMNs.list.array[i]
1911                                              != NULLP)
1912                                        {
1913                                           DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.array[i],\
1914                                                 sizeof(ServedPLMNs_Item_t));
1915                                        }
1916                                     }
1917                                     DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.array,\
1918                                           modifyItem->served_Cell_Information.servedPLMNs.list.size);
1919                                  }
1920                                  DU_FREE(modifyItem->served_Cell_Information.nRCGI.nRCellIdentity.buf,\
1921                                        modifyItem->served_Cell_Information.nRCGI.nRCellIdentity.size);
1922                               }
1923                               DU_FREE(modifyItem->served_Cell_Information.nRCGI.pLMN_Identity.buf,\
1924                                     modifyItem->served_Cell_Information.nRCGI.pLMN_Identity.size);
1925                            }
1926                            DU_FREE(modifyItem->oldNRCGI.nRCellIdentity.buf,\
1927                                  modifyItem->oldNRCGI.nRCellIdentity.size);
1928                         }
1929                         DU_FREE(modifyItem->oldNRCGI.pLMN_Identity.buf,\
1930                               modifyItem->oldNRCGI.pLMN_Identity.size);
1931                      }
1932                   }
1933                   for(i=0; i<cellsToModify->list.count ;i++)
1934                   {
1935                      if(cellsToModify->list.array[i] != NULLP)
1936                      {
1937                         DU_FREE(cellsToModify->list.array[i],\
1938                               sizeof(Served_Cells_To_Modify_ItemIEs_t));
1939                      }
1940                   }
1941                   DU_FREE(cellsToModify->list.array,cellsToModify->list.size);
1942                }
1943             }
1944             for(i=0;i<duCfgUpdate->protocolIEs.list.count;i++)
1945             {
1946                if(duCfgUpdate->protocolIEs.list.array[i] !=NULLP)
1947                {
1948                   DU_FREE(duCfgUpdate->protocolIEs.list.array[i],\
1949                         sizeof(GNBDUConfigurationUpdateIEs_t));
1950                }
1951             }
1952             DU_FREE(duCfgUpdate->protocolIEs.list.array,duCfgUpdate->protocolIEs.list.size);
1953          }
1954          DU_FREE(f1apDuCfg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
1955       }
1956       DU_FREE(f1apDuCfg, (Size)sizeof(F1AP_PDU_t));
1957    }
1958 }
1959
1960 /*******************************************************************
1961  *
1962  * @brief Fills Served Plmns required in ServCellInfo IE
1963  *
1964  * @details
1965  *
1966  *    Function : fillServedPlmns
1967  *
1968  *    Functionality: Fills Served Plmns required in ServCellInfo IE
1969  *
1970  * @params[in] Pointer to ServedPLMNs_List_t *
1971  *
1972  * @return ROK     - success
1973  *         RFAILED - failure
1974  *
1975  *****************************************************************/
1976
1977 uint8_t fillServedPlmns(ServedPLMNs_List_t *servedPlmn)
1978 {
1979    uint8_t ieIdx, ieListCnt;
1980
1981    servedPlmn->list.array[0]->pLMN_Identity.size = 3*sizeof(uint8_t);
1982    DU_ALLOC(servedPlmn->list.array[0]->pLMN_Identity.buf, servedPlmn->list.\
1983          array[0]->pLMN_Identity.size);
1984    if(servedPlmn->list.array[0]->pLMN_Identity.buf == NULLP)
1985    {
1986       return RFAILED;
1987    }
1988    buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.plmn[0],\
1989          servedPlmn->list.array[0]->pLMN_Identity.buf);
1990    DU_ALLOC(servedPlmn->list.array[0]->iE_Extensions,sizeof(ProtocolExtensionContainer_4624P3_t));
1991    if(servedPlmn->list.array[0]->iE_Extensions == NULLP)
1992    {
1993       return RFAILED;
1994    }
1995
1996    ieListCnt=1;
1997    servedPlmn->list.array[0]->iE_Extensions->list.count = ieListCnt;
1998    servedPlmn->list.array[0]->iE_Extensions->list.size = ieListCnt *sizeof(ServedPLMNs_ItemExtIEs_t *);
1999    DU_ALLOC(servedPlmn->list.array[0]->iE_Extensions->list.array,servedPlmn->list.array[0]->\
2000          iE_Extensions->list.size);
2001    if(servedPlmn->list.array[0]->iE_Extensions->list.array == NULLP)
2002    {
2003       return RFAILED;
2004    }
2005    for(ieIdx=0;ieIdx<ieListCnt;ieIdx++)
2006    {
2007       DU_ALLOC(servedPlmn->list.array[0]->iE_Extensions->list.array[ieIdx],\
2008             sizeof(ServedPLMNs_ItemExtIEs_t));
2009       if(servedPlmn->list.array[0]->iE_Extensions->list.array[ieIdx] == NULLP)
2010       {
2011          return RFAILED;
2012       }
2013    }
2014    //plmnIeExt = servedPlmn->list.array[0]->iE_Extensions;
2015    servedPlmn->list.array[0]->iE_Extensions->list.array[0]->id =ProtocolIE_ID_id_TAISliceSupportList;
2016    servedPlmn->list.array[0]->iE_Extensions->list.array[0]->criticality = Criticality_ignore;
2017    servedPlmn->list.array[0]->iE_Extensions->list.array[0]->extensionValue.present = \
2018       ServedPLMNs_ItemExtIEs__extensionValue_PR_SliceSupportList;
2019    servedPlmn->list.array[0]->iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2020       list.count = 1;
2021    servedPlmn->list.array[0]->\
2022       iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2023       list.size = sizeof(SliceSupportItem_t *);
2024    DU_ALLOC(servedPlmn->list.array[0]->\
2025          iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2026          list.array,servedPlmn->list.array[0]->\
2027          iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.list.size);
2028    if(servedPlmn->list.array[0]->\
2029          iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2030          list.array == NULLP)
2031    {
2032       return RFAILED;
2033    }
2034
2035    DU_ALLOC(servedPlmn->list.array[0]->\
2036          iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2037          list.array[0],sizeof( SliceSupportItem_t));
2038    if(servedPlmn->list.array[0]->\
2039          iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2040          list.array[0] == NULLP)
2041    {
2042       return RFAILED;
2043    }
2044    servedPlmn->list.array[0]->\
2045       iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2046       list.array[0]->sNSSAI.sST.size = sizeof(uint8_t);
2047    DU_ALLOC(servedPlmn->list.array[0]->\
2048          iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2049          list.array[0]->sNSSAI.sST.buf,servedPlmn->list.array[0]->\
2050          iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.list.array[0]->sNSSAI.sST.size);
2051    if(servedPlmn->list.array[0]->\
2052          iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2053          list.array[0]->sNSSAI.sST.buf == NULLP)
2054    {
2055       return RFAILED;
2056    }
2057    servedPlmn->list.array[0]->\
2058       iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2059       list.array[0]->sNSSAI.sST.buf[0] = 3;
2060    DU_ALLOC(servedPlmn->list.array[0]->\
2061          iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2062          list.array[0]->sNSSAI.sD,sizeof(OCTET_STRING_t));
2063    if(servedPlmn->list.array[0]->\
2064          iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2065          list.array[0]->sNSSAI.sD == NULLP)
2066    {
2067       return RFAILED;
2068    }
2069    servedPlmn->list.array[0]->\
2070       iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2071       list.array[0]->sNSSAI.sD->size = 3*sizeof(uint8_t);
2072    DU_ALLOC(servedPlmn->list.array[0]->\
2073          iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2074          list.array[0]->sNSSAI.sD->buf,servedPlmn->list.array[0]->\
2075          iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2076          list.array[0]->sNSSAI.sD->size);
2077    if(servedPlmn->list.array[0]->\
2078          iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2079          list.array[0]->sNSSAI.sD->buf == NULLP)
2080    {
2081       return RFAILED;
2082    }
2083    servedPlmn->list.array[0]->\
2084       iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2085       list.array[0]->sNSSAI.sD->buf[0] = 3;
2086    servedPlmn->list.array[0]->\
2087       iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2088       list.array[0]->sNSSAI.sD->buf[1] = 6;
2089    servedPlmn->list.array[0]->\
2090       iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2091       list.array[0]->sNSSAI.sD->buf[2] = 9;
2092    return ROK;
2093 }
2094
2095 /*******************************************************************
2096  *
2097  * @brief Fills Nr Fdd Info required in ServCellInfo IE
2098  *
2099  * @details
2100  *
2101  *    Function : fillNrFddInfo
2102  *
2103  *    Functionality: Fills Nr Fdd Info required in ServCellInfo IE
2104  *
2105  * @params[in] Pointer to NR_Mode_Info_t *
2106  *
2107  * @return ROK     - success
2108  *         RFAILED - failure
2109  *
2110  *****************************************************************/
2111
2112 uint8_t fillNrFddInfo(NR_Mode_Info_t *nrFdd)
2113 {
2114    nrFdd->choice.fDD->uL_NRFreqInfo.nRARFCN = duCfgParam.srvdCellLst[0].duCellInfo.\
2115       f1Mode.mode.fdd.ulNrFreqInfo.nrArfcn;
2116    nrFdd->choice.fDD->uL_NRFreqInfo.freqBandListNr.list.count = 1;
2117    nrFdd->choice.fDD->uL_NRFreqInfo.freqBandListNr.list.size = sizeof(FreqBandNrItem_t*);
2118    DU_ALLOC(nrFdd->choice.fDD->uL_NRFreqInfo.freqBandListNr.list.\
2119          array, nrFdd->choice.fDD->uL_NRFreqInfo.freqBandListNr.list.size);
2120    if(nrFdd->choice.fDD->uL_NRFreqInfo.freqBandListNr.list.array == NULLP)
2121    {
2122       return RFAILED;
2123    }
2124    DU_ALLOC(nrFdd->choice.fDD->uL_NRFreqInfo.freqBandListNr.list.array[0], \
2125       sizeof(FreqBandNrItem_t));
2126    if(nrFdd->choice.fDD->uL_NRFreqInfo.freqBandListNr.list.array[0] == NULLP)
2127    {
2128       return RFAILED;
2129    }
2130    nrFdd->choice.fDD->uL_NRFreqInfo.freqBandListNr.list.array[0]->freqBandIndicatorNr = \
2131       duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.fdd.ulNrFreqInfo.\
2132       freqBand[0].nrFreqBand;
2133    nrFdd->choice.fDD->uL_NRFreqInfo.freqBandListNr.list.array[0]->supportedSULBandList.list.count=0;
2134    nrFdd->choice.fDD->dL_NRFreqInfo.nRARFCN = duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.fdd.\
2135       dlNrFreqInfo.nrArfcn;
2136    nrFdd->choice.fDD->dL_NRFreqInfo.freqBandListNr.list.count = 1;
2137    nrFdd->choice.fDD->dL_NRFreqInfo.freqBandListNr.list.size = sizeof(FreqBandNrItem_t *);
2138    DU_ALLOC(nrFdd->choice.fDD->dL_NRFreqInfo.freqBandListNr.list.array,nrFdd->\
2139          choice.fDD->dL_NRFreqInfo.freqBandListNr.list.size);
2140    if(nrFdd->choice.fDD->dL_NRFreqInfo.freqBandListNr.list.array == NULLP)
2141    {
2142       return RFAILED;
2143    }
2144    DU_ALLOC(nrFdd->choice.fDD->dL_NRFreqInfo.freqBandListNr.list.array[0],\
2145          sizeof(FreqBandNrItem_t));
2146    if(nrFdd->choice.fDD->dL_NRFreqInfo.freqBandListNr.list.array[0] == NULLP)
2147    {
2148       return RFAILED;
2149    }
2150    nrFdd->choice.fDD->dL_NRFreqInfo.freqBandListNr.list.array[0]->freqBandIndicatorNr = \
2151       duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.fdd.dlNrFreqInfo.\
2152       freqBand[0].nrFreqBand;
2153    nrFdd->choice.fDD->dL_NRFreqInfo.freqBandListNr.list.array[0]->supportedSULBandList.list.count=0;
2154
2155    /*Transmission Bandwidth*/
2156    nrFdd->choice.fDD->uL_Transmission_Bandwidth.nRSCS = duCfgParam.srvdCellLst[0].duCellInfo.\
2157       f1Mode.mode.fdd.ulTxBw.nrScs;
2158    nrFdd->choice.fDD->uL_Transmission_Bandwidth.nRNRB = duCfgParam.srvdCellLst[0].duCellInfo.\
2159       f1Mode.mode.fdd.ulTxBw.nrb;
2160    nrFdd->choice.fDD->dL_Transmission_Bandwidth.nRSCS = duCfgParam.srvdCellLst[0].duCellInfo.\
2161       f1Mode.mode.fdd.dlTxBw.nrScs;
2162    nrFdd->choice.fDD->dL_Transmission_Bandwidth.nRNRB = duCfgParam.srvdCellLst[0].duCellInfo.\
2163       f1Mode.mode.fdd.dlTxBw.nrb;
2164
2165    return ROK;
2166 }
2167
2168 /*******************************************************************
2169  *
2170  * @brief Fills ServCellInfo IE
2171  *
2172  * @details
2173  *
2174  *    Function : fillServedCellInfo
2175  *
2176  *    Functionality: Fills ServCellInfo
2177  *
2178  * @params[in] Pointer to Served_Cell_Information_t *
2179  *
2180  * @return ROK     - success
2181  *         RFAILED - failure
2182  *
2183  *****************************************************************/
2184
2185 uint8_t fillServedCellInfo(Served_Cell_Information_t *srvCellInfo)
2186 {
2187    uint8_t tmp, ieIdx, ieListCnt;
2188
2189    /*nRCGI*/
2190    srvCellInfo->nRCGI.pLMN_Identity.size =3*sizeof(uint8_t);
2191    DU_ALLOC(srvCellInfo->nRCGI.pLMN_Identity.buf,\
2192          srvCellInfo->nRCGI.pLMN_Identity.size);
2193    if(srvCellInfo->nRCGI.pLMN_Identity.buf == NULLP)
2194    {
2195       return RFAILED;
2196    }
2197    buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrCgi.plmn,\
2198          srvCellInfo->nRCGI.pLMN_Identity.buf);
2199    srvCellInfo->nRCGI.nRCellIdentity.size =5*sizeof(uint8_t);
2200    DU_ALLOC(srvCellInfo->nRCGI.nRCellIdentity.buf,\
2201          srvCellInfo->nRCGI.nRCellIdentity.size);
2202    if(srvCellInfo->nRCGI.nRCellIdentity.buf == NULLP)
2203    {
2204       return RFAILED;
2205    }
2206    for (tmp = 0 ; tmp < srvCellInfo->\
2207          nRCGI.nRCellIdentity.size-1 ; tmp++)
2208    {
2209       srvCellInfo->nRCGI.nRCellIdentity.buf[tmp] = 0;
2210    }
2211    srvCellInfo->nRCGI.nRCellIdentity.buf[4] = 16;
2212    srvCellInfo->nRCGI.nRCellIdentity.bits_unused =4;
2213
2214    /*nRPCI*/
2215    srvCellInfo->nRPCI = duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrPci;
2216
2217    /*servedPLMNs*/
2218    ieListCnt = 1;
2219    srvCellInfo->servedPLMNs.list.count = ieListCnt;
2220    srvCellInfo->servedPLMNs.list.size = ieListCnt*sizeof(ServedPLMNs_Item_t *);
2221    DU_ALLOC(srvCellInfo->servedPLMNs.list.array,\
2222          srvCellInfo->servedPLMNs.list.size);
2223    if(srvCellInfo->servedPLMNs.list.array == NULLP)
2224    {
2225       return RFAILED;
2226    }
2227    for(ieIdx=0; ieIdx < ieListCnt; ieIdx++)
2228    {
2229       DU_ALLOC(srvCellInfo->servedPLMNs.list.array[ieIdx],\
2230             sizeof(ServedPLMNs_Item_t));
2231       if(srvCellInfo->servedPLMNs.list.array[ieIdx]== NULLP)
2232       {
2233          return RFAILED;
2234       }
2235    }
2236    if(fillServedPlmns(&srvCellInfo->servedPLMNs))
2237    {
2238       return RFAILED;
2239    }
2240
2241    /*nR Mode Info with FDD*/
2242    srvCellInfo->nR_Mode_Info.present = NR_Mode_Info_PR_fDD;
2243    DU_ALLOC(srvCellInfo->nR_Mode_Info.choice.fDD,\
2244          sizeof(FDD_Info_t));
2245    if(srvCellInfo->nR_Mode_Info.choice.fDD == NULLP)
2246    {
2247       return RFAILED;
2248    }
2249    if(fillNrFddInfo(&srvCellInfo->nR_Mode_Info))
2250       return RFAILED;
2251
2252    /*Measurement timing Config*/
2253    srvCellInfo->measurementTimingConfiguration.size = sizeof(uint8_t);
2254    DU_ALLOC(srvCellInfo->measurementTimingConfiguration.\
2255          buf,srvCellInfo->measurementTimingConfiguration.size);
2256    if(srvCellInfo->measurementTimingConfiguration.buf == NULLP)
2257    {
2258       return RFAILED;
2259    }
2260    srvCellInfo->measurementTimingConfiguration.\
2261          buf[0] = duCfgParam.srvdCellLst[0].duCellInfo.measTimeCfg;
2262
2263    return ROK;
2264 }
2265
2266 /*******************************************************************
2267  *
2268  * @brief Fills ServCellToModItem IE
2269  *
2270  * @details
2271  *
2272  *    Function : fillServCellToModItem
2273  *
2274  *    Functionality: Fills ServCellToModItem IE
2275  *
2276  * @params[in] Pointer to Served_Cells_To_Modify_Item_t *
2277  *
2278  * @return ROK     - success
2279  *         RFAILED - failure
2280  *
2281  *****************************************************************/
2282
2283 uint8_t fillServCellToModItem(Served_Cells_To_Modify_Item_t *modifyItem)
2284 {
2285    uint8_t ieIdx;
2286
2287    /*pLMN_Identity*/
2288    modifyItem->oldNRCGI.pLMN_Identity.size = 3*sizeof(uint8_t);
2289    DU_ALLOC(modifyItem->oldNRCGI.pLMN_Identity.buf,modifyItem->oldNRCGI.pLMN_Identity.size);
2290    if(modifyItem->oldNRCGI.pLMN_Identity.buf == NULLP)
2291    {
2292       return RFAILED;
2293    }
2294    buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrCgi.plmn,\
2295          modifyItem->oldNRCGI.pLMN_Identity.buf);
2296
2297    /*nRCellIdentity*/
2298    modifyItem->oldNRCGI.nRCellIdentity.size = 5*sizeof(uint8_t);
2299    DU_ALLOC(modifyItem->oldNRCGI.nRCellIdentity.buf,\
2300          modifyItem->oldNRCGI.nRCellIdentity.size);
2301    if(modifyItem->oldNRCGI.nRCellIdentity.buf == NULLP)
2302    {
2303       return RFAILED;
2304    }
2305    for(ieIdx = 0; ieIdx < modifyItem->oldNRCGI.nRCellIdentity.size-1; ieIdx++)
2306    {
2307       modifyItem->oldNRCGI.nRCellIdentity.buf[ieIdx] = 0;
2308    }
2309    modifyItem->oldNRCGI.nRCellIdentity.buf[4] = 16;
2310    modifyItem->oldNRCGI.nRCellIdentity.bits_unused = 4;
2311
2312    if(fillServedCellInfo(&modifyItem->served_Cell_Information))
2313       return RFAILED;
2314    else
2315       return ROK;
2316 }
2317
2318 /*******************************************************************
2319  *
2320  * @brief Builds ServCellToModList
2321  *
2322  * @details
2323  *
2324  *    Function : buildServCellToModList
2325  *
2326  *    Functionality: Builds the serv cell to Mod List
2327  *
2328  * @params[in] Pointer to Served_Cells_To_Modify_List_t *
2329  *
2330  * @return ROK     - success
2331  *         RFAILED - failure
2332  *
2333  *****************************************************************/
2334
2335 uint8_t buildServCellToModList(Served_Cells_To_Modify_List_t *cellsToModify)
2336 {
2337    uint8_t ieListCnt, ieIdx;
2338    Served_Cells_To_Modify_Item_t *modifyItem = NULLP;
2339
2340    ieListCnt = 1;
2341    cellsToModify->list.count = ieListCnt;
2342    cellsToModify->list.size = ieListCnt*sizeof(Served_Cells_To_Modify_ItemIEs_t *);
2343    DU_ALLOC(cellsToModify->list.array,cellsToModify->list.size);
2344    if(cellsToModify->list.array == NULLP)
2345    {
2346       return RFAILED;
2347    }
2348    for(ieIdx=0; ieIdx< ieListCnt; ieIdx++)
2349    {
2350       DU_ALLOC(cellsToModify->list.array[ieIdx],sizeof(Served_Cells_To_Modify_ItemIEs_t));
2351       if(cellsToModify->list.array[ieIdx] == NULLP)
2352       {
2353          return RFAILED;
2354       }
2355    }
2356    cellsToModify->list.array[0]->id = ProtocolIE_ID_id_Served_Cells_To_Modify_Item;
2357    cellsToModify->list.array[0]->criticality = Criticality_reject;
2358    cellsToModify->list.array[0]->value.present =\
2359       Served_Cells_To_Modify_ItemIEs__value_PR_Served_Cells_To_Modify_Item;
2360    modifyItem=&cellsToModify->list.array[0]->value.choice.Served_Cells_To_Modify_Item;
2361
2362    if(fillServCellToModItem(modifyItem))
2363       return RFAILED;
2364    else
2365       return ROK;
2366 }
2367
2368 /*******************************************************************
2369  *
2370  * @brief Builds and sends the DUConfigUpdate
2371  *
2372  * @details
2373  *
2374  *    Function : BuildAndSendDUConfigUpdate
2375  *
2376  *    Functionality: Constructs the DU Update message and sends
2377  *                   it to the CU through SCTP.
2378  *
2379  * @params[in] void **buf,Buffer to which encoded pattern is written into
2380  * @params[in] int *size,size of buffer
2381  *
2382  * @return ROK     - success
2383  *         RFAILED - failure
2384  *
2385  * ****************************************************************/
2386 uint8_t BuildAndSendDUConfigUpdate()
2387 {
2388    uint8_t ret, ieIdx, elementCnt;
2389    F1AP_PDU_t                 *f1apDuCfg = NULLP;
2390    GNBDUConfigurationUpdate_t *duCfgUpdate = NULLP;
2391    asn_enc_rval_t encRetVal;     /* Encoder return value */
2392    memset(&encRetVal, 0, sizeof(asn_enc_rval_t));
2393    ret= RFAILED;
2394
2395    while(true)
2396    {
2397       DU_LOG("\nINFO   -->  F1AP : Building DU config update\n");
2398       /* Allocate the memory for F1DuCfg */
2399       DU_ALLOC(f1apDuCfg, sizeof(F1AP_PDU_t));
2400       if(f1apDuCfg == NULLP)
2401       {
2402          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
2403          break;
2404       }
2405
2406       f1apDuCfg->present = F1AP_PDU_PR_initiatingMessage;
2407       DU_ALLOC(f1apDuCfg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
2408       if(f1apDuCfg->choice.initiatingMessage == NULLP)
2409       {
2410          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
2411          break;
2412       }
2413
2414       f1apDuCfg->choice.initiatingMessage->procedureCode = \
2415                                                            ProcedureCode_id_gNBDUConfigurationUpdate;
2416       f1apDuCfg->choice.initiatingMessage->criticality = Criticality_reject;
2417       f1apDuCfg->choice.initiatingMessage->value.present = \
2418                                                            InitiatingMessage__value_PR_GNBDUConfigurationUpdate;
2419       duCfgUpdate = &f1apDuCfg->choice.initiatingMessage->value.\
2420                     choice.GNBDUConfigurationUpdate;
2421       elementCnt = 3;
2422       duCfgUpdate->protocolIEs.list.count = elementCnt;
2423       duCfgUpdate->protocolIEs.list.size = \
2424                                            elementCnt * sizeof(GNBDUConfigurationUpdateIEs_t*);
2425
2426       /* Initialize the F1Setup members */
2427       DU_ALLOC(duCfgUpdate->protocolIEs.list.array,duCfgUpdate->protocolIEs.list.size);
2428       if(duCfgUpdate->protocolIEs.list.array == NULLP)
2429       {
2430          DU_LOG("ERROR  -->  F1AP : Memory allocation for F1RequestIEs failed");
2431          break;
2432       }
2433       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
2434       {
2435          DU_ALLOC(duCfgUpdate->protocolIEs.list.array[ieIdx],sizeof(GNBDUConfigurationUpdateIEs_t));
2436          if(duCfgUpdate->protocolIEs.list.array[ieIdx] == NULLP)
2437          {
2438             break;
2439          }
2440       }
2441
2442       /*TransactionID*/
2443       ieIdx = 0;
2444       duCfgUpdate->protocolIEs.list.array[ieIdx]->id=ProtocolIE_ID_id_TransactionID;
2445       duCfgUpdate->protocolIEs.list.array[ieIdx]->criticality= Criticality_reject;
2446       duCfgUpdate->protocolIEs.list.array[ieIdx]->value.present = \
2447          GNBDUConfigurationUpdateIEs__value_PR_TransactionID;
2448       duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.TransactionID = TRANS_ID;
2449
2450       /*Served Cell to Modify */
2451       ieIdx++;
2452       duCfgUpdate->protocolIEs.list.array[ieIdx]->id = \
2453                                                       ProtocolIE_ID_id_Served_Cells_To_Modify_List;
2454       duCfgUpdate->protocolIEs.list.array[ieIdx]->criticality =Criticality_reject;
2455       duCfgUpdate->protocolIEs.list.array[ieIdx]->value.present = \
2456          GNBDUConfigurationUpdateIEs__value_PR_Served_Cells_To_Modify_List;
2457       if(buildServCellToModList(&duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.\
2458          Served_Cells_To_Modify_List))
2459          break;
2460
2461       // NOTE :GNB DU SYS INFO:MIB AND SIB1 INFORMATION TO BE BUILT AND FILLED HERE
2462       /*GNB DU ID */
2463       ieIdx++;
2464       duCfgUpdate->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_ID;
2465       duCfgUpdate->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
2466       duCfgUpdate->protocolIEs.list.array[ieIdx]->value.present = \
2467         GNBDUConfigurationUpdateIEs__value_PR_GNB_DU_ID;
2468       duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.size = sizeof(uint8_t);
2469       DU_ALLOC(duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf,\
2470             duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.size);
2471       if(duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf == NULLP)
2472       {
2473          break;
2474       }
2475       duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf[0] = duCfgParam.duId;
2476
2477       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apDuCfg);
2478
2479       /* Encode the DU Config Update type as APER */
2480       memset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
2481       encBufSize = 0;
2482       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apDuCfg, PrepFinalEncBuf, encBuf);
2483
2484       /* Checking encode results */
2485       if(encRetVal.encoded == ENCODE_FAIL)
2486       {
2487          DU_LOG("ERROR  -->  F1AP : Could not encode DUConfigUpdate structure (at %s)\n",\
2488          encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
2489          break;
2490       }
2491       else
2492       {
2493          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for DUConfigUpdate\n");
2494          for(ieIdx =0; ieIdx < encBufSize; ieIdx++)
2495          {
2496             printf("%x",encBuf[ieIdx]);
2497          }
2498       }
2499       /* Sending msg */
2500       if(SendF1APMsg(DU_APP_MEM_REGION, DU_POOL) != ROK)
2501       {
2502          DU_LOG("\nERROR  -->  F1AP : Sending GNB-DU Config Update failed");
2503          break;
2504       }
2505
2506       ret = ROK;
2507       break;
2508    }
2509    FreeDUConfigUpdate(f1apDuCfg);
2510
2511    return ret;
2512 }
2513
2514
2515 /*******************************************************************
2516  *
2517  * @brief free the ULRRCMessageTransfer
2518  *
2519  * @details
2520  *
2521  *    Function : FreeULRRCMessageTransfer
2522  *
2523  *    Functionality: Deallocating the memory of variable allocated in
2524  *                      FreeULRRCMessageTransfer
2525  *
2526  * @params[in]
2527  *
2528  * @return ROK     - void
2529  *
2530  ******************************************************************/
2531 void FreeULRRCMessageTransfer( F1AP_PDU_t *f1apMsg)
2532 {
2533    uint8_t idx1;
2534    ULRRCMessageTransfer_t  *ulRRCMsg;
2535
2536    if(f1apMsg != NULLP)
2537    {
2538       if(f1apMsg->choice.initiatingMessage != NULLP)
2539       {
2540          ulRRCMsg = &f1apMsg->choice.initiatingMessage->value.choice.ULRRCMessageTransfer;
2541          if(ulRRCMsg->protocolIEs.list.array != NULLP)
2542          {
2543             for(idx1=0;idx1<ulRRCMsg->protocolIEs.list.count;idx1++)
2544             {
2545                if(ulRRCMsg->protocolIEs.list.array[idx1] != NULLP)
2546                {
2547                   if(ulRRCMsg->protocolIEs.list.array[idx1]->value.present ==
2548                         ULRRCMessageTransferIEs__value_PR_RRCContainer)
2549                   {
2550                      DU_FREE(ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.buf,
2551                            ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.size);
2552                   }
2553                   DU_FREE(ulRRCMsg->protocolIEs.list.array[idx1],sizeof(ULRRCMessageTransferIEs_t));
2554                }
2555             }
2556             DU_FREE(ulRRCMsg->protocolIEs.list.array,ulRRCMsg->protocolIEs.list.size );
2557          }
2558          DU_FREE(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
2559       }
2560       DU_FREE(f1apMsg,sizeof(F1AP_PDU_t));
2561    }
2562 }
2563 /*******************************************************************
2564  *
2565  * @brief Builds and sends the ULRRCMessageTransfer
2566  *
2567  * @details
2568  *
2569  *    Function : BuildAndSendULRRCMessageTransfer
2570  *
2571  *    Functionality: Constructs the UL RRC Message Transfer and sends
2572  *                   it to the CU through SCTP.
2573  *
2574  * @params[in]
2575  *
2576  * @return ROK     - success
2577  *         RFAILED - failure
2578  *
2579  * ****************************************************************/
2580 uint8_t BuildAndSendULRRCMessageTransfer(DuUeCb  ueCb, uint8_t lcId, \
2581       uint16_t msgLen, uint8_t *rrcMsg)
2582 {
2583    uint8_t   elementCnt =0;
2584    uint8_t   idx1 =0;
2585    uint8_t   idx =0;
2586    F1AP_PDU_t                   *f1apMsg = NULLP;
2587    ULRRCMessageTransfer_t       *ulRRCMsg = NULLP;
2588    asn_enc_rval_t               encRetVal;        /* Encoder return value */
2589    uint8_t ret =RFAILED;
2590
2591    memset(&encRetVal, 0, sizeof(asn_enc_rval_t));
2592
2593    while(true)
2594    {
2595       DU_LOG("\n INFO   -->  F1AP : Building UL RRC Message Transfer Message\n");
2596
2597       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
2598       if(f1apMsg == NULLP)
2599       {
2600          DU_LOG(" ERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
2601          break;
2602       }
2603       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
2604       DU_ALLOC(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
2605       if(f1apMsg->choice.initiatingMessage == NULLP)
2606       {
2607          DU_LOG(" ERROR  -->  F1AP : Memory allocation for      F1AP-PDU failed");
2608          break;
2609       }
2610       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_ULRRCMessageTransfer;
2611       f1apMsg->choice.initiatingMessage->criticality = Criticality_ignore;
2612       f1apMsg->choice.initiatingMessage->value.present = \
2613                                                          InitiatingMessage__value_PR_ULRRCMessageTransfer;
2614       ulRRCMsg =
2615          &f1apMsg->choice.initiatingMessage->value.choice.ULRRCMessageTransfer;
2616       elementCnt = 4;
2617       ulRRCMsg->protocolIEs.list.count = elementCnt;
2618       ulRRCMsg->protocolIEs.list.size = \
2619                                         elementCnt * sizeof(ULRRCMessageTransferIEs_t *);
2620
2621       /* Initialize the F1Setup members */
2622       DU_ALLOC(ulRRCMsg->protocolIEs.list.array, ulRRCMsg->protocolIEs.list.size);
2623       if(ulRRCMsg->protocolIEs.list.array == NULLP)
2624       {
2625          DU_LOG(" ERROR  -->  F1AP : Memory allocation for UL RRC MessageTransferIEs failed");
2626          break;
2627       }
2628       for(idx=0; idx<elementCnt; idx++)
2629       {
2630          DU_ALLOC(ulRRCMsg->protocolIEs.list.array[idx],sizeof(ULRRCMessageTransferIEs_t));
2631          if(ulRRCMsg->protocolIEs.list.array[idx] == NULLP)
2632          {
2633             break;
2634          }
2635       }
2636
2637       idx1 = 0;
2638
2639       /*GNB CU UE F1AP ID*/
2640       ulRRCMsg->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
2641       ulRRCMsg->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
2642       ulRRCMsg->protocolIEs.list.array[idx1]->value.present = \
2643                                                               ULRRCMessageTransferIEs__value_PR_GNB_CU_UE_F1AP_ID;
2644       ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.GNB_CU_UE_F1AP_ID = ueCb.gnbCuUeF1apId;
2645
2646       /*GNB DU UE F1AP ID*/
2647       idx1++;
2648       ulRRCMsg->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
2649       ulRRCMsg->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
2650       ulRRCMsg->protocolIEs.list.array[idx1]->value.present = \
2651                                                               ULRRCMessageTransferIEs__value_PR_GNB_DU_UE_F1AP_ID;
2652       ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.GNB_DU_UE_F1AP_ID = ueCb.gnbDuUeF1apId;
2653
2654       /*SRBID*/
2655       idx1++;
2656       ulRRCMsg->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_SRBID;
2657       ulRRCMsg->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
2658       ulRRCMsg->protocolIEs.list.array[idx1]->value.present = \
2659                                                               ULRRCMessageTransferIEs__value_PR_SRBID;
2660       ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.SRBID = lcId;
2661
2662       /*RRCContainer*/
2663       idx1++;
2664       ulRRCMsg->protocolIEs.list.array[idx1]->id  = ProtocolIE_ID_id_RRCContainer;
2665       ulRRCMsg->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
2666       ulRRCMsg->protocolIEs.list.array[idx1]->value.present = \
2667                                                               ULRRCMessageTransferIEs__value_PR_RRCContainer;
2668       ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.size = msgLen;
2669       DU_ALLOC(ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.buf,
2670             ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.size)
2671       if(!ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.buf)
2672       {
2673          DU_LOG(" ERROR  -->  F1AP : Memory allocation for BuildAndSendULRRCMessageTransfer failed");
2674          break;
2675       }
2676       memset(ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.buf, 0, msgLen);
2677       memcpy(ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.buf, \
2678             rrcMsg, ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.size);
2679
2680       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
2681
2682       /* Encode the F1SetupRequest type as APER */
2683       memset(encBuf, 0, ENC_BUF_MAX_LEN);
2684       encBufSize = 0;
2685       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
2686             encBuf);
2687       /* Encode results */
2688       if(encRetVal.encoded == ENCODE_FAIL)
2689       {
2690          DU_LOG( "\nERROR  -->  F1AP : Could not encode ULRRCMessageTransfer structure (at %s)\n",\
2691                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
2692          break;
2693       }
2694       else
2695       {
2696          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for ULRRCMessageTransfer\n");
2697          for(int i=0; i< encBufSize; i++)
2698          {
2699             printf("%x",encBuf[i]);
2700          }
2701       }
2702
2703       /* Sending  msg  */
2704       if(SendF1APMsg(DU_APP_MEM_REGION,DU_POOL) !=      ROK)
2705       {
2706          DU_LOG("\nERROR  -->   F1AP : Sending  UL RRC Message Transfer Failed");
2707          break;
2708       }
2709       ret = ROK;
2710       break;
2711    }
2712    FreeULRRCMessageTransfer(f1apMsg);
2713
2714    return ret;
2715 }/* End of BuildAndSendULRRCMessageTransfer*/
2716
2717 /*******************************************************************
2718  *
2719  * @brief Builds tag config
2720  *
2721  * @details
2722  *
2723  *    Function : BuildTagConfig
2724  *
2725  *    Functionality: Builds tag config in MacCellGroupConfig
2726  *
2727  * @params[in] TAG_Config *tag_Config
2728  *
2729  * @return ROK     - success
2730  *         RFAILED - failure
2731  *
2732  * ****************************************************************/
2733 uint8_t BuildTagConfig(struct TAG_Config *tagConfig)
2734 {
2735    struct TAG_Config__tag_ToAddModList *tagList;
2736    uint8_t                     idx, elementCnt;
2737
2738    tagConfig->tag_ToReleaseList = NULLP;
2739    tagConfig->tag_ToAddModList = NULLP;
2740    DU_ALLOC(tagConfig->tag_ToAddModList, sizeof(struct TAG_Config__tag_ToAddModList));
2741    if(!tagConfig->tag_ToAddModList)
2742    {
2743       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildTagConfig");
2744       return RFAILED;
2745    }
2746
2747    elementCnt = 1; //ODU_VALUE_ONE;
2748    tagList = tagConfig->tag_ToAddModList;
2749    tagList->list.count = elementCnt;
2750    tagList->list.size  =  elementCnt * sizeof(struct TAG *);
2751
2752    tagList->list.array = NULLP;
2753    DU_ALLOC(tagList->list.array, tagList->list.size);
2754    if(!tagList->list.array)
2755    {
2756       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildTagConfig");
2757       return RFAILED;
2758    }
2759
2760    for(idx=0; idx<tagList->list.count; idx++)
2761    {
2762       tagList->list.array[idx] = NULLP;
2763       DU_ALLOC(tagList->list.array[idx], sizeof(struct TAG));
2764       if(!tagList->list.array[idx])
2765       {
2766          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildTagConfig");
2767          return RFAILED;
2768       }
2769    }
2770
2771    idx = 0;
2772    tagList->list.array[idx]->tag_Id = TAG_ID;
2773    tagList->list.array[idx]->timeAlignmentTimer = TIME_ALIGNMENT_TMR;
2774
2775    return ROK;
2776 }
2777
2778 /*******************************************************************
2779  *
2780  * @brief Builds PHR Config
2781  *
2782  * @details
2783  *
2784  *    Function : BuildPhrConfig
2785  *
2786  *    Functionality: Builds phrConfig in MacCellGroupConfig
2787  *
2788  * @params[in] PHR Config *
2789  *
2790  * @return ROK     - success
2791  *         RFAILED - failure
2792  *
2793  * ****************************************************************/
2794 uint8_t BuildPhrConfig(struct MAC_CellGroupConfig__phr_Config *phrConfig)
2795 {
2796
2797    phrConfig->present = MAC_CellGroupConfig__phr_Config_PR_setup;
2798    phrConfig->choice.setup = NULLP;
2799    DU_ALLOC(phrConfig->choice.setup, sizeof(struct PHR_Config));
2800    if(!phrConfig->choice.setup)
2801    {
2802       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildPhrConfig");
2803       return RFAILED;
2804    }
2805
2806    phrConfig->choice.setup->phr_PeriodicTimer        = PHR_PERIODIC_TMR;
2807    phrConfig->choice.setup->phr_ProhibitTimer        = PHR_PROHIBHIT_TMR;
2808    phrConfig->choice.setup->phr_Tx_PowerFactorChange = PHR_PWR_FACTOR_CHANGE;
2809    phrConfig->choice.setup->multiplePHR              = false;
2810    phrConfig->choice.setup->dummy                    = false;
2811    phrConfig->choice.setup->phr_Type2OtherCell       = false;
2812    phrConfig->choice.setup->phr_ModeOtherCG          = PHR_MODE_OTHER_CG;
2813
2814    return ROK;
2815 }
2816
2817 /*******************************************************************
2818  *
2819  * @brief Builds BSR Config
2820  *
2821  * @details
2822  *
2823  *    Function : BuildBsrConfig
2824  *
2825  *    Functionality: Builds BuildBsrConfig in MacCellGroupConfig
2826  *
2827  * @params[in] BSR_Config *bsrConfig
2828  *
2829  * @return ROK     - success
2830  *         RFAILED - failure
2831  *
2832  * ****************************************************************/
2833 uint8_t BuildBsrConfig(struct BSR_Config *bsrConfig)
2834 {
2835    bsrConfig->periodicBSR_Timer = PERIODIC_BSR_TMR;
2836    bsrConfig->retxBSR_Timer     = RETX_BSR_TMR;
2837    bsrConfig->logicalChannelSR_DelayTimer = NULLP;
2838
2839    return ROK;
2840 }
2841
2842 /*******************************************************************
2843  *
2844  * @brief Builds scheduling request config
2845  *
2846  * @details
2847  *
2848  *    Function : BuildSchedulingReqConfig
2849  *
2850  *    Functionality: Builds BuildSchedulingReqConfig in MacCellGroupConfig
2851  *
2852  * @params[in] SchedulingRequestConfig *schedulingRequestConfig
2853  *
2854  * @return ROK     - success
2855  *         RFAILED - failure
2856  *
2857  * ****************************************************************/
2858 uint8_t BuildSchedulingReqConfig(struct SchedulingRequestConfig *schedulingRequestConfig)
2859 {
2860    struct SchedulingRequestConfig__schedulingRequestToAddModList *schReqList;
2861    uint8_t                     idx, elementCnt;
2862
2863    schedulingRequestConfig->schedulingRequestToAddModList = NULLP;
2864    DU_ALLOC(schedulingRequestConfig->schedulingRequestToAddModList,
2865          sizeof(struct SchedulingRequestConfig__schedulingRequestToAddModList));
2866    if(!schedulingRequestConfig->schedulingRequestToAddModList)
2867    {
2868       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSchedulingReqConfig");
2869       return RFAILED;
2870    }
2871
2872    elementCnt = 1; //ODU_VALUE_ONE;
2873    schReqList = schedulingRequestConfig->schedulingRequestToAddModList;
2874    schReqList->list.count = elementCnt;
2875    schReqList->list.size  = elementCnt * sizeof(struct SchedulingRequestToAddMod *);
2876
2877    schReqList->list.array = NULLP;
2878    DU_ALLOC(schReqList->list.array, schReqList->list.size);
2879    if(!schReqList->list.array)
2880    {
2881       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSchedulingReqConfig");
2882       return RFAILED;
2883    }
2884
2885    for(idx=0;idx<schReqList->list.count; idx++)
2886    {
2887       schReqList->list.array[idx] = NULLP;
2888       DU_ALLOC(schReqList->list.array[idx], sizeof(struct SchedulingRequestToAddMod));
2889       if(!schReqList->list.array[idx])
2890       {
2891          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSchedulingReqConfig");
2892          return RFAILED;
2893       }
2894    }
2895
2896    idx = 0;
2897    schReqList->list.array[idx]->schedulingRequestId = SCH_REQ_ID;
2898
2899    schReqList->list.array[idx]->sr_ProhibitTimer = NULLP;
2900    DU_ALLOC(schReqList->list.array[idx]->sr_ProhibitTimer, sizeof(long));
2901    if(!schReqList->list.array[idx]->sr_ProhibitTimer)
2902    {
2903       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSchedulingReqConfig");
2904       return RFAILED;
2905    }
2906    *(schReqList->list.array[idx]->sr_ProhibitTimer) = SR_PROHIBIT_TMR;
2907    schReqList->list.array[idx]->sr_TransMax = SR_TRANS_MAX;
2908    schedulingRequestConfig->schedulingRequestToReleaseList = NULLP;
2909
2910    return ROK;
2911 }
2912
2913 /*******************************************************************
2914  *
2915  * @brief Builds RLC Config
2916  *
2917  * @details
2918  *
2919  *    Function : BuildRlcConfig
2920  *
2921  *    Functionality: Builds RLC Config in BuildRlcBearerToAddModList
2922  *
2923  * @params[in] RLC_Config *rlcConfig
2924  *
2925  * @return ROK     - success
2926  *         RFAILED - failure
2927  *
2928  * ****************************************************************/
2929 uint8_t BuildRlcConfig(struct RLC_Config *rlcConfig)
2930 {
2931
2932    rlcConfig->present = RLC_Config_PR_am;
2933
2934    rlcConfig->choice.am = NULLP;
2935    DU_ALLOC(rlcConfig->choice.am, sizeof(struct RLC_Config__am));
2936    if(!rlcConfig->choice.am)
2937    {
2938       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfig");
2939       return RFAILED;
2940    }
2941
2942    /* UL */
2943    rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength = NULLP;
2944    DU_ALLOC(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
2945    if(!rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength)
2946    {
2947       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfig");
2948       return RFAILED;
2949    }
2950    *(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength) = SN_FIELD_LEN;
2951    rlcConfig->choice.am->ul_AM_RLC.t_PollRetransmit  = T_POLL_RETRANSMIT;
2952    rlcConfig->choice.am->ul_AM_RLC.pollPDU           = POLL_PDU;
2953    rlcConfig->choice.am->ul_AM_RLC.pollByte          = POLL_BYTE;
2954    rlcConfig->choice.am->ul_AM_RLC.maxRetxThreshold  = MAX_RETX_THRESHOLD;
2955
2956    /* DL */
2957    rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength = NULLP;
2958    DU_ALLOC(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
2959    if(!rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength)
2960    {
2961       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfig");
2962       return RFAILED;
2963    }
2964    *(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength) = SN_FIELD_LEN;
2965    rlcConfig->choice.am->dl_AM_RLC.t_Reassembly      = T_REASSEMBLY;
2966    rlcConfig->choice.am->dl_AM_RLC.t_StatusProhibit  = T_STATUS_PROHIBHIT;
2967
2968    return ROK;
2969 }
2970
2971 /*******************************************************************
2972  *
2973  * @brief Builds MAC LC Config
2974  *
2975  * @details
2976  *
2977  *    Function : BuildMacLCConfig
2978  *
2979  *    Functionality: Builds MAC LC Config in BuildRlcBearerToAddModList
2980  *
2981  * @params[in] struct LogicalChannelConfig macLcConfig
2982  *
2983  * @return ROK     - success
2984  *         RFAILED - failure
2985  *
2986  * ****************************************************************/
2987 uint8_t BuildMacLCConfig(struct LogicalChannelConfig *macLcConfig)
2988 {
2989
2990    macLcConfig->ul_SpecificParameters = NULLP;
2991    DU_ALLOC(macLcConfig->ul_SpecificParameters, sizeof(struct LogicalChannelConfig__ul_SpecificParameters));
2992    if(!macLcConfig->ul_SpecificParameters)
2993    {
2994       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacLCConfig");
2995       return RFAILED;
2996    }
2997
2998    macLcConfig->ul_SpecificParameters->priority = MAC_LC_PRIORITY;
2999    macLcConfig->ul_SpecificParameters->prioritisedBitRate =     PRIORTISIED_BIT_RATE;
3000    macLcConfig->ul_SpecificParameters->bucketSizeDuration =     BUCKET_SIZE_DURATION;
3001    macLcConfig->ul_SpecificParameters->allowedServingCells = NULLP;
3002    macLcConfig->ul_SpecificParameters->allowedSCS_List = NULLP;
3003    macLcConfig->ul_SpecificParameters->maxPUSCH_Duration = NULLP;
3004    macLcConfig->ul_SpecificParameters->configuredGrantType1Allowed = NULLP;
3005
3006    macLcConfig->ul_SpecificParameters->logicalChannelGroup = NULLP;
3007    DU_ALLOC(macLcConfig->ul_SpecificParameters->logicalChannelGroup,    sizeof(long));
3008    if(!macLcConfig->ul_SpecificParameters->logicalChannelGroup)
3009    {
3010       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacLCConfig");
3011       return RFAILED;
3012    }
3013    *(macLcConfig->ul_SpecificParameters->logicalChannelGroup) = LC_GRP;
3014
3015    macLcConfig->ul_SpecificParameters->schedulingRequestID = NULLP;
3016    DU_ALLOC(macLcConfig->ul_SpecificParameters->schedulingRequestID,    sizeof(SchedulingRequestId_t));
3017    if(!macLcConfig->ul_SpecificParameters->schedulingRequestID)
3018    {
3019       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacLCConfig");
3020       return RFAILED;
3021    }
3022    *(macLcConfig->ul_SpecificParameters->schedulingRequestID) = SCH_REQ_ID;
3023
3024    macLcConfig->ul_SpecificParameters->logicalChannelSR_Mask = false;
3025    macLcConfig->ul_SpecificParameters->logicalChannelSR_DelayTimerApplied = false;
3026    macLcConfig->ul_SpecificParameters->bitRateQueryProhibitTimer = NULLP;
3027
3028    return ROK;
3029 }
3030
3031 /*******************************************************************
3032  *
3033  * @brief Builds RLC Bearer to Add/Mod list
3034  *
3035  * @details
3036  *
3037  *    Function :BuildRlcBearerToAddModList
3038  *
3039  *    Functionality: Builds RLC Bearer to Add/Mod list in DuToCuRrcContainer
3040  *
3041  * @params[in] rlc_BearerToAddModList
3042  *
3043  * @return ROK     - success
3044  *         RFAILED - failure
3045  *
3046  * ****************************************************************/
3047 uint8_t BuildRlcBearerToAddModList(struct CellGroupConfigRrc__rlc_BearerToAddModList *rlcBearerList)
3048 {
3049    uint8_t                     idx, elementCnt;
3050
3051    elementCnt = 1;
3052    rlcBearerList->list.count = elementCnt;
3053    rlcBearerList->list.size  = elementCnt * sizeof(struct RLC_BearerConfig *);
3054
3055    rlcBearerList->list.array = NULLP;
3056    DU_ALLOC(rlcBearerList->list.array, rlcBearerList->list.size);
3057    if(!rlcBearerList->list.array)
3058    {
3059       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
3060       return RFAILED;
3061    }
3062
3063    for(idx=0; idx<rlcBearerList->list.count; idx++)
3064    {
3065       rlcBearerList->list.array[idx] = NULLP;
3066       DU_ALLOC(rlcBearerList->list.array[idx], sizeof(struct RLC_BearerConfig));
3067       if(!rlcBearerList->list.array[idx])
3068       {
3069          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
3070          return RFAILED;
3071       }
3072    }
3073
3074    idx = 0;
3075    rlcBearerList->list.array[idx]->logicalChannelIdentity = SRB1_LCID;
3076
3077    DU_ALLOC(rlcBearerList->list.array[idx]->servedRadioBearer, \
3078       sizeof(struct RLC_BearerConfig__servedRadioBearer));
3079    if(!rlcBearerList->list.array[idx]->servedRadioBearer)
3080    {
3081       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
3082       return RFAILED;
3083    }
3084
3085    rlcBearerList->list.array[idx]->servedRadioBearer->present = \
3086       RLC_BearerConfig__servedRadioBearer_PR_srb_Identity;
3087    rlcBearerList->list.array[idx]->servedRadioBearer->choice.srb_Identity = \
3088       SRB1_LCID;
3089
3090    rlcBearerList->list.array[idx]->reestablishRLC = NULLP;
3091    rlcBearerList->list.array[idx]->rlc_Config = NULLP;
3092    DU_ALLOC(rlcBearerList->list.array[idx]->rlc_Config, sizeof(struct RLC_Config));
3093    if(!rlcBearerList->list.array[idx]->rlc_Config)
3094    {
3095       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
3096       return RFAILED;
3097    }
3098
3099    if(BuildRlcConfig(rlcBearerList->list.array[idx]->rlc_Config) != ROK)
3100    {
3101       DU_LOG("\nERROR  -->  F1AP : BuildRlcConfig failed");
3102       return RFAILED;
3103    }
3104
3105    rlcBearerList->list.array[idx]->mac_LogicalChannelConfig = NULLP;
3106    DU_ALLOC(rlcBearerList->list.array[idx]->mac_LogicalChannelConfig, \
3107       sizeof(struct LogicalChannelConfig));
3108    if(!rlcBearerList->list.array[idx]->mac_LogicalChannelConfig)
3109    {
3110       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
3111       return RFAILED;
3112    }
3113
3114    if(BuildMacLCConfig(rlcBearerList->list.array[idx]->mac_LogicalChannelConfig) != ROK)
3115    {
3116       DU_LOG("\nERROR  -->  F1AP : BuildMacLCConfig failed");
3117       return RFAILED;
3118    }
3119
3120    return ROK;
3121 }
3122
3123 /*******************************************************************
3124  *
3125  * @brief Build Control resource set to add/modify list
3126  *
3127  * @details
3128  *
3129  *    Function : BuildControlRSetToAddModList
3130  *
3131  *    Functionality: Build Control resource set to add/modify list
3132  *
3133  * @params[in]
3134  * struct PDCCH_Config__controlResourceSetToAddModList *controlRSetList
3135  *
3136  * @return ROK     - success
3137  *         RFAILED - failure
3138  *
3139  * ****************************************************************/
3140    uint8_t BuildControlRSetToAddModList
3141 (
3142  struct PDCCH_Config__controlResourceSetToAddModList *controlRSetList
3143  )
3144 {
3145    uint8_t idx;
3146    uint8_t elementCnt;
3147    uint8_t numBytes, bitsUnused;
3148    struct ControlResourceSet *controlRSet;
3149    uint8_t freqDomainResource[FREQ_DOM_RSRC_SIZE] = {0};
3150    uint8_t coreset0EndPrb, coreset1StartPrb, coreset1NumPrb;
3151
3152
3153    elementCnt = 1;
3154    controlRSetList->list.count = elementCnt;
3155    controlRSetList->list.size = \
3156                                 elementCnt * sizeof(struct ControlResourceSet *);
3157
3158    controlRSetList->list.array = NULLP;
3159    DU_ALLOC(controlRSetList->list.array, controlRSetList->list.size);
3160    if(!controlRSetList->list.array)
3161    {
3162       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3163       return RFAILED;
3164    }
3165
3166    for(idx = 0; idx < elementCnt; idx++)
3167    {
3168       controlRSetList->list.array[idx] = NULLP;
3169       DU_ALLOC(controlRSetList->list.array[idx], sizeof(struct ControlResourceSet));
3170       if(!controlRSetList->list.array[idx])
3171       {
3172          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3173          return RFAILED;
3174       }
3175    }
3176
3177    idx=0;
3178    controlRSet = controlRSetList->list.array[idx];
3179
3180    controlRSet->controlResourceSetId = PDCCH_CTRL_RSRC_SET_ONE_ID;
3181
3182    /* size 6 bytes
3183     * 3 LSBs unsued
3184     * Bit string stored ff0000000000
3185     */
3186    numBytes = 6;
3187    bitsUnused = 3;
3188    controlRSet->frequencyDomainResources.size = numBytes * sizeof(uint8_t);
3189
3190    controlRSet->frequencyDomainResources.buf = NULLP;
3191    DU_ALLOC(controlRSet->frequencyDomainResources.buf, \
3192          controlRSet->frequencyDomainResources.size);
3193    if(!controlRSet->frequencyDomainResources.buf)
3194    {
3195       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3196       return RFAILED;
3197    }
3198
3199    memset(controlRSet->frequencyDomainResources.buf, 0, FREQ_DOM_RSRC_SIZE);
3200    coreset0EndPrb = CORESET0_END_PRB;
3201    coreset1StartPrb = coreset0EndPrb + 6;
3202    coreset1NumPrb = CORESET1_NUM_PRB;
3203    /* calculate the PRBs */
3204    freqDomRscAllocType0(((coreset1StartPrb)/6), (coreset1NumPrb/6), freqDomainResource);
3205    memcpy(controlRSet->frequencyDomainResources.buf, freqDomainResource, FREQ_DOM_RSRC_SIZE);
3206    controlRSet->frequencyDomainResources.bits_unused = bitsUnused;
3207
3208    controlRSet->duration = PDCCH_CTRL_RSRC_SET_ONE_DURATION;
3209    controlRSet->cce_REG_MappingType.present = \
3210                                               ControlResourceSet__cce_REG_MappingType_PR_nonInterleaved;
3211
3212    controlRSet->precoderGranularity = PDCCH_CTRL_RSRC_SET_ONE_PRECOD_GRANULARITY;
3213    controlRSet->tci_StatesPDCCH_ToAddList = NULLP;
3214    controlRSet->tci_StatesPDCCH_ToReleaseList = NULLP;
3215    controlRSet->tci_PresentInDCI = NULLP;
3216 #if 0
3217    uint8_t tciStateIdx;
3218
3219    DU_ALLOC(controlRset->tci_StatesPDCCH_ToAddList, \
3220          sizeof(struct ControlResourceSet__tci_StatesPDCCH_ToAddList));
3221    if(!controlRset->tci_StatesPDCCH_ToAddList)
3222    {
3223       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3224       return RFAILED;
3225    }
3226
3227    elementCnt = 1;
3228    controlRset->tci_StatesPDCCH_ToAddList->list.count = elementCnt;
3229    controlRset->tci_StatesPDCCH_ToAddList->list.size = elementCnt * sizeof(TCI_StateId_t *);
3230    DU_ALLOC(controlRset->tci_StatesPDCCH_ToAddList->list.array, \
3231          controlRset->tci_StatesPDCCH_ToAddList->list.size)
3232       if(!controlRset->tci_StatesPDCCH_ToAddList->list.array)
3233       {
3234          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3235          return RFAILED;
3236       }
3237
3238    for(tciStateIdx = 0; tciStateIdx <elementCntl; tciStateIdx++)
3239    {
3240       DU_ALLOC(controlRset->tci_StatesPDCCH_ToAddList->list.array[tciStateIdx], sizeof(TCI_StateId_t));
3241       if(!controlRset->tci_StatesPDCCH_ToAddList->list.array[tciStateIdx])
3242       {
3243          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3244          return RFAILED;
3245       }
3246    }
3247
3248    tciStateIdx = 0;
3249    /* TODO */
3250    *(controlRset->tci_StatesPDCCH_ToAddList->list.array[tciStateIdx]);
3251
3252    DU_ALLOC(controlRset->tci_PresentInDCI, sizeof(long));
3253    if(!controlRset->tci_PresentInDCI)
3254    {
3255       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3256       return RFAILED;
3257    }
3258    /* TODO */
3259    *(controlRset->tci_PresentInDCI);
3260 #endif
3261
3262    controlRSet->pdcch_DMRS_ScramblingID = NULLP;
3263    DU_ALLOC(controlRSet->pdcch_DMRS_ScramblingID, sizeof(long));
3264    if(!controlRSet->pdcch_DMRS_ScramblingID)
3265    {
3266       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3267       return RFAILED;
3268    }
3269    *(controlRSet->pdcch_DMRS_ScramblingID) = SCRAMBLING_ID;
3270
3271    return ROK;
3272 } /* End BuildControlRSetToAddModList */
3273
3274 /*******************************************************************
3275  *
3276  * @brief Build search space to add/modify list
3277  *
3278  * @details
3279  *
3280  *    Function : BuildSearchSpcToAddModList
3281  *
3282  *    Functionality: Build search space to add/modify list
3283  *
3284  * @params[in]
3285  * @return ROK     - success
3286  *         RFAILED - failure
3287  *
3288  * ****************************************************************/
3289    uint8_t BuildSearchSpcToAddModList
3290 (
3291  struct PDCCH_Config__searchSpacesToAddModList *searchSpcList
3292  )
3293 {
3294    uint8_t idx;
3295    uint8_t numBytes;
3296    uint8_t byteIdx;
3297    uint8_t bitsUnused;
3298    uint8_t elementCnt;
3299    struct SearchSpace *searchSpc;
3300
3301    elementCnt = 1;
3302    searchSpcList->list.count = elementCnt;
3303    searchSpcList->list.size = elementCnt * sizeof(struct SearchSpace *);
3304
3305    searchSpcList->list.array = NULLP;
3306    DU_ALLOC(searchSpcList->list.array, searchSpcList->list.size);
3307    if(!searchSpcList->list.array)
3308    {
3309       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3310       return RFAILED;
3311    }
3312
3313    for(idx = 0; idx < elementCnt; idx++)
3314    {
3315       searchSpcList->list.array[idx] = NULLP;
3316       DU_ALLOC(searchSpcList->list.array[idx], sizeof(struct SearchSpace));
3317       if(!searchSpcList->list.array[idx])
3318       {
3319          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3320          return RFAILED;
3321       }
3322    }
3323
3324    idx = 0;
3325    searchSpc = searchSpcList->list.array[idx];
3326
3327    searchSpc->searchSpaceId = PDCCH_SRCH_SPC_TWO_ID;
3328
3329    searchSpc->controlResourceSetId = NULLP;
3330    DU_ALLOC(searchSpc->controlResourceSetId, sizeof(ControlResourceSetId_t));
3331    if(!searchSpc->controlResourceSetId)
3332    {
3333       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3334       return RFAILED;
3335    }
3336    *(searchSpc->controlResourceSetId) = PDCCH_CTRL_RSRC_SET_ONE_ID;
3337
3338    searchSpc->monitoringSlotPeriodicityAndOffset = NULLP;
3339    DU_ALLOC(searchSpc->monitoringSlotPeriodicityAndOffset, \
3340          sizeof(struct SearchSpace__monitoringSlotPeriodicityAndOffset));
3341    if(!searchSpc->monitoringSlotPeriodicityAndOffset)
3342    {
3343       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3344       return RFAILED;
3345    }
3346    searchSpc->monitoringSlotPeriodicityAndOffset->present = \
3347                                                             SearchSpace__monitoringSlotPeriodicityAndOffset_PR_sl1;
3348
3349    searchSpc->duration = NULLP;
3350    searchSpc->monitoringSymbolsWithinSlot = NULLP;
3351    DU_ALLOC(searchSpc->monitoringSymbolsWithinSlot, sizeof(BIT_STRING_t));
3352    if(!searchSpc->monitoringSymbolsWithinSlot)
3353    {
3354       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3355       return RFAILED;
3356    }
3357
3358    /* Values taken from reference logs :
3359     * size 2 bytes
3360     * 2 LSBs unsued
3361     * Bit string stores 8000
3362     */
3363    numBytes = 2;
3364    bitsUnused = 2;
3365
3366    searchSpc->monitoringSymbolsWithinSlot->size = numBytes * sizeof(uint8_t);
3367    searchSpc->monitoringSymbolsWithinSlot->buf = NULLP;
3368    DU_ALLOC(searchSpc->monitoringSymbolsWithinSlot->buf, \
3369          searchSpc->monitoringSymbolsWithinSlot->size);
3370    if(!searchSpc->monitoringSymbolsWithinSlot->buf)
3371    {
3372       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3373       return RFAILED;
3374    }
3375
3376    byteIdx = 0;
3377    searchSpc->monitoringSymbolsWithinSlot->buf[byteIdx++] = \
3378                                                             PDCCH_SYMBOL_WITHIN_SLOT /* setting MSB to 128 i.e. 0x80 */;
3379    searchSpc->monitoringSymbolsWithinSlot->buf[byteIdx++] = 0;
3380    searchSpc->monitoringSymbolsWithinSlot->bits_unused = bitsUnused;
3381
3382    searchSpc->nrofCandidates = NULLP;
3383    DU_ALLOC(searchSpc->nrofCandidates, sizeof(struct SearchSpace__nrofCandidates));
3384    if(!searchSpc->nrofCandidates)
3385    {
3386       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3387       return RFAILED;
3388    }
3389
3390    searchSpc->nrofCandidates->aggregationLevel1 = \
3391                                                   PDCCH_SRCH_SPC_TWO_AGG_LVL1_CANDIDATE;
3392    searchSpc->nrofCandidates->aggregationLevel2 = \
3393                                                   PDCCH_SRCH_SPC_TWO_AGG_LVL2_CANDIDATE;
3394    searchSpc->nrofCandidates->aggregationLevel4 = \
3395                                                   PDCCH_SRCH_SPC_TWO_AGG_LVL4_CANDIDATE;
3396    searchSpc->nrofCandidates->aggregationLevel8 = \
3397                                                   PDCCH_SRCH_SPC_TWO_AGG_LVL8_CANDIDATE;
3398    searchSpc->nrofCandidates->aggregationLevel16 = \
3399                                                    PDCCH_SRCH_SPC_TWO_AGG_LVL16_CANDIDATE;
3400
3401    searchSpc->searchSpaceType = NULLP;
3402    DU_ALLOC(searchSpc->searchSpaceType, sizeof(struct SearchSpace__searchSpaceType));
3403    if(!searchSpc->searchSpaceType)
3404    {
3405       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3406       return RFAILED;
3407    }
3408
3409    searchSpc->searchSpaceType->present = SearchSpace__searchSpaceType_PR_ue_Specific;
3410
3411    searchSpc->searchSpaceType->choice.ue_Specific = NULLP;
3412    DU_ALLOC(searchSpc->searchSpaceType->choice.ue_Specific, \
3413          sizeof(struct SearchSpace__searchSpaceType__ue_Specific));
3414    if(!searchSpc->searchSpaceType->choice.ue_Specific)
3415    {
3416       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3417       return RFAILED;
3418    }
3419    searchSpc->searchSpaceType->choice.ue_Specific->dci_Formats = \
3420                                                                  PDCCH_SRCH_SPC_TWO_UE_SPEC_DCI_FORMAT;
3421
3422    return ROK;
3423 }/* End BuildSearchSpcToAddModList */
3424
3425 /*******************************************************************
3426  *
3427  * @brief Builds BWP DL dedicated PDCCH config
3428  *
3429  * @details
3430  *
3431  *    Function : BuildBWPDlDedPdcchCfg
3432  *
3433  *    Functionality: Builds BWP DL dedicated PDCCH config
3434  *
3435  * @params[in] struct PDCCH_Config *pdcchCfg
3436  *
3437  * @return ROK     - success
3438  *         RFAILED - failure
3439  *
3440  * ****************************************************************/
3441 uint8_t BuildBWPDlDedPdcchCfg(struct PDCCH_Config *pdcchCfg)
3442 {
3443    pdcchCfg->controlResourceSetToAddModList = NULLP;
3444    DU_ALLOC(pdcchCfg->controlResourceSetToAddModList, \
3445          sizeof(struct PDCCH_Config__controlResourceSetToAddModList));
3446    if(!pdcchCfg->controlResourceSetToAddModList)
3447    {
3448       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdcchCfg");
3449       return RFAILED;
3450    }
3451
3452    if(BuildControlRSetToAddModList(pdcchCfg->controlResourceSetToAddModList) != ROK)
3453    {
3454       return RFAILED;
3455    }
3456
3457    pdcchCfg->controlResourceSetToReleaseList = NULLP;
3458
3459    pdcchCfg->searchSpacesToAddModList = NULLP;
3460    DU_ALLOC(pdcchCfg->searchSpacesToAddModList, \
3461          sizeof(struct PDCCH_Config__searchSpacesToAddModList));
3462    if(!pdcchCfg->searchSpacesToAddModList)
3463    {
3464       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdcchCfg");
3465       return RFAILED;
3466    }
3467
3468    if(BuildSearchSpcToAddModList(pdcchCfg->searchSpacesToAddModList) != ROK)
3469    {
3470       return RFAILED;
3471    }
3472
3473    pdcchCfg->searchSpacesToReleaseList = NULLP;
3474    pdcchCfg->downlinkPreemption = NULLP;
3475    pdcchCfg->tpc_PUSCH = NULLP;
3476    pdcchCfg->tpc_PUCCH = NULLP;
3477    pdcchCfg->tpc_SRS = NULLP;
3478
3479    return ROK;
3480 }
3481
3482 /*******************************************************************
3483  *
3484  * @brief Builds DMRS DL PDSCH Mapping type A
3485  *
3486  * @details
3487  *
3488  *    Function : BuildDMRSDLPdschMapTypeA
3489  *
3490  *    Functionality: Builds DMRS DL PDSCH Mapping type A
3491  *
3492  * @params[in]
3493  * struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA *dmrsDlCfg
3494  * @return ROK     - success
3495  *         RFAILED - failure
3496  *
3497  * ****************************************************************/
3498    uint8_t BuildDMRSDLPdschMapTypeA
3499 (
3500  struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA *dmrsDlCfg
3501  )
3502 {
3503    dmrsDlCfg->present = PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA_PR_setup;
3504    dmrsDlCfg->choice.setup = NULLP;
3505    DU_ALLOC(dmrsDlCfg->choice.setup, sizeof(struct DMRS_DownlinkConfig));
3506    if(!dmrsDlCfg->choice.setup)
3507    {
3508       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
3509       return RFAILED;
3510    }
3511
3512    dmrsDlCfg->choice.setup->dmrs_Type = NULLP;
3513    dmrsDlCfg->choice.setup->dmrs_AdditionalPosition = NULLP;
3514    DU_ALLOC(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition, sizeof(long));
3515    if(!dmrsDlCfg->choice.setup->dmrs_AdditionalPosition)
3516    {
3517       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSDLPdschMapTypeA");
3518       return RFAILED;
3519    }
3520    *(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition) = DMRS_ADDITIONAL_POS;
3521
3522    dmrsDlCfg->choice.setup->maxLength = NULLP;
3523    dmrsDlCfg->choice.setup->scramblingID0 = NULLP;
3524    dmrsDlCfg->choice.setup->scramblingID1 = NULLP;
3525    dmrsDlCfg->choice.setup->phaseTrackingRS = NULLP;
3526
3527    return ROK;
3528 }
3529
3530 /*******************************************************************
3531  *
3532  * @brief Builds TCI states to add/modify list
3533  *
3534  * @details
3535  *
3536  *    Function : BuildTCIStatesToAddModList
3537  *
3538  *    Functionality:Builds TCI states to add/modify list
3539  *
3540  * @params[in]
3541  * struct PDSCH_Config__tci_StatesToAddModList *tciStatesList
3542  *
3543  * @return ROK     - success
3544  *         RFAILED - failure
3545  *
3546  * ****************************************************************/
3547 uint8_t BuildTCIStatesToAddModList(struct PDSCH_Config__tci_StatesToAddModList *tciStatesList)
3548 {
3549    return ROK;
3550 }
3551
3552 /*******************************************************************
3553  *
3554  * @brief Builds PDSCH time domain allocation list
3555  *
3556  * @details
3557  *
3558  *    Function : BuildPdschTimeDomAllocList
3559  *
3560  *    Functionality: Builds PDSCH time domain allocation list
3561  *
3562  * @params[in]
3563  * struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList
3564  *
3565  * @return ROK     - success
3566  *         RFAILED - failure
3567  *
3568  * ****************************************************************/
3569    uint8_t BuildPdschTimeDomAllocList
3570 (
3571  struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList
3572  )
3573 {
3574    uint8_t idx;
3575    uint8_t elementCnt;
3576    struct PDSCH_TimeDomainResourceAllocation *timeDomAlloc;
3577
3578    timeDomAllocList->present = \
3579                                PDSCH_Config__pdsch_TimeDomainAllocationList_PR_setup;
3580
3581    timeDomAllocList->choice.setup = NULLP;
3582    DU_ALLOC(timeDomAllocList->choice.setup, \
3583          sizeof(struct PDSCH_TimeDomainResourceAllocationList));
3584    if(!timeDomAllocList->choice.setup)
3585    {
3586       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
3587       return RFAILED;
3588    }
3589
3590    elementCnt = 1;
3591    timeDomAllocList->choice.setup->list.count = elementCnt;
3592    timeDomAllocList->choice.setup->list.size = \
3593                                                elementCnt * sizeof(struct PDSCH_TimeDomainResourceAllocation *);
3594
3595    timeDomAllocList->choice.setup->list.array = NULLP;
3596    DU_ALLOC(timeDomAllocList->choice.setup->list.array, \
3597          timeDomAllocList->choice.setup->list.size);
3598    if(!timeDomAllocList->choice.setup->list.array)
3599    {
3600       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
3601       return RFAILED;
3602    }
3603
3604    for(idx = 0; idx < elementCnt; idx++)
3605    {
3606       timeDomAllocList->choice.setup->list.array[idx] = NULLP;
3607       DU_ALLOC(timeDomAllocList->choice.setup->list.array[idx], \
3608             sizeof(struct PDSCH_TimeDomainResourceAllocation));
3609       if(!timeDomAllocList->choice.setup->list.array[idx])
3610       {
3611          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
3612          return RFAILED;
3613       }
3614    }
3615
3616    idx = 0;
3617    timeDomAlloc = timeDomAllocList->choice.setup->list.array[idx];
3618
3619    timeDomAlloc->k0 = NULLP;
3620    timeDomAlloc->mappingType = PDSCH_MAPPING_TYPE_A;
3621    timeDomAlloc->startSymbolAndLength = \
3622                                         calcSliv(PDSCH_START_SYMBOL, PDSCH_LENGTH_SYMBOL);
3623
3624    return ROK;
3625 }
3626
3627 /*******************************************************************
3628  *
3629  * @brief Builds PDSCH PRB Bundling type
3630  *
3631  * @details
3632  *
3633  *    Function : BuildPdschPrbBundlingType
3634  *
3635  *    Functionality: Builds PDSCH PRB Bundling type
3636  *
3637  * @params[in]
3638  * struct PDSCH_Config__prb_BundlingType *prbBndlType
3639  *
3640  * @return ROK     - success
3641  *         RFAILED - failure
3642  *
3643  * ****************************************************************/
3644    uint8_t BuildPdschPrbBundlingType
3645 (
3646  struct PDSCH_Config__prb_BundlingType *prbBndlType
3647  )
3648 {
3649    prbBndlType->present = PDSCH_Config__prb_BundlingType_PR_staticBundling;
3650
3651    prbBndlType->choice.staticBundling = NULLP;
3652    DU_ALLOC(prbBndlType->choice.staticBundling, \
3653          sizeof(struct PDSCH_Config__prb_BundlingType__staticBundling));
3654    if(!prbBndlType->choice.staticBundling)
3655    {
3656       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschPrbBundlingType");
3657       return RFAILED;
3658    }
3659    prbBndlType->choice.staticBundling->bundleSize = NULLP;
3660
3661    return ROK;
3662 }
3663
3664 /*******************************************************************
3665  *
3666  * @brief Builds BWP DL dedicated PDSCH config
3667  *
3668  * @details
3669  *
3670  *    Function : BuildBWPDlDedPdschCfg
3671  *
3672  *    Functionality: Builds BWP DL dedicated PDSCH config
3673  *
3674  * @params[in] struct PDSCH_Config *pdschCfg
3675  *
3676  * @return ROK     - success
3677  *         RFAILED - failure
3678  *
3679  * ****************************************************************/
3680 uint8_t BuildBWPDlDedPdschCfg(struct PDSCH_Config *pdschCfg)
3681 {
3682    pdschCfg->dataScramblingIdentityPDSCH = NULLP;
3683
3684    pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA = NULLP;
3685    DU_ALLOC(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA, \
3686          sizeof(struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA));
3687    if(!pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA)
3688    {
3689       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
3690       return RFAILED;
3691    }
3692
3693    if(BuildDMRSDLPdschMapTypeA(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA) != ROK)
3694    {
3695       return RFAILED;
3696    }
3697
3698    pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeB = NULLP;
3699    pdschCfg->tci_StatesToAddModList = NULLP;
3700    pdschCfg->tci_StatesToReleaseList = NULLP;
3701    pdschCfg->vrb_ToPRB_Interleaver = NULLP;
3702 #if 0
3703    DU_ALLOC(pdschCfg->tci_StatesToAddModList, sizeof(struct PDSCH_Config__tci_StatesToAddModList));
3704    if(!pdschCfg->tci_StatesToAddModList)
3705    {
3706       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
3707       return RFAILED;
3708    }
3709    if(BuildTCIStatesToAddModList(pdschCfg->tci_StatesToAddModList) != ROK)
3710    {
3711       return RFAILED;
3712    }
3713 #endif
3714
3715    pdschCfg->resourceAllocation = RES_ALLOC_TYPE;
3716
3717    pdschCfg->pdsch_TimeDomainAllocationList = NULLP;
3718    DU_ALLOC(pdschCfg->pdsch_TimeDomainAllocationList, \
3719          sizeof(struct PDSCH_Config__pdsch_TimeDomainAllocationList));
3720    if(!pdschCfg->pdsch_TimeDomainAllocationList)
3721    {
3722       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
3723       return RFAILED;
3724    }
3725
3726    if(BuildPdschTimeDomAllocList(pdschCfg->pdsch_TimeDomainAllocationList) != ROK)
3727    {
3728       return RFAILED;
3729    }
3730
3731    pdschCfg->pdsch_AggregationFactor = NULLP;
3732    pdschCfg->rateMatchPatternToAddModList = NULLP;
3733    pdschCfg->rateMatchPatternToReleaseList = NULLP;
3734    pdschCfg->rateMatchPatternGroup1 = NULLP;
3735    pdschCfg->rateMatchPatternGroup2 = NULLP;
3736    pdschCfg->rbg_Size = PDSCH_RBG_SIZE;
3737    pdschCfg->mcs_Table = NULLP;
3738
3739    pdschCfg->maxNrofCodeWordsScheduledByDCI = NULLP;
3740    DU_ALLOC(pdschCfg->maxNrofCodeWordsScheduledByDCI, sizeof(long));
3741    if(!pdschCfg->maxNrofCodeWordsScheduledByDCI)
3742    {
3743       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
3744       return RFAILED;
3745    }
3746    *(pdschCfg->maxNrofCodeWordsScheduledByDCI) = PDSCH_MAX_CODEWORD_SCH_BY_DCI;
3747
3748    if(BuildPdschPrbBundlingType(&pdschCfg->prb_BundlingType) != ROK)
3749    {
3750       return RFAILED;
3751    }
3752
3753    pdschCfg->zp_CSI_RS_ResourceToAddModList = NULLP;
3754    pdschCfg->zp_CSI_RS_ResourceToReleaseList = NULLP;
3755    pdschCfg->aperiodic_ZP_CSI_RS_ResourceSetsToAddModList = NULLP;
3756    pdschCfg->aperiodic_ZP_CSI_RS_ResourceSetsToReleaseList = NULLP;
3757    pdschCfg->sp_ZP_CSI_RS_ResourceSetsToAddModList = NULLP;
3758    pdschCfg->sp_ZP_CSI_RS_ResourceSetsToReleaseList = NULLP;
3759    pdschCfg->p_ZP_CSI_RS_ResourceSet = NULLP;
3760
3761    return ROK;
3762 }
3763
3764 /*******************************************************************
3765  *
3766  * @brief Builds intitial DL BWP
3767  * @details
3768  *
3769  *    Function : BuildInitialDlBWP
3770  *
3771  *    Functionality: Builds intitial DL BWP in spCellCfgDed
3772  *
3773  * @params[in] BWP_DownlinkDedicated_t *dlBwp
3774  *
3775  * @return ROK     - success
3776  *         RFAILED - failure
3777  *
3778  * ****************************************************************/
3779 uint8_t BuildInitialDlBWP(BWP_DownlinkDedicated_t *dlBwp)
3780 {
3781    dlBwp->pdcch_Config = NULLP;
3782    DU_ALLOC(dlBwp->pdcch_Config, sizeof(struct BWP_DownlinkDedicated__pdcch_Config));
3783    if(!dlBwp->pdcch_Config)
3784    {
3785       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failure in BuildInitialDlBWP");
3786       return RFAILED;
3787    }
3788    dlBwp->pdcch_Config->present = BWP_DownlinkDedicated__pdcch_Config_PR_setup;
3789
3790    dlBwp->pdcch_Config->choice.setup = NULLP;
3791    DU_ALLOC(dlBwp->pdcch_Config->choice.setup, sizeof(struct PDCCH_Config));
3792    if(!dlBwp->pdcch_Config->choice.setup)
3793    {
3794       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failure in BuildInitialDlBWP");
3795       return RFAILED;
3796    }
3797    if(BuildBWPDlDedPdcchCfg(dlBwp->pdcch_Config->choice.setup) != ROK)
3798    {
3799       return RFAILED;
3800    }
3801
3802    dlBwp->pdsch_Config = NULLP;
3803    DU_ALLOC(dlBwp->pdsch_Config, sizeof(struct BWP_DownlinkDedicated__pdsch_Config));
3804    if(!dlBwp->pdsch_Config)
3805    {
3806       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failure in BuildInitialDlBWP");
3807       return RFAILED;
3808    }
3809    dlBwp->pdsch_Config->present = BWP_DownlinkDedicated__pdsch_Config_PR_setup;
3810
3811    dlBwp->pdsch_Config->choice.setup = NULLP;
3812    DU_ALLOC(dlBwp->pdsch_Config->choice.setup, sizeof(struct PDSCH_Config));
3813    if(!dlBwp->pdsch_Config->choice.setup)
3814    {
3815       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failure in BuildInitialDlBWP");
3816       return RFAILED;
3817    }
3818
3819    if(BuildBWPDlDedPdschCfg(dlBwp->pdsch_Config->choice.setup) != ROK)
3820    {
3821       return RFAILED;
3822    }
3823
3824    dlBwp->sps_Config = NULLP;
3825    dlBwp->radioLinkMonitoringConfig = NULLP;
3826    return ROK;
3827 }
3828
3829 /*******************************************************************
3830  *
3831  * @brief Builds DMRS UL Pusch Mapping type A
3832  *
3833  * @details
3834  *
3835  *    Function : BuildDMRSULPuschMapTypeA
3836  *
3837  *    Functionality: Builds DMRS UL Pusch Mapping type A
3838  *
3839  * @params[in]
3840  *    struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA *dmrsUlCfg
3841  * @return ROK     - success
3842  *         RFAILED - failure
3843  *
3844  * ****************************************************************/
3845    uint8_t BuildDMRSULPuschMapTypeA
3846 (
3847  struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA *dmrsUlCfg
3848  )
3849 {
3850    dmrsUlCfg->present = PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA_PR_setup;
3851    dmrsUlCfg->choice.setup= NULLP;
3852    DU_ALLOC(dmrsUlCfg->choice.setup, sizeof(DMRS_UplinkConfig_t));
3853    if(!dmrsUlCfg->choice.setup)
3854    {
3855       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
3856       return RFAILED;
3857    }
3858
3859    dmrsUlCfg->choice.setup->dmrs_Type = NULLP;
3860    dmrsUlCfg->choice.setup->dmrs_AdditionalPosition = NULLP;
3861    DU_ALLOC(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition, sizeof(long));
3862    if(!dmrsUlCfg->choice.setup->dmrs_AdditionalPosition)
3863    {
3864       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
3865       return RFAILED;
3866    }
3867    *(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition) = DMRS_ADDITIONAL_POS;
3868
3869    dmrsUlCfg->choice.setup->phaseTrackingRS = NULLP;
3870    dmrsUlCfg->choice.setup->maxLength = NULLP;
3871    dmrsUlCfg->choice.setup->transformPrecodingDisabled = NULLP;
3872    DU_ALLOC(dmrsUlCfg->choice.setup->transformPrecodingDisabled, \
3873          sizeof(struct DMRS_UplinkConfig__transformPrecodingDisabled));
3874    if(!dmrsUlCfg->choice.setup->transformPrecodingDisabled)
3875    {
3876       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
3877       return RFAILED;
3878    }
3879
3880    dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0 = NULLP;
3881    DU_ALLOC(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0,\
3882          sizeof(long));
3883    if(!dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0)
3884    {
3885       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
3886       return RFAILED;
3887    }
3888    *(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0) = SCRAMBLING_ID;
3889
3890    dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID1 = NULLP;
3891    dmrsUlCfg->choice.setup->transformPrecodingEnabled = NULLP;
3892    return ROK;
3893 }
3894
3895 /*******************************************************************
3896  *
3897  * @brief Build PUSCH time domain allocation list
3898  *
3899  * @details
3900  *
3901  *    Function : BuildPuschTimeDomAllocList
3902  *
3903  *    Functionality: Build PUSCH time domain allocation list
3904  *
3905  * @params[in]
3906  * struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList
3907  *
3908  * @return ROK     - success
3909  *         RFAILED - failure
3910  *
3911  * ****************************************************************/
3912    uint8_t BuildPuschTimeDomAllocList
3913 (
3914  struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList
3915  )
3916 {
3917    uint8_t idx;
3918    uint8_t elementCnt;
3919    PUSCH_TimeDomainResourceAllocation_t  *timeDomAlloc;
3920
3921    timeDomAllocList->present = PUSCH_Config__pusch_TimeDomainAllocationList_PR_setup;
3922    timeDomAllocList->choice.setup = NULLP;
3923    DU_ALLOC(timeDomAllocList->choice.setup, \
3924          sizeof(struct PUSCH_TimeDomainResourceAllocationList));
3925    if(!timeDomAllocList->choice.setup)
3926    {
3927       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
3928       return RFAILED;
3929    }
3930
3931    elementCnt = 1;
3932    timeDomAllocList->choice.setup->list.count = elementCnt;
3933    timeDomAllocList->choice.setup->list.size = \
3934                                                elementCnt * sizeof(PUSCH_TimeDomainResourceAllocation_t *);
3935    timeDomAllocList->choice.setup->list.array = NULLP;
3936    DU_ALLOC(timeDomAllocList->choice.setup->list.array, \
3937          timeDomAllocList->choice.setup->list.size);
3938    if(!timeDomAllocList->choice.setup->list.array)
3939    {
3940       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
3941       return RFAILED;
3942    }
3943
3944    for(idx = 0; idx < elementCnt; idx++)
3945    {
3946       timeDomAllocList->choice.setup->list.array[idx] = NULLP;
3947       DU_ALLOC(timeDomAllocList->choice.setup->list.array[idx],\
3948             sizeof(PUSCH_TimeDomainResourceAllocation_t));
3949       if(!timeDomAllocList->choice.setup->list.array[idx])
3950       {
3951          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
3952          return RFAILED;
3953       }
3954    }
3955
3956    idx = 0;
3957    timeDomAlloc = timeDomAllocList->choice.setup->list.array[idx];
3958    DU_ALLOC(timeDomAlloc->k2, sizeof(long));
3959    if(!timeDomAlloc->k2)
3960    {
3961       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
3962       return RFAILED;
3963    }
3964    *(timeDomAlloc->k2) = PUSCH_K2;
3965    timeDomAlloc->mappingType = PUSCH_MAPPING_TYPE_A;
3966    timeDomAlloc->startSymbolAndLength = calcSliv(PUSCH_START_SYMBOL, PUSCH_LENGTH_SYMBOL);
3967    return ROK;
3968 }
3969
3970 /*******************************************************************
3971  *
3972  * @brief Builds BWP UL dedicated PUSCH Config
3973  *
3974  * @details
3975  *
3976  *    Function : BuildBWPUlDedPuschCfg
3977  *
3978  *    Functionality:
3979  *      Builds BWP UL dedicated PUSCH Config
3980  *
3981  * @params[in] : PUSCH_Config_t *puschCfg
3982  *
3983  * @return ROK     - success
3984  *         RFAILED - failure
3985  *
3986  * ****************************************************************/
3987 uint8_t BuildBWPUlDedPuschCfg(PUSCH_Config_t *puschCfg)
3988 {
3989    puschCfg->dataScramblingIdentityPUSCH = NULLP;
3990    DU_ALLOC(puschCfg->dataScramblingIdentityPUSCH, sizeof(long));
3991    if(!puschCfg->dataScramblingIdentityPUSCH)
3992    {
3993       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
3994       return RFAILED;
3995    }
3996    *(puschCfg->dataScramblingIdentityPUSCH) = SCRAMBLING_ID;
3997
3998    puschCfg->txConfig = NULLP;
3999    puschCfg->dmrs_UplinkForPUSCH_MappingTypeA = NULLP;
4000    DU_ALLOC(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA, \
4001          sizeof(struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA));
4002    if(!puschCfg->dmrs_UplinkForPUSCH_MappingTypeA)
4003    {
4004       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
4005       return RFAILED;
4006    }
4007
4008    if(BuildDMRSULPuschMapTypeA(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA) != ROK)
4009    {
4010       return RFAILED;
4011    }
4012
4013    puschCfg->dmrs_UplinkForPUSCH_MappingTypeB = NULLP;
4014    puschCfg->pusch_PowerControl = NULLP;
4015    puschCfg->frequencyHopping = NULLP;
4016    puschCfg->frequencyHoppingOffsetLists = NULLP;
4017    puschCfg->resourceAllocation = RES_ALLOC_TYPE;
4018
4019    puschCfg->pusch_TimeDomainAllocationList = NULLP;
4020    DU_ALLOC(puschCfg->pusch_TimeDomainAllocationList, \
4021          sizeof(struct PUSCH_Config__pusch_TimeDomainAllocationList));
4022    if(!puschCfg->pusch_TimeDomainAllocationList)
4023    {
4024       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
4025       return RFAILED;
4026    }
4027
4028    if(BuildPuschTimeDomAllocList(puschCfg->pusch_TimeDomainAllocationList) != ROK)
4029    {
4030       return RFAILED;
4031    }
4032
4033    puschCfg->pusch_AggregationFactor = NULLP;
4034    puschCfg->mcs_Table = NULLP;
4035    puschCfg->mcs_TableTransformPrecoder = NULLP;
4036    puschCfg->transformPrecoder = NULLP;
4037    DU_ALLOC(puschCfg->transformPrecoder, sizeof(long));
4038    if(!puschCfg->transformPrecoder)
4039    {
4040       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
4041       return RFAILED;
4042    }
4043    *(puschCfg->transformPrecoder) = PUSCH_TRANSFORM_PRECODER;
4044
4045    puschCfg->codebookSubset = NULLP;
4046    puschCfg->maxRank = NULLP;
4047    puschCfg->rbg_Size = NULLP;
4048    puschCfg->uci_OnPUSCH = NULLP;
4049    puschCfg->tp_pi2BPSK = NULLP;
4050
4051    return ROK;
4052 }
4053
4054 /*******************************************************************
4055  *
4056  * @brief Fills SRS resource to add/modify list
4057  *
4058  * @details
4059  *
4060  *    Function : BuildSrsRsrcAddModList
4061  *
4062  *    Functionality: Fills SRS resource to add/modify list
4063  *
4064  * @params[in]
4065  * @return ROK     - success
4066  *         RFAILED - failure
4067  *
4068  * ****************************************************************/
4069 uint8_t BuildSrsRsrcAddModList(struct SRS_Config__srs_ResourceToAddModList *resourceList)
4070 {
4071    uint8_t   elementCnt;
4072    uint8_t   rsrcIdx;
4073
4074    elementCnt = 1;
4075    resourceList->list.count = elementCnt;
4076    resourceList->list.size = elementCnt * sizeof(SRS_Resource_t *);
4077    resourceList->list.array = NULLP;
4078    DU_ALLOC(resourceList->list.array, resourceList->list.size);
4079    if(!resourceList->list.array)
4080    {
4081       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcAddModList");
4082       return RFAILED;
4083    }
4084
4085    for(rsrcIdx = 0; rsrcIdx < resourceList->list.count; rsrcIdx++)
4086    {
4087       DU_ALLOC(resourceList->list.array[rsrcIdx], sizeof(SRS_Resource_t));
4088       if(!resourceList->list.array[rsrcIdx])
4089       {
4090          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcAddModList");
4091          return RFAILED;
4092       }
4093    }
4094
4095    rsrcIdx = 0;
4096    resourceList->list.array[rsrcIdx]->srs_ResourceId = SRS_RSRC_ID;
4097    resourceList->list.array[rsrcIdx]->nrofSRS_Ports = SRS_Resource__nrofSRS_Ports_port1;
4098    resourceList->list.array[rsrcIdx]->transmissionComb.present = SRS_Resource__transmissionComb_PR_n2;
4099
4100    resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2 = NULLP;
4101    DU_ALLOC(resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2, \
4102          sizeof(struct SRS_Resource__transmissionComb__n2));
4103    if(!resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2)
4104    {
4105       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcAddModList");
4106       return RFAILED;
4107    }
4108    resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2->combOffset_n2\
4109       = SRS_COMB_OFFSET_N2;
4110    resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2->cyclicShift_n2\
4111       = SRS_CYCLIC_SHIFT_N2;
4112
4113    resourceList->list.array[rsrcIdx]->resourceMapping.startPosition = \
4114                                                                       PUSCH_START_SYMBOL;
4115    resourceList->list.array[rsrcIdx]->resourceMapping.nrofSymbols =  \
4116                                                                      SRS_Resource__resourceMapping__nrofSymbols_n1;
4117    resourceList->list.array[rsrcIdx]->resourceMapping.repetitionFactor = \
4118                                                                          SRS_Resource__resourceMapping__repetitionFactor_n1;
4119
4120    resourceList->list.array[rsrcIdx]->freqDomainPosition = SRS_FREQ_DOM_POS;
4121    resourceList->list.array[rsrcIdx]->freqDomainShift = SRS_FREQ_DOM_SHIFT;
4122    resourceList->list.array[rsrcIdx]->freqHopping.c_SRS = C_SRS;
4123    resourceList->list.array[rsrcIdx]->freqHopping.b_SRS = B_SRS;
4124    resourceList->list.array[rsrcIdx]->freqHopping.b_hop = B_HOP;
4125    resourceList->list.array[rsrcIdx]->groupOrSequenceHopping = \
4126                                                                SRS_Resource__groupOrSequenceHopping_neither;
4127
4128    /* Setting resource type to aperiodic for intergration purposes */
4129    resourceList->list.array[rsrcIdx]->resourceType.present = \
4130                                                              SRS_Resource__resourceType_PR_aperiodic;
4131    resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic = NULLP;
4132    DU_ALLOC(resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic,
4133          sizeof(struct SRS_Resource__resourceType__aperiodic));
4134    if(!resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic)
4135    {
4136       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcAddModList");
4137       return RFAILED;
4138    }
4139    resourceList->list.array[rsrcIdx]->sequenceId = SRS_SEQ_ID;
4140
4141    return ROK;
4142 }
4143
4144 /*******************************************************************
4145  *
4146  * @brief Build SRS resource set Add/mod list
4147  *
4148  * @details
4149  *
4150  *    Function : BuildSrsRsrcSetAddModList
4151  *
4152  *    Functionality: Build SRS resource set Add/mod list
4153  *
4154  * @params[in]
4155  * @return ROK     - success
4156  *         RFAILED - failure
4157  *
4158  * ****************************************************************/
4159    uint8_t BuildSrsRsrcSetAddModList
4160 (
4161  struct SRS_Config__srs_ResourceSetToAddModList *rsrcSetList
4162  )
4163 {
4164    uint8_t  elementCnt;
4165    uint8_t  rSetIdx;
4166    uint8_t  rsrcIdx;
4167    struct SRS_ResourceSet__srs_ResourceIdList *rsrcIdList;
4168
4169    elementCnt = 1;
4170    rsrcSetList->list.count = elementCnt;
4171    rsrcSetList->list.size = elementCnt * sizeof(SRS_ResourceSet_t *);
4172    rsrcSetList->list.array = NULLP;
4173    DU_ALLOC(rsrcSetList->list.array, rsrcSetList->list.size);
4174    if(!rsrcSetList->list.array)
4175    {
4176       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
4177       return RFAILED;
4178    }
4179
4180    for(rSetIdx = 0; rSetIdx < rsrcSetList->list.count; rSetIdx++)
4181    {
4182       DU_ALLOC(rsrcSetList->list.array[rSetIdx], sizeof(SRS_ResourceSet_t));
4183       if(!rsrcSetList->list.array[rSetIdx])
4184       {
4185          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
4186          return RFAILED;
4187       }
4188    }
4189
4190    rSetIdx = 0;
4191    rsrcSetList->list.array[rSetIdx]->srs_ResourceSetId = SRS_RSET_ID;
4192
4193    /* Fill Resource Id list in resource set */
4194    rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList = NULLP;
4195    DU_ALLOC(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList,\
4196          sizeof(struct SRS_ResourceSet__srs_ResourceIdList));
4197    if(!rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList)
4198    {
4199       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
4200       return RFAILED;
4201    }
4202
4203    elementCnt = 1;
4204    rsrcIdList = rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList;
4205    rsrcIdList->list.count = elementCnt;
4206    rsrcIdList->list.size = elementCnt * sizeof(SRS_ResourceId_t *);
4207    rsrcIdList->list.array = NULLP;
4208    DU_ALLOC(rsrcIdList->list.array, rsrcIdList->list.size);
4209    if(!rsrcIdList->list.array)
4210    {
4211       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
4212       return RFAILED;
4213    }
4214
4215    for(rsrcIdx = 0; rsrcIdx < rsrcIdList->list.count; rsrcIdx++)
4216    {
4217       DU_ALLOC(rsrcIdList->list.array[rsrcIdx], sizeof(SRS_ResourceId_t));
4218       if(!rsrcIdList->list.array[rsrcIdx])
4219       {
4220          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
4221          return RFAILED;
4222       }
4223    }
4224
4225    rsrcIdx = 0;
4226    *rsrcIdList->list.array[rsrcIdx] = SRS_RSRC_ID;
4227
4228    /* Fill resource type */
4229    rsrcSetList->list.array[rSetIdx]->resourceType.present = \
4230                                                             SRS_ResourceSet__resourceType_PR_aperiodic;
4231
4232    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic = NULLP;
4233    DU_ALLOC(rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic, \
4234          sizeof(struct SRS_ResourceSet__resourceType__aperiodic));
4235    if(!rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic)
4236    {
4237       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
4238       return RFAILED;
4239    }
4240    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic->aperiodicSRS_ResourceTrigger \
4241       = APERIODIC_SRS_RESRC_TRIGGER;
4242
4243    /* TODO : Fill values for below IEs as expected by Viavi */
4244    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic->csi_RS = NULLP;
4245    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic->slotOffset = NULLP;
4246
4247
4248    rsrcSetList->list.array[rSetIdx]->usage = SRS_ResourceSet__usage_codebook;
4249    rsrcSetList->list.array[rSetIdx]->alpha = NULLP;
4250    rsrcSetList->list.array[rSetIdx]->p0 = NULLP;
4251    rsrcSetList->list.array[rSetIdx]->pathlossReferenceRS = NULLP;
4252    rsrcSetList->list.array[rSetIdx]->srs_PowerControlAdjustmentStates = NULLP;
4253
4254    return ROK;
4255 }
4256
4257 /*******************************************************************
4258  *
4259  * @brief Builds BWP UL dedicated SRS Config
4260  *
4261  * @details
4262  *
4263  *    Function : BuildBWPUlDedSrsCfg
4264  *
4265  *    Functionality: Builds BWP UL dedicated SRS Config
4266  *
4267  * @params[in] SRS Config
4268  * @return ROK     - success
4269  *         RFAILED - failure
4270  *
4271  * ****************************************************************/
4272 uint8_t BuildBWPUlDedSrsCfg(SRS_Config_t *srsCfg)
4273 {
4274    srsCfg->srs_ResourceSetToReleaseList = NULLP;
4275    srsCfg->srs_ResourceSetToAddModList = NULLP;
4276    DU_ALLOC(srsCfg->srs_ResourceSetToAddModList, \
4277          sizeof(struct SRS_Config__srs_ResourceSetToAddModList));
4278    if(!srsCfg->srs_ResourceSetToAddModList)
4279    {
4280       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedSrsCfg");
4281       return RFAILED;
4282    }
4283    if(BuildSrsRsrcSetAddModList(srsCfg->srs_ResourceSetToAddModList) != ROK)
4284    {
4285       return RFAILED;
4286    }
4287
4288    srsCfg->srs_ResourceToReleaseList = NULLP;
4289
4290    /* Resource to Add/Modify list */
4291    srsCfg->srs_ResourceToAddModList = NULLP;
4292    DU_ALLOC(srsCfg->srs_ResourceToAddModList, \
4293          sizeof(struct SRS_Config__srs_ResourceToAddModList));
4294    if(!srsCfg->srs_ResourceToAddModList)
4295    {
4296       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedSrsCfg");
4297       return RFAILED;
4298    }
4299
4300    if(BuildSrsRsrcAddModList(srsCfg->srs_ResourceToAddModList) != ROK)
4301    {
4302       return RFAILED;
4303    }
4304
4305    srsCfg->tpc_Accumulation = NULLP;
4306
4307    return ROK;
4308 }
4309
4310
4311
4312 /*******************************************************************
4313  *
4314  * @brief Builds Pusch Serving cell Config
4315  *
4316  * @details
4317  *
4318  *    Function : BuildPuschSrvCellCfg
4319  *
4320  *    Functionality: Builds Pusch Serving cell Config
4321  *
4322  * @params[in] struct UplinkConfig__pusch_ServingCellConfig *puschCfg
4323  *
4324  * @return ROK     - success
4325  *         RFAILED - failure
4326  *
4327  * ****************************************************************/
4328 uint8_t BuildPuschSrvCellCfg(struct UplinkConfig__pusch_ServingCellConfig *puschCfg)
4329 {
4330    puschCfg->present = UplinkConfig__pusch_ServingCellConfig_PR_setup;
4331    puschCfg->choice.setup = NULLP;
4332    DU_ALLOC(puschCfg->choice.setup, sizeof(struct PUSCH_ServingCellConfig));
4333    if(!puschCfg->choice.setup)
4334    {
4335       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
4336       return RFAILED;
4337    }
4338
4339    puschCfg->choice.setup->codeBlockGroupTransmission = NULLP;
4340    puschCfg->choice.setup->rateMatching = NULLP;
4341    puschCfg->choice.setup->xOverhead = NULLP;
4342    puschCfg->choice.setup->ext1 = NULLP;
4343    DU_ALLOC(puschCfg->choice.setup->ext1, sizeof(struct PUSCH_ServingCellConfig__ext1));
4344    if(!puschCfg->choice.setup->ext1)
4345    {
4346       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
4347       return RFAILED;
4348    }
4349
4350    puschCfg->choice.setup->ext1->maxMIMO_Layers = NULLP;
4351    DU_ALLOC(puschCfg->choice.setup->ext1->maxMIMO_Layers, sizeof(long));
4352    if(!puschCfg->choice.setup->ext1->maxMIMO_Layers)
4353    {
4354       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
4355       return RFAILED;
4356    }
4357    *(puschCfg->choice.setup->ext1->maxMIMO_Layers) = PUSCH_MAX_MIMO_LAYERS;
4358
4359    puschCfg->choice.setup->ext1->processingType2Enabled= NULLP;
4360    DU_ALLOC(puschCfg->choice.setup->ext1->processingType2Enabled,sizeof(BOOLEAN_t));
4361    if(!puschCfg->choice.setup->ext1->processingType2Enabled)
4362    {
4363       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
4364       return RFAILED;
4365    }
4366    *(puschCfg->choice.setup->ext1->processingType2Enabled) = PUSCH_PROCESS_TYPE2_ENABLED;
4367    return ROK;
4368 }
4369
4370 /*******************************************************************
4371  *
4372  * @brief Builds inital UL BWP
4373  *
4374  * @details
4375  *
4376  *    Function : BuildInitialUlBWP
4377  *
4378  *    Functionality: Builds initial UL BWP
4379  *
4380  * @params[in] BWP_UplinkDedicated_t *ulBwp
4381  * @return ROK     - success
4382  *         RFAILED - failure
4383  *
4384  * ****************************************************************/
4385 uint8_t BuildInitialUlBWP(BWP_UplinkDedicated_t *ulBwp)
4386 {
4387    ulBwp->pucch_Config = NULLP;
4388
4389    /* Fill BWP UL dedicated PUSCH config */
4390    ulBwp->pusch_Config = NULLP;
4391    DU_ALLOC(ulBwp->pusch_Config, sizeof(struct BWP_UplinkDedicated__pusch_Config));
4392    if(!ulBwp->pusch_Config)
4393    {
4394       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
4395       return RFAILED;
4396    }
4397
4398    ulBwp->pusch_Config->present = BWP_UplinkDedicated__pusch_Config_PR_setup;
4399    ulBwp->pusch_Config->choice.setup = NULLP;
4400    DU_ALLOC(ulBwp->pusch_Config->choice.setup, sizeof(PUSCH_Config_t));
4401    if(!ulBwp->pusch_Config->choice.setup)
4402    {
4403       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
4404       return RFAILED;
4405    }
4406
4407    if(BuildBWPUlDedPuschCfg(ulBwp->pusch_Config->choice.setup) != ROK)
4408    {
4409       return RFAILED;
4410    }
4411
4412    ulBwp->configuredGrantConfig = NULLP;
4413
4414    /* Fill BPW UL dedicated SRS config */
4415    ulBwp->srs_Config = NULLP;
4416    DU_ALLOC(ulBwp->srs_Config, sizeof(struct BWP_UplinkDedicated__srs_Config));
4417    if(!ulBwp->srs_Config)
4418    {
4419       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
4420       return RFAILED;
4421    }
4422
4423    ulBwp->srs_Config->present = BWP_UplinkDedicated__srs_Config_PR_setup;
4424    ulBwp->srs_Config->choice.setup = NULLP;
4425    DU_ALLOC(ulBwp->srs_Config->choice.setup, sizeof(SRS_Config_t));
4426    if(!ulBwp->srs_Config->choice.setup)
4427    {
4428       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
4429       return RFAILED;
4430    }
4431
4432    if(BuildBWPUlDedSrsCfg(ulBwp->srs_Config->choice.setup) != ROK)
4433    {
4434       return RFAILED;
4435    }
4436
4437    ulBwp->beamFailureRecoveryConfig = NULLP;
4438
4439    return ROK;
4440 }
4441
4442 /*******************************************************************
4443  *
4444  * @brief Builds UL config
4445  * @details
4446  *
4447  *    Function : BuildUlCfg
4448  *
4449  *    Functionality: Builds UL config in spCellCfgDed
4450  *
4451  * @params[in] UplinkConfig_t *ulCfg
4452  *
4453  * @return ROK     - success
4454  *         RFAILED - failure
4455  *
4456  * ****************************************************************/
4457 uint8_t BuildUlCfg(UplinkConfig_t *ulCfg)
4458 {
4459    ulCfg->initialUplinkBWP = NULLP;
4460    DU_ALLOC(ulCfg->initialUplinkBWP, sizeof(BWP_UplinkDedicated_t));
4461    if(!ulCfg->initialUplinkBWP)
4462    {
4463       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failed in BuildUlCfg");
4464       return RFAILED;
4465    }
4466
4467    if(BuildInitialUlBWP(ulCfg->initialUplinkBWP) != ROK)
4468    {
4469       return RFAILED;
4470    }
4471
4472    ulCfg->uplinkBWP_ToReleaseList = NULLP;
4473    ulCfg->uplinkBWP_ToAddModList = NULLP;
4474    ulCfg->firstActiveUplinkBWP_Id = NULLP;
4475    DU_ALLOC(ulCfg->firstActiveUplinkBWP_Id, sizeof(BWP_Id_t));
4476    if(!ulCfg->firstActiveUplinkBWP_Id)
4477    {
4478       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failed in BuildUlCfg");
4479       return RFAILED;
4480    }
4481    *(ulCfg->firstActiveUplinkBWP_Id) = ACTIVE_UL_BWP_ID;
4482
4483    ulCfg->pusch_ServingCellConfig = NULLP;
4484    DU_ALLOC(ulCfg->pusch_ServingCellConfig, \
4485          sizeof(struct UplinkConfig__pusch_ServingCellConfig));
4486    if(!ulCfg->pusch_ServingCellConfig)
4487    {
4488       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failed in BuildUlCfg");
4489       return RFAILED;
4490    }
4491
4492    if(BuildPuschSrvCellCfg(ulCfg->pusch_ServingCellConfig) != ROK)
4493    {
4494       return RFAILED;
4495    }
4496
4497    ulCfg->carrierSwitching = NULLP;
4498    ulCfg->ext1 = NULLP;
4499    return ROK;
4500 }
4501
4502 /*******************************************************************
4503  *
4504  * @brief Builds PDSCH serving cell config
4505  * @details
4506  *
4507  *    Function : BuildPdschSrvCellCfg
4508  *
4509  *    Functionality: Builds PDSCH serving cell config in spCellCfgDed
4510  *
4511  * @params[in] struct ServingCellConfig__pdsch_ServingCellConfig *pdschCfg
4512  *
4513  * @return ROK     - success
4514  *         RFAILED - failure
4515  *
4516  * ****************************************************************/
4517 uint8_t BuildPdschSrvCellCfg(struct ServingCellConfig__pdsch_ServingCellConfig *pdschCfg)
4518 {
4519    pdschCfg->present =  ServingCellConfig__pdsch_ServingCellConfig_PR_setup;
4520    pdschCfg->choice.setup = NULLP;
4521    DU_ALLOC(pdschCfg->choice.setup, sizeof( struct PDSCH_ServingCellConfig));
4522    if(!pdschCfg->choice.setup)
4523    {
4524       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschSrvCellCfg");
4525       return RFAILED;
4526    }
4527
4528    pdschCfg->choice.setup->codeBlockGroupTransmission = NULLP;
4529    pdschCfg->choice.setup->xOverhead = NULLP;
4530    pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH = NULLP;
4531    DU_ALLOC(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH, sizeof(long));
4532    if(!pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH)
4533    {
4534       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschSrvCellCfg");
4535       return RFAILED;
4536    }
4537    *(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH)= PDSCH_NUM_HARQ_PROC;
4538    pdschCfg->choice.setup->pucch_Cell = NULLP;
4539    pdschCfg->choice.setup->ext1 = NULLP;
4540
4541    return ROK;
4542 }
4543
4544 /*******************************************************************
4545  *
4546  * @brief Builds CSI Meas config
4547  * @details
4548  *
4549  *    Function : BuildCsiMeasCfg
4550  *
4551  *    Functionality: Builds CSI Meas config in spCellCfgDed
4552  *
4553  * @params[in] struct ServingCellConfig__csi_MeasConfig *csiMeasCfg
4554  *
4555  * @return ROK     - success
4556  *         RFAILED - failure
4557  *
4558  * ****************************************************************/
4559 uint8_t BuildCsiMeasCfg(struct ServingCellConfig__csi_MeasConfig *csiMeasCfg)
4560 {
4561
4562    return ROK;
4563 }
4564
4565 /*******************************************************************
4566  *
4567  * @brief Builds Spcell config dedicated
4568  * @details
4569  *
4570  *    Function : BuildSpCellCfgDed
4571  *
4572  *    Functionality: Builds sp cell config dedicated in spCellCfg
4573  *
4574  * @params[in] ServingCellConfig_t srvCellCfg
4575  *
4576  * @return ROK     - success
4577  *         RFAILED - failure
4578  *
4579  * ****************************************************************/
4580 uint8_t BuildSpCellCfgDed(ServingCellConfig_t *srvCellCfg)
4581 {
4582    srvCellCfg->tdd_UL_DL_ConfigurationDedicated = NULLP;
4583    DU_ALLOC(srvCellCfg->tdd_UL_DL_ConfigurationDedicated, sizeof(TDD_UL_DL_ConfigDedicated_t));
4584    if(!srvCellCfg->tdd_UL_DL_ConfigurationDedicated)
4585    {
4586       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
4587       return RFAILED;
4588    }
4589
4590    srvCellCfg->initialDownlinkBWP = NULLP;
4591    DU_ALLOC(srvCellCfg->initialDownlinkBWP, sizeof(BWP_DownlinkDedicated_t));
4592    if(!srvCellCfg->initialDownlinkBWP)
4593    {
4594       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
4595       return RFAILED;
4596    }
4597
4598    if(BuildInitialDlBWP(srvCellCfg->initialDownlinkBWP) != ROK)
4599    {
4600       DU_LOG("\nERROR  -->  F1AP : BuildInitialDlBWP failed");
4601       return RFAILED;
4602    }
4603    srvCellCfg->downlinkBWP_ToReleaseList = NULLP;
4604    srvCellCfg->downlinkBWP_ToAddModList = NULLP;
4605
4606    srvCellCfg->firstActiveDownlinkBWP_Id = NULLP;
4607    DU_ALLOC(srvCellCfg->firstActiveDownlinkBWP_Id, sizeof(long));
4608    if(!srvCellCfg->firstActiveDownlinkBWP_Id)
4609    {
4610       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
4611       return RFAILED;
4612    }
4613    *(srvCellCfg->firstActiveDownlinkBWP_Id) = ACTIVE_DL_BWP_ID;
4614
4615    srvCellCfg->bwp_InactivityTimer = NULLP;
4616
4617    srvCellCfg->defaultDownlinkBWP_Id = NULLP;
4618    DU_ALLOC(srvCellCfg->defaultDownlinkBWP_Id, sizeof(long));
4619    if(!srvCellCfg->defaultDownlinkBWP_Id)
4620    {
4621       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
4622       return RFAILED;
4623    }
4624    *(srvCellCfg->defaultDownlinkBWP_Id) = ACTIVE_DL_BWP_ID;
4625
4626    srvCellCfg->uplinkConfig = NULLP;
4627    DU_ALLOC(srvCellCfg->uplinkConfig, sizeof(UplinkConfig_t));
4628    if(!srvCellCfg->uplinkConfig)
4629    {
4630       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
4631       return RFAILED;
4632    }
4633
4634    if(BuildUlCfg(srvCellCfg->uplinkConfig) != ROK)
4635    {
4636       DU_LOG("\nERROR  -->  F1AP : BuildUlCfg failed");
4637       return RFAILED;
4638    }
4639    srvCellCfg->supplementaryUplink = NULLP;
4640    srvCellCfg->pdcch_ServingCellConfig = NULLP;
4641
4642    srvCellCfg->pdsch_ServingCellConfig = NULLP;
4643    DU_ALLOC(srvCellCfg->pdsch_ServingCellConfig, sizeof(struct  ServingCellConfig__pdsch_ServingCellConfig));
4644    if(!srvCellCfg->pdsch_ServingCellConfig)
4645    {
4646       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
4647       return RFAILED;
4648    }
4649
4650    if(BuildPdschSrvCellCfg(srvCellCfg->pdsch_ServingCellConfig) != ROK)
4651    {
4652       DU_LOG("\nERROR  -->  F1AP : BuildPdschSrvCellCfg failed");
4653       return RFAILED;
4654    }
4655
4656    srvCellCfg->csi_MeasConfig = NULLP;
4657 #if 0
4658    DU_ALLOC(srvCellCfg->csi_MeasConfig, sizeof(struct   ServingCellConfig__csi_MeasConfig))
4659       if(!srvCellCfg->csi_MeasConfig)
4660       {
4661          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
4662          return RFAILED;
4663       }
4664
4665    if(BuildCsiMeasCfg(srvCellCfg->csi_MeasConfig) != ROK)
4666    {
4667       DU_LOG("\nF1AP : BuildCsiMeasCfg failed");
4668       return RFAILED;
4669    }
4670 #endif
4671    srvCellCfg->sCellDeactivationTimer = NULLP;
4672    srvCellCfg->crossCarrierSchedulingConfig = NULLP;
4673    srvCellCfg->tag_Id = TAG_ID;
4674    srvCellCfg->dummy = NULLP;
4675    srvCellCfg->pathlossReferenceLinking = NULLP;
4676    srvCellCfg->servingCellMO = NULLP;
4677    srvCellCfg->ext1 = NULLP;
4678
4679    return ROK;
4680 }
4681 /*******************************************************************
4682  *
4683  * @brief Builds Spcell config
4684  *
4685  * @details
4686  *
4687  *    Function : BuildSpCellCfg
4688  *
4689  *    Functionality: Builds sp cell config in DuToCuRrcContainer
4690  *
4691  * @params[in] SpCellConfig_t spCellCfg
4692  *
4693  * @return ROK     - success
4694  *         RFAILED - failure
4695  *
4696  * ****************************************************************/
4697 uint8_t BuildSpCellCfg(SpCellConfig_t *spCellCfg)
4698 {
4699
4700    spCellCfg->servCellIndex = NULLP;
4701    DU_ALLOC(spCellCfg->servCellIndex, sizeof(long));
4702    if(!spCellCfg->servCellIndex)
4703    {
4704       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfg");
4705       return RFAILED;
4706    }
4707    *(spCellCfg->servCellIndex) = SERV_CELL_IDX;
4708
4709    spCellCfg->reconfigurationWithSync = NULLP;
4710    spCellCfg->rlf_TimersAndConstants = NULLP;
4711    spCellCfg->rlmInSyncOutOfSyncThreshold = NULLP;
4712    DU_ALLOC(spCellCfg->rlmInSyncOutOfSyncThreshold, sizeof(long));
4713    if(!spCellCfg->rlmInSyncOutOfSyncThreshold)
4714    {
4715       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfg");
4716       return RFAILED;
4717    }
4718    *(spCellCfg->rlmInSyncOutOfSyncThreshold) = RLM_SYNC_OUT_SYNC_THRESHOLD;
4719
4720    spCellCfg->spCellConfigDedicated = NULLP;
4721    DU_ALLOC(spCellCfg->spCellConfigDedicated, sizeof(ServingCellConfig_t));
4722    if(!spCellCfg->spCellConfigDedicated)
4723    {
4724       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfg");
4725       return RFAILED;
4726    }
4727    if(BuildSpCellCfgDed(spCellCfg->spCellConfigDedicated) != ROK)
4728    {
4729       DU_LOG("\nERROR  -->  F1AP : BuildSpCellCfgDed failed");
4730       return RFAILED;
4731    }
4732    return ROK;
4733 }
4734 /*******************************************************************
4735  *
4736  * @brief Builds Phy cell group config
4737  *
4738  * @details
4739  *
4740  *    Function : BuildPhyCellGrpCfg
4741  *
4742  *    Functionality: Builds Phy cell group config in DuToCuRrcContainer
4743  *
4744  * @params[in] PhysicalCellGroupConfig_t *phyCellGrpCfg
4745  *
4746  * @return ROK     - success
4747  *         RFAILED - failure
4748  *
4749  * ****************************************************************/
4750 uint8_t BuildPhyCellGrpCfg(PhysicalCellGroupConfig_t *phyCellGrpCfg)
4751 {
4752    phyCellGrpCfg->harq_ACK_SpatialBundlingPUCCH = NULLP;
4753    phyCellGrpCfg->harq_ACK_SpatialBundlingPUSCH = NULLP;
4754
4755    phyCellGrpCfg->p_NR_FR1 = NULLP;
4756    DU_ALLOC(phyCellGrpCfg->p_NR_FR1, sizeof(long));
4757    if(!phyCellGrpCfg->p_NR_FR1)
4758    {
4759       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildPhyCellGrpCfg");
4760       return RFAILED;
4761    }
4762    *(phyCellGrpCfg->p_NR_FR1)             = P_NR_FR1;
4763    phyCellGrpCfg->pdsch_HARQ_ACK_Codebook = PDSCH_HARQ_ACK_CODEBOOK;
4764    phyCellGrpCfg->tpc_SRS_RNTI = NULLP;
4765    phyCellGrpCfg->tpc_PUCCH_RNTI = NULLP;
4766    phyCellGrpCfg->tpc_PUSCH_RNTI = NULLP;
4767    phyCellGrpCfg->sp_CSI_RNTI = NULLP;
4768    phyCellGrpCfg->cs_RNTI = NULLP;
4769    phyCellGrpCfg->ext1 = NULLP;
4770    phyCellGrpCfg->ext2 = NULLP;
4771
4772    return ROK;
4773 }
4774 /*******************************************************************
4775  *
4776  * @brief Builds Mac cell group config
4777  *
4778  * @details
4779  *
4780  *    Function : BuildMacCellGrpCfg
4781  *
4782  *    Functionality: Builds Mac cell group config in DuToCuRrcContainer
4783  *
4784  * @params[in] MAC_CellGroupConfig_t *macCellGrpCfg
4785  *
4786  * @return ROK     - success
4787  *         RFAILED - failure
4788  *
4789  * ****************************************************************/
4790 uint8_t BuildMacCellGrpCfg(MAC_CellGroupConfig_t *macCellGrpCfg)
4791 {
4792    macCellGrpCfg->drx_Config = NULLP;
4793    macCellGrpCfg->schedulingRequestConfig = NULLP;
4794    DU_ALLOC(macCellGrpCfg->schedulingRequestConfig, sizeof(struct SchedulingRequestConfig));
4795    if(!macCellGrpCfg->schedulingRequestConfig)
4796    {
4797       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacCellGrpCfg");
4798       return RFAILED;
4799    }
4800
4801    if(BuildSchedulingReqConfig(macCellGrpCfg->schedulingRequestConfig) != ROK)
4802    {
4803       DU_LOG("\nERROR  -->  F1AP : BuildSchedulingReqConfig failed");
4804       return RFAILED;
4805    }
4806
4807    macCellGrpCfg->bsr_Config = NULLP;
4808    DU_ALLOC(macCellGrpCfg->bsr_Config, sizeof(struct BSR_Config));
4809    if(!macCellGrpCfg->bsr_Config)
4810    {
4811       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacCellGrpCfg");
4812       return RFAILED;
4813    }
4814
4815    if(BuildBsrConfig(macCellGrpCfg->bsr_Config) != ROK)
4816    {
4817       DU_LOG("\nERROR  -->  F1AP : BuildBsrConfig failed");
4818       return RFAILED;
4819    }
4820
4821    macCellGrpCfg->tag_Config = NULLP;
4822    DU_ALLOC(macCellGrpCfg->tag_Config, sizeof(struct TAG_Config));
4823    if(!macCellGrpCfg->tag_Config)
4824    {
4825       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacCellGrpCfg");
4826       return RFAILED;
4827    }
4828
4829    if(BuildTagConfig(macCellGrpCfg->tag_Config) != ROK)
4830    {
4831       DU_LOG("\nERROR  -->  F1AP : BuildTagConfig failed");
4832       return RFAILED;
4833    }
4834
4835    macCellGrpCfg->phr_Config = NULLP;
4836    DU_ALLOC(macCellGrpCfg->phr_Config, sizeof(struct MAC_CellGroupConfig__phr_Config));
4837    if(!macCellGrpCfg->phr_Config)
4838    {
4839       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacCellGrpCfg");
4840       return RFAILED;
4841    }
4842
4843    if(BuildPhrConfig(macCellGrpCfg->phr_Config) != ROK)
4844    {
4845       DU_LOG("\nERROR  -->  F1AP : BuildPhrConfig failed");
4846       return RFAILED;
4847    }
4848
4849    macCellGrpCfg->skipUplinkTxDynamic = false;
4850    macCellGrpCfg->ext1 = NULLP;
4851
4852    return ROK;
4853 }
4854 /*******************************************************************
4855  *
4856  * @brief Frees memeory allocated for SearchSpcToAddModList
4857  *
4858  * @details
4859  *
4860  *    Function : FreeSearchSpcToAddModList
4861  *
4862  *    Functionality: Deallocating memory of SearchSpcToAddModList
4863  *
4864  * @params[in] struct PDCCH_Config__searchSpacesToAddModList *searchSpcList
4865  *
4866  * @return void
4867  *
4868  4221 * ****************************************************************/
4869 void FreeSearchSpcToAddModList(struct PDCCH_Config__searchSpacesToAddModList *searchSpcList)
4870 {
4871    uint8_t idx1=0;
4872    uint8_t idx2=0;
4873    struct  SearchSpace *searchSpc=NULLP;
4874
4875    if(searchSpcList->list.array)
4876    {
4877       if(searchSpcList->list.array[idx2])
4878       {
4879          searchSpc = searchSpcList->list.array[idx2];
4880          if(searchSpc->controlResourceSetId)
4881          {
4882             if(searchSpc->monitoringSlotPeriodicityAndOffset)
4883             {
4884                if(searchSpc->monitoringSymbolsWithinSlot)
4885                {
4886                   if(searchSpc->monitoringSymbolsWithinSlot->buf)
4887                   {
4888                      if(searchSpc->nrofCandidates)
4889                      {
4890                         if(searchSpc->searchSpaceType)
4891                         {
4892                            DU_FREE(searchSpc->searchSpaceType->choice.ue_Specific,\
4893                                  sizeof(struct SearchSpace__searchSpaceType__ue_Specific));
4894                            DU_FREE(searchSpc->searchSpaceType, sizeof(struct
4895                                     SearchSpace__searchSpaceType));
4896                         }
4897                         DU_FREE(searchSpc->nrofCandidates,
4898                               sizeof(struct SearchSpace__nrofCandidates));
4899                      }
4900                      DU_FREE(searchSpc->monitoringSymbolsWithinSlot->buf, \
4901                            searchSpc->monitoringSymbolsWithinSlot->size);
4902                   }
4903                   DU_FREE(searchSpc->monitoringSymbolsWithinSlot,
4904                         sizeof(BIT_STRING_t));
4905                }
4906                DU_FREE(searchSpc->monitoringSlotPeriodicityAndOffset, \
4907                      sizeof(struct SearchSpace__monitoringSlotPeriodicityAndOffset));
4908             }
4909             DU_FREE(searchSpc->controlResourceSetId,
4910                   sizeof(ControlResourceSetId_t));
4911          }
4912       }
4913       for(idx1 = 0; idx1 < searchSpcList->list.count; idx1++)
4914       {
4915          DU_FREE(searchSpcList->list.array[idx1],
4916                sizeof(struct SearchSpace));
4917       }
4918       DU_FREE(searchSpcList->list.array,searchSpcList->list.size);
4919    }
4920 }
4921 /*******************************************************************
4922  *
4923  * @brief Frees memory allocated for PdschTimeDomAllocList
4924  *
4925  * @details
4926  *
4927  *    Function : FreePdschTimeDomAllocList
4928  *
4929  *    Functionality: Deallocating memory of PdschTimeDomAllocList
4930  *
4931  * @params[in] struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList
4932  *
4933  * @return void
4934  *
4935  4221 * ****************************************************************/
4936 void FreePdschTimeDomAllocList( struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList)
4937 {
4938    uint8_t idx1=0;
4939
4940    if(timeDomAllocList->choice.setup)
4941    {
4942       if(timeDomAllocList->choice.setup->list.array)
4943       {
4944          for(idx1 = 0; idx1 <timeDomAllocList->choice.setup->list.count ; idx1++)
4945          {
4946             DU_FREE(timeDomAllocList->choice.setup->list.array[idx1],
4947                   sizeof(struct PDSCH_TimeDomainResourceAllocation));
4948          }
4949          DU_FREE(timeDomAllocList->choice.setup->list.array, \
4950                timeDomAllocList->choice.setup->list.size);
4951       }
4952       DU_FREE(timeDomAllocList->choice.setup,\
4953             sizeof(struct PDSCH_TimeDomainResourceAllocationList));
4954    }
4955 }
4956 /*******************************************************************
4957  *
4958  * @brief Frees memory allocated for PuschTimeDomAllocList
4959  *
4960  *@details
4961  *
4962  *    Function : FreePuschTimeDomAllocList
4963  *
4964  *    Functionality: Deallocating memory of PuschTimeDomAllocList
4965  *
4966  * @params[in] PUSCH_Config_t *puschCfg
4967  *
4968  * @return void
4969  *
4970  * ****************************************************************/
4971 void FreePuschTimeDomAllocList(PUSCH_Config_t *puschCfg)
4972 {
4973    uint8_t idx1=0;
4974    uint8_t idx2=0;
4975    struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList_t=NULLP;
4976
4977    if(puschCfg->pusch_TimeDomainAllocationList)
4978    {
4979       timeDomAllocList_t=puschCfg->pusch_TimeDomainAllocationList;
4980       if(timeDomAllocList_t->choice.setup)
4981       {
4982          if(timeDomAllocList_t->choice.setup->list.array)
4983          {
4984             DU_FREE(timeDomAllocList_t->choice.setup->list.array[idx2]->k2, sizeof(long));
4985             for(idx1 = 0; idx1<timeDomAllocList_t->choice.setup->list.count; idx1++)
4986             {
4987                DU_FREE(timeDomAllocList_t->choice.setup->list.array[idx1],\
4988                      sizeof(PUSCH_TimeDomainResourceAllocation_t));
4989             }
4990             DU_FREE(timeDomAllocList_t->choice.setup->list.array, \
4991                   timeDomAllocList_t->choice.setup->list.size);
4992          }
4993          DU_FREE(timeDomAllocList_t->choice.setup, \
4994                sizeof(struct PUSCH_TimeDomainResourceAllocationList));
4995       }
4996       DU_FREE(puschCfg->transformPrecoder, sizeof(long));
4997       DU_FREE(puschCfg->pusch_TimeDomainAllocationList, \
4998             sizeof(struct PUSCH_Config__pusch_TimeDomainAllocationList));
4999    }
5000
5001 }
5002 /*******************************************************************
5003  *
5004  * @brief Frees memory allocated for InitialUlBWP
5005  *
5006  * @details
5007  *
5008  *    Function : FreeInitialUlBWP
5009  *
5010  *    Functionality: Deallocating memory of InitialUlBWP
5011  *
5012  * @params[in] BWP_UplinkDedicated_t *ulBwp
5013  *
5014  * @return void
5015  *
5016  * ****************************************************************/
5017 void FreeInitialUlBWP(BWP_UplinkDedicated_t *ulBwp)
5018 {
5019    uint8_t  rSetIdx, rsrcIdx;
5020    SRS_Config_t   *srsCfg = NULLP;
5021    PUSCH_Config_t *puschCfg = NULLP;
5022    struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA *dmrsUlCfg = NULLP;
5023    struct SRS_Config__srs_ResourceSetToAddModList *rsrcSetList = NULLP;
5024    struct SRS_ResourceSet__srs_ResourceIdList *rsrcIdList = NULLP;
5025    struct SRS_Config__srs_ResourceToAddModList *resourceList = NULLP;
5026
5027    if(ulBwp->pusch_Config)
5028    {
5029       if(ulBwp->pusch_Config->choice.setup)
5030       {
5031          puschCfg=ulBwp->pusch_Config->choice.setup;
5032          if(puschCfg->dataScramblingIdentityPUSCH)
5033          {
5034             if(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA)
5035             {
5036                FreePuschTimeDomAllocList(puschCfg);
5037                dmrsUlCfg=puschCfg->dmrs_UplinkForPUSCH_MappingTypeA;
5038                if(dmrsUlCfg->choice.setup)
5039                {
5040                   if(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition)
5041                   {
5042                      if(dmrsUlCfg->choice.setup->transformPrecodingDisabled)
5043                      {
5044                         DU_FREE(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0,\
5045                               sizeof(long));
5046                         DU_FREE(dmrsUlCfg->choice.setup->transformPrecodingDisabled,
5047                               sizeof(struct DMRS_UplinkConfig__transformPrecodingDisabled));
5048                      }
5049                      DU_FREE(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition,
5050                            sizeof(long));
5051                   }
5052                   DU_FREE(dmrsUlCfg->choice.setup,sizeof(DMRS_UplinkConfig_t));
5053                }
5054                DU_FREE(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA, \
5055                      sizeof(struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA));
5056             }
5057             DU_FREE(puschCfg->dataScramblingIdentityPUSCH, sizeof(long));
5058          }
5059          DU_FREE(ulBwp->pusch_Config->choice.setup, sizeof(PUSCH_Config_t));
5060       }
5061       DU_FREE(ulBwp->pusch_Config, sizeof(struct BWP_UplinkDedicated__pusch_Config));
5062
5063       /* Free SRS-Config */
5064       if(ulBwp->srs_Config)
5065       {
5066          if(ulBwp->srs_Config->choice.setup)
5067          {
5068             srsCfg = ulBwp->srs_Config->choice.setup;
5069
5070             /* Free Resource Set to add/mod list */
5071             if(srsCfg->srs_ResourceSetToAddModList)
5072             {
5073                rsrcSetList = srsCfg->srs_ResourceSetToAddModList;
5074                if(rsrcSetList->list.array)
5075                {
5076                   rSetIdx = 0;
5077
5078                   /* Free SRS resource Id list in this SRS resource set */
5079                   if(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList)
5080                   {
5081                      rsrcIdList = rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList;
5082
5083                      if(rsrcIdList->list.array)
5084                      {
5085                         for(rsrcIdx = 0; rsrcIdx < rsrcIdList->list.count; rsrcIdx++)
5086                         {
5087                            DU_FREE(rsrcIdList->list.array[rsrcIdx], sizeof(SRS_ResourceId_t));
5088                         }
5089                         DU_FREE(rsrcIdList->list.array, rsrcIdList->list.size);
5090                      }
5091                      DU_FREE(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList,\
5092                            sizeof(struct SRS_ResourceSet__srs_ResourceIdList));
5093                   }
5094
5095                   /* Free resource type info for this SRS resource set */
5096                   DU_FREE(rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic, \
5097                         sizeof(struct SRS_ResourceSet__resourceType__aperiodic));
5098
5099                   /* Free memory for each resource set */
5100                   for(rSetIdx = 0; rSetIdx < rsrcSetList->list.count; rSetIdx++)
5101                   {
5102                      DU_FREE(rsrcSetList->list.array[rSetIdx], sizeof(SRS_ResourceSet_t));
5103                   }
5104                   DU_FREE(rsrcSetList->list.array, rsrcSetList->list.size);
5105                }
5106                DU_FREE(srsCfg->srs_ResourceSetToAddModList, \
5107                      sizeof(struct SRS_Config__srs_ResourceSetToAddModList));
5108             }
5109
5110             /* Free resource to add/modd list */
5111             if(srsCfg->srs_ResourceToAddModList)
5112             {
5113                resourceList = srsCfg->srs_ResourceToAddModList;
5114                if(resourceList->list.array)
5115                {
5116                   rsrcIdx = 0;
5117                   DU_FREE(resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2,\
5118                         sizeof(struct SRS_Resource__transmissionComb__n2));
5119                   DU_FREE(resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic,\
5120                         sizeof(struct SRS_Resource__resourceType__aperiodic));
5121
5122                   for(rsrcIdx = 0; rsrcIdx < resourceList->list.count; rsrcIdx++)
5123                   {
5124                      DU_FREE(resourceList->list.array[rsrcIdx], sizeof(SRS_Resource_t));
5125                   }
5126                   DU_FREE(resourceList->list.array, resourceList->list.size);
5127                }
5128                DU_FREE(srsCfg->srs_ResourceToAddModList, \
5129                      sizeof(struct SRS_Config__srs_ResourceToAddModList));
5130             }
5131
5132             DU_FREE(ulBwp->srs_Config->choice.setup, sizeof(SRS_Config_t));
5133          }
5134          DU_FREE(ulBwp->srs_Config, sizeof(struct BWP_UplinkDedicated__srs_Config));
5135       }
5136    }
5137 }
5138 /*******************************************************************
5139  *
5140  * @brief Frees memory allocated for initialUplinkBWP
5141  *
5142  * @details
5143  *
5144  *    Function : FreeinitialUplinkBWP
5145  *
5146  *    Functionality: Deallocating memory of initialUplinkBWP
5147  *
5148  * @params[in] UplinkConfig_t *ulCfg
5149  *
5150  * @return void
5151  *
5152  *
5153  * ****************************************************************/
5154 void FreeinitialUplinkBWP(UplinkConfig_t *ulCfg)
5155 {
5156    BWP_UplinkDedicated_t *ulBwp=NULLP;
5157    struct UplinkConfig__pusch_ServingCellConfig *puschCfg=NULLP;
5158
5159    if(ulCfg->initialUplinkBWP)
5160    {
5161       ulBwp=ulCfg->initialUplinkBWP;
5162       if(ulCfg->firstActiveUplinkBWP_Id)
5163       {
5164          if(ulCfg->pusch_ServingCellConfig)
5165          {
5166             puschCfg=ulCfg->pusch_ServingCellConfig;
5167             if(puschCfg->choice.setup)
5168             {
5169                if(puschCfg->choice.setup->ext1)
5170                {
5171                   DU_FREE(puschCfg->choice.setup->ext1->\
5172                         processingType2Enabled,sizeof(BOOLEAN_t));
5173                   DU_FREE(puschCfg->choice.setup->ext1->\
5174                         maxMIMO_Layers,sizeof(long));
5175                   DU_FREE(puschCfg->choice.setup->ext1, \
5176                         sizeof(struct PUSCH_ServingCellConfig__ext1));
5177                }
5178                DU_FREE(puschCfg->choice.setup, sizeof(struct PUSCH_ServingCellConfig));
5179             }
5180             DU_FREE(ulCfg->pusch_ServingCellConfig, sizeof(struct UplinkConfig__pusch_ServingCellConfig));
5181          }
5182          DU_FREE(ulCfg->firstActiveUplinkBWP_Id, sizeof(BWP_Id_t));
5183       }
5184       FreeInitialUlBWP(ulBwp);
5185       DU_FREE(ulCfg->initialUplinkBWP, sizeof(BWP_UplinkDedicated_t));
5186    }
5187 }
5188 /*******************************************************************
5189  *
5190  * @brief Frees emmory allocated for BWPDlDedPdschCfg
5191  *
5192  * @details
5193  *
5194  *    Function : FreeBWPDlDedPdschCfg
5195  *
5196  *    Functionality: Deallocating memory of BWPDlDedPdschCfg
5197  *
5198  * @params[in] BWP_DownlinkDedicated_t *dlBwp
5199  *
5200  * @return void
5201  *
5202  *
5203  * ****************************************************************/
5204 void FreeBWPDlDedPdschCfg(BWP_DownlinkDedicated_t *dlBwp)
5205 {
5206    struct PDSCH_Config *pdschCfg=NULLP;
5207    struct PDSCH_Config__prb_BundlingType *prbBndlType=NULLP;
5208    struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList=NULLP;
5209    struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA *dmrsDlCfg=NULLP;
5210
5211    if(dlBwp->pdsch_Config->choice.setup)
5212    {
5213       pdschCfg=dlBwp->pdsch_Config->choice.setup;
5214       if(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA)
5215       {
5216          if(pdschCfg->pdsch_TimeDomainAllocationList)
5217          {
5218             timeDomAllocList=pdschCfg->pdsch_TimeDomainAllocationList;
5219             if(pdschCfg->maxNrofCodeWordsScheduledByDCI)
5220             {
5221                prbBndlType=&pdschCfg->prb_BundlingType;
5222                DU_FREE(prbBndlType->choice.staticBundling,\
5223                      sizeof(struct PDSCH_Config__prb_BundlingType__staticBundling));
5224                DU_FREE(pdschCfg->maxNrofCodeWordsScheduledByDCI, sizeof(long));
5225             }
5226             FreePdschTimeDomAllocList(timeDomAllocList);
5227             DU_FREE(pdschCfg->pdsch_TimeDomainAllocationList, \
5228                   sizeof(struct PDSCH_Config__pdsch_TimeDomainAllocationList));
5229          }
5230          dmrsDlCfg=pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA;
5231          if(dmrsDlCfg->choice.setup)
5232          {
5233             DU_FREE(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition,
5234                   sizeof(long));
5235             DU_FREE(dmrsDlCfg->choice.setup, sizeof(struct DMRS_DownlinkConfig));
5236          }
5237          DU_FREE(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA, \
5238                sizeof(struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA));
5239       }
5240       DU_FREE(dlBwp->pdsch_Config->choice.setup, sizeof(struct PDSCH_Config));
5241    }
5242 }
5243 /*******************************************************************
5244  *
5245  * @brief Frees emmory allocated for BWPDlDedPdcchCfg
5246  *
5247  * @details
5248  *
5249  *    Function : FreeBWPDlDedPdcchCfg
5250  *
5251  *    Functionality: Deallocating memory of BWPDlDedPdcchCfg
5252  *
5253  * @params[in] BWP_DownlinkDedicated_t *dlBwp
5254  *
5255  * @return void
5256  *
5257  *
5258  * ****************************************************************/
5259 void FreeBWPDlDedPdcchCfg(BWP_DownlinkDedicated_t *dlBwp)
5260 {
5261    uint8_t idx1=0;
5262    uint8_t idx2=0;
5263    struct PDCCH_Config *pdcchCfg=NULLP;
5264    struct ControlResourceSet *controlRSet=NULLP;
5265    struct PDCCH_Config__controlResourceSetToAddModList *controlRSetList=NULLP;
5266
5267    if(dlBwp->pdcch_Config->choice.setup)
5268    {
5269       pdcchCfg=dlBwp->pdcch_Config->choice.setup;
5270       if(pdcchCfg->controlResourceSetToAddModList)
5271       {
5272          controlRSetList = pdcchCfg->controlResourceSetToAddModList;
5273          if(controlRSetList->list.array)
5274          {
5275             controlRSet = controlRSetList->list.array[idx2];
5276             if(controlRSet)
5277             {
5278                if(controlRSet->frequencyDomainResources.buf)
5279                {
5280                   if(controlRSet->pdcch_DMRS_ScramblingID)
5281                   {
5282                      if(pdcchCfg->searchSpacesToAddModList)
5283                      {
5284                         FreeSearchSpcToAddModList(pdcchCfg->searchSpacesToAddModList);
5285                         DU_FREE(pdcchCfg->searchSpacesToAddModList, \
5286                               sizeof(struct PDCCH_Config__searchSpacesToAddModList));
5287                      }
5288                      DU_FREE(controlRSet->pdcch_DMRS_ScramblingID, sizeof(long));
5289                   }
5290                   DU_FREE(controlRSet->frequencyDomainResources.buf, \
5291                         controlRSet->frequencyDomainResources.size);
5292                }
5293             }
5294             for(idx1 = 0; idx1 <controlRSetList->list.count; idx1++)
5295             {
5296                DU_FREE(controlRSetList->list.array[idx1], sizeof(struct ControlResourceSet));
5297             }
5298             DU_FREE(controlRSetList->list.array, controlRSetList->list.size);
5299          }
5300          DU_FREE(pdcchCfg->controlResourceSetToAddModList, \
5301                sizeof(struct PDCCH_Config__controlResourceSetToAddModList));
5302       }
5303       DU_FREE(dlBwp->pdcch_Config->choice.setup, sizeof(struct PDCCH_Config));
5304    }
5305 }
5306
5307 /*******************************************************************
5308  *
5309  * @brief Frees emmory allocated for DUToCURRCContainer
5310  *
5311  * @details
5312  *
5313  *    Function : FreeMemDuToCuRrcCont
5314  *
5315  *    Functionality: Deallocating memory of DuToCuRrcContainer
5316  *
5317  * @params[in] DuToCuRRCContainer, DuToCuRRCContainer
5318  *
5319  * @return ROK     - success
5320  *         RFAILED - failure
5321  *
5322  * ****************************************************************/
5323 uint8_t FreeMemDuToCuRrcCont(CellGroupConfigRrc_t *cellGrpCfg)
5324 {
5325    uint8_t idx=0;
5326    SpCellConfig_t *spCellCfg=NULLP;
5327    ServingCellConfig_t *srvCellCfg=NULLP;
5328    BWP_DownlinkDedicated_t *dlBwp=NULLP;
5329    MAC_CellGroupConfig_t *macCellGrpCfg=NULLP;
5330    PhysicalCellGroupConfig_t *phyCellGrpCfg=NULLP;
5331    struct CellGroupConfigRrc__rlc_BearerToAddModList *rlcBearerList=NULLP;
5332    struct RLC_Config *rlcConfig=NULLP;
5333    struct LogicalChannelConfig *macLcConfig=NULLP;
5334    struct SchedulingRequestConfig *schedulingRequestConfig=NULLP;
5335    struct SchedulingRequestConfig__schedulingRequestToAddModList *schReqList=NULLP;
5336    struct TAG_Config *tagConfig=NULLP;
5337    struct TAG_Config__tag_ToAddModList *tagList=NULLP;
5338    struct MAC_CellGroupConfig__phr_Config *phrConfig=NULLP;
5339    struct ServingCellConfig__pdsch_ServingCellConfig *pdschCfg=NULLP;
5340
5341    rlcBearerList = cellGrpCfg->rlc_BearerToAddModList;
5342    if(rlcBearerList)
5343    {
5344       if(rlcBearerList->list.array)
5345       {
5346          for(idx=0; idx<rlcBearerList->list.count; idx++)
5347          {
5348             if(rlcBearerList->list.array[idx])
5349             {
5350                rlcConfig   = rlcBearerList->list.array[idx]->rlc_Config;
5351                macLcConfig = rlcBearerList->list.array[idx]->mac_LogicalChannelConfig;
5352                if(rlcConfig)
5353                {
5354                   if(rlcConfig->choice.am)
5355                   {
5356                      DU_FREE(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
5357                      DU_FREE(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
5358                      DU_FREE(rlcConfig->choice.am, sizeof(struct RLC_Config__am));
5359                   }
5360                   DU_FREE(rlcConfig, sizeof(struct RLC_Config));
5361                }
5362                DU_FREE(rlcBearerList->list.array[idx]->servedRadioBearer, sizeof(struct RLC_BearerConfig__servedRadioBearer));
5363                if(macLcConfig)
5364                {
5365                   if(macLcConfig->ul_SpecificParameters)
5366                   {
5367                      DU_FREE(macLcConfig->ul_SpecificParameters->schedulingRequestID,   sizeof(SchedulingRequestId_t));
5368                      DU_FREE(macLcConfig->ul_SpecificParameters->logicalChannelGroup,   sizeof(long));
5369                      DU_FREE(macLcConfig->ul_SpecificParameters, sizeof(struct LogicalChannelConfig__ul_SpecificParameters));
5370                   }
5371                   DU_FREE(rlcBearerList->list.array[idx]->mac_LogicalChannelConfig, sizeof(struct LogicalChannelConfig));
5372                }
5373                DU_FREE(rlcBearerList->list.array[idx], sizeof(struct RLC_BearerConfig));
5374             }
5375          }
5376          DU_FREE(rlcBearerList->list.array, rlcBearerList->list.size);
5377       }
5378       DU_FREE(cellGrpCfg->rlc_BearerToAddModList, sizeof(struct CellGroupConfigRrc__rlc_BearerToAddModList));
5379    }
5380
5381    macCellGrpCfg = cellGrpCfg->mac_CellGroupConfig;
5382    if(macCellGrpCfg)
5383    {
5384       schedulingRequestConfig = macCellGrpCfg->schedulingRequestConfig;
5385       if(schedulingRequestConfig)
5386       {
5387          schReqList = schedulingRequestConfig->schedulingRequestToAddModList;
5388          if(schReqList)
5389          {
5390             if(schReqList->list.array)
5391             {
5392                for(idx=0;idx<schReqList->list.count; idx++)
5393                {
5394                   if(schReqList->list.array[idx])
5395                   {
5396                      DU_FREE(schReqList->list.array[idx]->sr_ProhibitTimer, sizeof(long));
5397                      DU_FREE(schReqList->list.array[idx], sizeof(struct SchedulingRequestToAddMod));
5398                   }
5399                }
5400                DU_FREE(schReqList->list.array, schReqList->list.size);
5401             }
5402             DU_FREE(schedulingRequestConfig->schedulingRequestToAddModList,\
5403                   sizeof(struct SchedulingRequestConfig__schedulingRequestToAddModList));    }
5404             DU_FREE(macCellGrpCfg->schedulingRequestConfig, sizeof(struct SchedulingRequestConfig));
5405       }
5406       if(macCellGrpCfg->bsr_Config)
5407       {
5408          DU_FREE(macCellGrpCfg->bsr_Config, sizeof(struct BSR_Config));
5409       }
5410       tagConfig = macCellGrpCfg->tag_Config;
5411       if(tagConfig)
5412       {
5413          tagList = tagConfig->tag_ToAddModList;
5414          if(tagList)
5415          {
5416             if(tagList->list.array)
5417             {
5418                for(idx=0; idx<tagList->list.count; idx++)
5419                {
5420                   DU_FREE(tagList->list.array[idx], sizeof(struct TAG));
5421                }
5422                DU_FREE(tagList->list.array, tagList->list.size);
5423             }
5424             DU_FREE(tagConfig->tag_ToAddModList, sizeof(struct TAG_Config__tag_ToAddModList));
5425          }
5426          DU_FREE(tagConfig, sizeof(struct TAG_Config));
5427       }
5428
5429       phrConfig = macCellGrpCfg->phr_Config;
5430       if(phrConfig)
5431       {
5432          DU_FREE(phrConfig->choice.setup, sizeof(struct PHR_Config));
5433          DU_FREE(phrConfig, sizeof(struct MAC_CellGroupConfig__phr_Config));
5434       }
5435
5436       DU_FREE(macCellGrpCfg, sizeof(MAC_CellGroupConfig_t));
5437    }
5438
5439    phyCellGrpCfg = cellGrpCfg->physicalCellGroupConfig;
5440    if(phyCellGrpCfg)
5441    {
5442       DU_FREE(phyCellGrpCfg->p_NR_FR1, sizeof(long));
5443       DU_FREE(phyCellGrpCfg, sizeof(PhysicalCellGroupConfig_t));
5444    }
5445
5446    spCellCfg = cellGrpCfg->spCellConfig;
5447    if(spCellCfg)
5448    {
5449       if(spCellCfg->servCellIndex)
5450       {
5451          if(spCellCfg->rlmInSyncOutOfSyncThreshold)
5452          {
5453             if(spCellCfg->spCellConfigDedicated)
5454             {
5455                srvCellCfg = spCellCfg->spCellConfigDedicated;
5456                if(srvCellCfg->tdd_UL_DL_ConfigurationDedicated)
5457                {
5458                   if(srvCellCfg->initialDownlinkBWP)
5459                   {
5460                      dlBwp = srvCellCfg->initialDownlinkBWP;
5461                      if(srvCellCfg->firstActiveDownlinkBWP_Id)
5462                      {
5463                         if(srvCellCfg->defaultDownlinkBWP_Id)
5464                         {
5465                            if(srvCellCfg->uplinkConfig)
5466                            {
5467                               if(srvCellCfg->pdsch_ServingCellConfig)
5468                               {
5469                                  pdschCfg= srvCellCfg->pdsch_ServingCellConfig;
5470                                  if(pdschCfg->choice.setup)
5471                                  {
5472                                     DU_FREE(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH,sizeof(long));
5473                                     DU_FREE(pdschCfg->choice.setup, sizeof( struct PDSCH_ServingCellConfig));
5474                                  }
5475                                  DU_FREE(srvCellCfg->pdsch_ServingCellConfig, sizeof(struct
5476                                        ServingCellConfig__pdsch_ServingCellConfig));
5477                               }
5478                               FreeinitialUplinkBWP(srvCellCfg->uplinkConfig);
5479                               DU_FREE(srvCellCfg->uplinkConfig, sizeof(UplinkConfig_t));
5480                            }
5481                            DU_FREE(srvCellCfg->defaultDownlinkBWP_Id, sizeof(long));
5482                         }
5483                         DU_FREE(srvCellCfg->firstActiveDownlinkBWP_Id, sizeof(long));
5484                      }
5485                      if(dlBwp->pdcch_Config)
5486                      {
5487                         if(dlBwp->pdsch_Config)
5488                         {
5489                            FreeBWPDlDedPdschCfg(dlBwp);
5490                            DU_FREE(dlBwp->pdsch_Config, sizeof(struct BWP_DownlinkDedicated__pdsch_Config));
5491                         }
5492                         FreeBWPDlDedPdcchCfg(dlBwp);
5493                         DU_FREE(dlBwp->pdcch_Config, sizeof(struct BWP_DownlinkDedicated__pdcch_Config));
5494                     }
5495                     DU_FREE(srvCellCfg->initialDownlinkBWP, sizeof(BWP_DownlinkDedicated_t));
5496                   }
5497                   DU_FREE(srvCellCfg->tdd_UL_DL_ConfigurationDedicated, sizeof(TDD_UL_DL_ConfigDedicated_t));
5498                }
5499                DU_FREE(spCellCfg->spCellConfigDedicated, sizeof(ServingCellConfig_t));
5500             }
5501             DU_FREE(spCellCfg->rlmInSyncOutOfSyncThreshold, sizeof(long));
5502          }
5503          DU_FREE(spCellCfg->servCellIndex, sizeof(long));
5504       }
5505       DU_FREE(spCellCfg,sizeof(SpCellConfig_t));
5506    }
5507    return ROK;
5508 }
5509 /*******************************************************************
5510  *
5511  * @brief Builds DU To CU RRC Container
5512  *
5513  * @details
5514  *
5515  *    Function : BuildDuToCuRrcContainer
5516  *
5517  *    Functionality: Builds DuToCuRrcContainer
5518  *
5519  * @params[in] idx, index in F1AP msg
5520  *             DuToCuRRCContainer, DuToCuRRCContainer
5521  *
5522  * @return ROK     - success
5523  *         RFAILED - failure
5524  *
5525  * ****************************************************************/
5526 uint8_t BuildDuToCuRrcContainer(DUtoCURRCContainer_t *duToCuRrcContainer)
5527 {
5528    uint8_t  ret = ROK;
5529    CellGroupConfigRrc_t  cellGrpCfg;
5530    asn_enc_rval_t        encRetVal;
5531    memset(&cellGrpCfg, 0, sizeof(CellGroupConfigRrc_t));
5532    memset(&encRetVal, 0, sizeof(asn_enc_rval_t));
5533
5534    while(true)
5535    {
5536       cellGrpCfg.cellGroupId = CELL_GRP_ID;
5537
5538       cellGrpCfg.rlc_BearerToAddModList = NULLP;
5539       DU_ALLOC(cellGrpCfg.rlc_BearerToAddModList, sizeof(struct CellGroupConfigRrc__rlc_BearerToAddModList));
5540       if(!cellGrpCfg.rlc_BearerToAddModList)
5541       {
5542          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildDuToCuRrcContainer");
5543          ret = RFAILED;
5544          break;
5545       }
5546       if(BuildRlcBearerToAddModList(cellGrpCfg.rlc_BearerToAddModList) != ROK)
5547       {
5548          DU_LOG("\nERROR  -->  F1AP : BuildRlcBearerToAddModList failed");
5549          ret = RFAILED;
5550          break;
5551       }
5552
5553       cellGrpCfg.rlc_BearerToReleaseList = NULLP;
5554       cellGrpCfg.mac_CellGroupConfig = NULLP;
5555       DU_ALLOC(cellGrpCfg.mac_CellGroupConfig, sizeof(MAC_CellGroupConfig_t));
5556       if(!cellGrpCfg.mac_CellGroupConfig)
5557       {
5558          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildDuToCuRrcContainer");
5559          ret = RFAILED;
5560          break;
5561       }
5562       if(BuildMacCellGrpCfg(cellGrpCfg.mac_CellGroupConfig) != ROK)
5563       {
5564          DU_LOG("\nERROR  -->  F1AP : BuildMacCellGrpCfg failed");
5565          ret = RFAILED;
5566          break;
5567       }
5568
5569       cellGrpCfg.physicalCellGroupConfig = NULLP;
5570       DU_ALLOC(cellGrpCfg.physicalCellGroupConfig, sizeof(PhysicalCellGroupConfig_t));
5571       if(!cellGrpCfg.physicalCellGroupConfig)
5572       {
5573          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildDuToCuRrcContainer");
5574          ret = RFAILED;
5575          break;
5576       }
5577       if(BuildPhyCellGrpCfg(cellGrpCfg.physicalCellGroupConfig) != ROK)
5578       {
5579          DU_LOG("\nERROR  -->  F1AP : BuildPhyCellGrpCfg failed");
5580          ret = RFAILED;
5581          break;
5582       }
5583
5584       cellGrpCfg.spCellConfig = NULLP;
5585       DU_ALLOC(cellGrpCfg.spCellConfig, sizeof(SpCellConfig_t));
5586       if(!cellGrpCfg.spCellConfig)
5587       {
5588          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildDuToCuRrcContainer");
5589          ret = RFAILED;
5590          break;
5591       }
5592       if(BuildSpCellCfg(cellGrpCfg.spCellConfig) != ROK)
5593       {
5594          DU_LOG("\nERROR  -->  F1AP : BuildSpCellCfg failed");
5595          ret = RFAILED;
5596          break;
5597       }
5598
5599       cellGrpCfg.sCellToAddModList = NULLP;
5600       cellGrpCfg.sCellToReleaseList = NULLP;
5601       cellGrpCfg.ext1 = NULLP;
5602
5603       /* encode cellGrpCfg into duToCuRrcContainer */
5604       xer_fprint(stdout, &asn_DEF_CellGroupConfigRrc, &cellGrpCfg);
5605       memset(encBuf, 0, ENC_BUF_MAX_LEN);
5606       encBufSize = 0;
5607       encRetVal = aper_encode(&asn_DEF_CellGroupConfigRrc, 0, &cellGrpCfg, PrepFinalEncBuf, encBuf);
5608       /* Encode results */
5609       if(encRetVal.encoded == ENCODE_FAIL)
5610       {
5611          DU_LOG( "\nERROR  --> F1AP : Could not encode DuToCuRrcContainer (at %s)\n",\
5612                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
5613          ret = RFAILED;
5614          break;
5615       }
5616       else
5617       {
5618          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for DuToCuRrcContainer\n");
5619          for(int i=0; i< encBufSize; i++)
5620          {
5621             printf("%x",encBuf[i]);
5622          }
5623       }
5624
5625       duToCuRrcContainer->size = encBufSize;
5626       DU_ALLOC(duToCuRrcContainer->buf, duToCuRrcContainer->size);
5627       if(!duToCuRrcContainer->buf)
5628       {
5629          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDuToCuRrcContainer");
5630          ret = RFAILED;
5631          break;
5632       }
5633       if(ret == ROK)
5634       {
5635          memcpy(duToCuRrcContainer->buf, encBuf, duToCuRrcContainer->size);
5636       }
5637       break;
5638    }
5639    FreeMemDuToCuRrcCont(&cellGrpCfg);
5640    return ret;
5641 }
5642
5643 /*******************************************************************
5644  *
5645  * @brief Free memory allocated in InitialULRRCMessage
5646  *
5647  * @details
5648  *
5649  *    Function : freeInitUlRrcMsgTransfer
5650  *
5651  *    Functionality: Free memory allocated in InitialULRRCMessage
5652  *
5653  * @params[in]F1AP_PDU_t  *f1apMsg)
5654  *
5655  * @return ROK     - success
5656  *         RFAILED - failure
5657  *
5658  * ****************************************************************/
5659
5660 uint8_t freeInitUlRrcMsgTransfer(F1AP_PDU_t  *f1apMsg)
5661 {
5662    uint8_t ieIdx, arrIdx;
5663    InitialULRRCMessageTransfer_t *initULRRCMsg=NULLP;
5664
5665    if(f1apMsg)
5666    {
5667       if(f1apMsg->choice.initiatingMessage)
5668       {
5669          initULRRCMsg = &f1apMsg->choice.initiatingMessage->value.\
5670             choice.InitialULRRCMessageTransfer;
5671          if(initULRRCMsg->protocolIEs.list.array)
5672          {
5673             for(ieIdx = 0; ieIdx < initULRRCMsg->protocolIEs.list.count; ieIdx++)
5674             {
5675                switch(initULRRCMsg->protocolIEs.list.array[ieIdx]->id)
5676                {
5677                   case ProtocolIE_ID_id_NRCGI:
5678                   {
5679                      if(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.pLMN_Identity.buf)
5680                      {
5681                         if(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.nRCellIdentity.buf)
5682                         {
5683                            DU_FREE(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.nRCellIdentity.buf,\
5684                            initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.nRCellIdentity.size);
5685                         }
5686                         DU_FREE(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.pLMN_Identity.buf,\
5687                         initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.pLMN_Identity.size);
5688                      }
5689                      break;
5690                   }
5691                   case ProtocolIE_ID_id_RRCContainer:
5692                   {
5693                      if(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf)
5694                      {
5695                         DU_FREE(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf,\
5696                         initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.size);
5697                      }
5698                      break;
5699                   }
5700                   case ProtocolIE_ID_id_DUtoCURRCContainer:
5701                   {
5702                      if(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.DUtoCURRCContainer.buf)
5703                      {
5704                         DU_FREE(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.DUtoCURRCContainer.buf,
5705                         initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.DUtoCURRCContainer.size);
5706                      }
5707                      break;
5708                   }
5709                   default:
5710                      break;
5711                }
5712              }
5713              for(arrIdx = 0; arrIdx < ieIdx; arrIdx++)
5714              {
5715                 if(initULRRCMsg->protocolIEs.list.array[arrIdx])
5716                 {
5717                    DU_FREE(initULRRCMsg->protocolIEs.list.array[arrIdx],\
5718                       sizeof(InitialULRRCMessageTransferIEs_t));
5719                 }
5720              }
5721              DU_FREE(initULRRCMsg->protocolIEs.list.array, initULRRCMsg->protocolIEs.list.size);
5722           }
5723          DU_FREE(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
5724       }
5725       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
5726    }
5727    else
5728    {
5729       DU_LOG("\nERROR  -->  DU_APP : Recevied F1ap Pdu is null at freeInitUlRrcMsgTransfer()");
5730       return RFAILED;
5731    }
5732    return ROK;
5733 }
5734
5735 /*******************************************************************
5736  *
5737  * @brief Builds and sends the InitialULRRCMessage
5738  *
5739  * @details
5740  *
5741  *    Function : BuildAndSendInitialRrcMsgTransfer
5742  *
5743  *    Functionality: Constructs the Initial UL RRC Message Transfer and sends
5744  *                   it to the CU through SCTP.
5745  *
5746  * @params[in]
5747  *
5748  * @return ROK     - success
5749  *         RFAILED - failure
5750  *
5751  * ****************************************************************/
5752 uint8_t BuildAndSendInitialRrcMsgTransfer(uint32_t gnbDuUeF1apId, uint16_t crnti,
5753       uint16_t rrcContSize, uint8_t *rrcContainer)
5754 {
5755    uint8_t   ret;
5756    uint8_t   elementCnt;
5757    uint8_t   ieIdx;
5758    asn_enc_rval_t  encRetVal;
5759    F1AP_PDU_t  *f1apMsg = NULLP;
5760    InitialULRRCMessageTransfer_t *initULRRCMsg = NULLP;
5761    memset(&encRetVal, 0, sizeof(asn_enc_rval_t));
5762
5763    while(true)
5764    {
5765       DU_LOG("\n INFO   -->  F1AP : Building RRC Setup Request\n");
5766       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
5767       if(f1apMsg == NULLP)
5768       {
5769          DU_LOG(" ERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
5770          break;
5771       }
5772       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
5773       DU_ALLOC(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
5774       if(f1apMsg->choice.initiatingMessage == NULLP)
5775       {
5776          DU_LOG(" ERROR  -->  F1AP : Memory allocation for  F1AP-PDU failed");
5777          break;
5778       }
5779       f1apMsg->choice.initiatingMessage->procedureCode =\
5780                                                         ProcedureCode_id_InitialULRRCMessageTransfer;
5781       f1apMsg->choice.initiatingMessage->criticality = Criticality_ignore;
5782       f1apMsg->choice.initiatingMessage->value.present = \
5783                                                          InitiatingMessage__value_PR_InitialULRRCMessageTransfer;
5784       initULRRCMsg =\
5785                     &f1apMsg->choice.initiatingMessage->value.choice.InitialULRRCMessageTransfer;
5786       elementCnt = 5;
5787       initULRRCMsg->protocolIEs.list.count = elementCnt;
5788       initULRRCMsg->protocolIEs.list.size = \
5789                                             elementCnt * sizeof(InitialULRRCMessageTransferIEs_t *);
5790       /* Initialize the F1Setup members */
5791       DU_ALLOC(initULRRCMsg->protocolIEs.list.array,initULRRCMsg->protocolIEs.list.size);
5792       if(initULRRCMsg->protocolIEs.list.array == NULLP)
5793       {
5794          DU_LOG(" ERROR  -->  F1AP : Memory allocation for\
5795                RRCSetupRequestMessageTransferIEs failed");
5796          break;
5797       }
5798       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
5799       {
5800          DU_ALLOC(initULRRCMsg->protocolIEs.list.array[ieIdx],\
5801                sizeof(InitialULRRCMessageTransferIEs_t));
5802          if(initULRRCMsg->protocolIEs.list.array[ieIdx] == NULLP)
5803          {
5804             break;
5805          }
5806       }
5807       ieIdx = 0;
5808       /*GNB DU UE F1AP ID*/
5809       initULRRCMsg->protocolIEs.list.array[ieIdx]->id  = \
5810                                                         ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
5811       initULRRCMsg->protocolIEs.list.array[ieIdx]->criticality  = Criticality_reject;
5812       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.present = \
5813                                                                   InitialULRRCMessageTransferIEs__value_PR_GNB_DU_UE_F1AP_ID;
5814       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID = gnbDuUeF1apId;
5815
5816
5817       /*NRCGI*/
5818       ieIdx++;
5819       initULRRCMsg->protocolIEs.list.array[ieIdx]->id  = \
5820                                                         ProtocolIE_ID_id_NRCGI;
5821       initULRRCMsg->protocolIEs.list.array[ieIdx]->criticality  =Criticality_reject;
5822       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.present = \
5823                                                                   InitialULRRCMessageTransferIEs__value_PR_NRCGI;
5824
5825       ret =\
5826            BuildNrcgi(&initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI);
5827       if(ret!=ROK)
5828       {
5829          break;
5830       }
5831
5832       /*CRNTI*/
5833       ieIdx++;
5834       initULRRCMsg->protocolIEs.list.array[ieIdx]->id  = \
5835                                                         ProtocolIE_ID_id_C_RNTI;
5836       initULRRCMsg->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
5837       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.present =\
5838                                                                  InitialULRRCMessageTransferIEs__value_PR_C_RNTI;
5839       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.C_RNTI = crnti;
5840
5841       /*RRCContainer*/
5842       ieIdx++;
5843       initULRRCMsg->protocolIEs.list.array[ieIdx]->id  = \
5844                                                         ProtocolIE_ID_id_RRCContainer;
5845       initULRRCMsg->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
5846       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.present =\
5847                                                                  InitialULRRCMessageTransferIEs__value_PR_RRCContainer;
5848
5849       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.size = rrcContSize;
5850       DU_ALLOC(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf,
5851             initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.size)
5852       if(!initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf)
5853       {
5854          DU_LOG(" ERROR  -->  F1AP : Memory allocation for RRCSetupRequestMessageTransferIEs failed");
5855          break;
5856
5857       }
5858       memcpy(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf, rrcContainer,
5859             initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.size);
5860
5861
5862       /*DUtoCURRCContainer*/
5863       ieIdx++;
5864       initULRRCMsg->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_DUtoCURRCContainer;
5865       initULRRCMsg->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
5866       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.present =\
5867                                                                  InitialULRRCMessageTransferIEs__value_PR_DUtoCURRCContainer;
5868
5869       ret = BuildDuToCuRrcContainer(&initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.DUtoCURRCContainer);
5870       if(ret != ROK)
5871       {
5872          break;
5873       }
5874
5875       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
5876
5877       /* Encode the F1SetupRequest type as APER */
5878       memset(encBuf, 0, ENC_BUF_MAX_LEN);
5879       encBufSize = 0;
5880       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
5881       /* Encode results */
5882       if(encRetVal.encoded == ENCODE_FAIL)
5883       {
5884          DU_LOG( "\nERROR  --> F1AP : Could not encode Initial UL RRC Message Transfer\
5885                structure (at %s)\n",encRetVal.failed_type ? \
5886                encRetVal.failed_type->name : "unknown");
5887          ret = RFAILED;
5888          break;
5889       }
5890       else
5891       {
5892
5893          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for Initial UL RRC\
5894                Message transfer\n");
5895          for(int i=0; i< encBufSize; i++)
5896          {
5897             printf("%x",encBuf[i]);
5898          }
5899       }
5900       /* Sending  msg  */
5901       if(SendF1APMsg(DU_APP_MEM_REGION,DU_POOL) != ROK)
5902       {
5903          DU_LOG("\nERROR  -->  F1AP : Sending Initial UL RRC Message Transfer Failed");
5904          ret = RFAILED;
5905          break;
5906       }
5907       break;
5908    }
5909    freeInitUlRrcMsgTransfer(f1apMsg);
5910    return ret;
5911 }/* End of BuildAndSendInitialRrcMsgTransfer*/
5912
5913 /*****  UE SETUP REQUEST *****/
5914
5915 /*******************************************************************
5916  *
5917  * @brief Free Qos And Snssai Drb Info
5918  *
5919  * @details
5920  *
5921  *    Function : freeDrbQosAndSnssaiInfo
5922  *
5923  *    Functionality: Free Qos And Snssai Drb Info
5924  *
5925  * @params[in] LcCfg *lcCfg,
5926  * @return void
5927  *
5928  * ****************************************************************/
5929 void freeDrbQosAndSnssaiInfo(LcCfg *lcCfg)
5930 {
5931    if(lcCfg->snssai)
5932    {
5933       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->snssai, sizeof(Snssai));
5934    }
5935    if(lcCfg->drbQos)
5936    {
5937       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->drbQos, sizeof(DrbQosInfo));
5938    }
5939 }
5940
5941 /******************************************************************
5942 *
5943 * @brief Function to delete the RLC Lc cfg from UE APP DB
5944 *
5945 * @details
5946 *
5947 *  Function : freeRlcLcCfg
5948 *
5949 *  Functionality: Function to delete the RLC Lc cfg from UE APP DB
5950 *
5951 *
5952  *****************************************************************/
5953
5954 void freeRlcLcCfg(RlcBearerCfg *lcCfg)
5955 {
5956    switch(lcCfg->rlcMode)
5957    {
5958       case RLC_AM :
5959       {
5960          if(lcCfg->u.amCfg)
5961          {
5962             DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->u.amCfg, sizeof(AmBearerCfg));
5963             lcCfg->u.amCfg = NULLP;
5964          }
5965          break;
5966       }
5967       case RLC_UM_BI_DIRECTIONAL :
5968       {
5969          if(lcCfg->u.umBiDirCfg)
5970          {
5971             DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->u.umBiDirCfg, sizeof(UmBiDirBearerCfg));
5972             lcCfg->u.umBiDirCfg = NULLP;
5973          }
5974          break;
5975       }
5976       case RLC_UM_UNI_DIRECTIONAL_UL :
5977       {
5978          if(lcCfg->u.umUniDirUlCfg)
5979          {
5980             DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->u.umUniDirUlCfg, sizeof(UmUniDirUlBearerCfg));
5981             lcCfg->u.umUniDirUlCfg = NULLP;
5982          }
5983          break;
5984
5985       }
5986       case RLC_UM_UNI_DIRECTIONAL_DL :
5987       {
5988          if(lcCfg->u.umUniDirDlCfg)
5989          {
5990             DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->u.umUniDirDlCfg, sizeof(UmUniDirDlBearerCfg));
5991             lcCfg->u.umUniDirDlCfg = NULLP;
5992          }
5993          break;
5994       }
5995       default:
5996          DU_LOG("\nERROR  -->  DU_APP: Invalid Rlc Mode %d at freeRlcLcCfg()", lcCfg->rlcMode);
5997          break;
5998    }
5999    memset(lcCfg, 0, sizeof(LcCfg));
6000 }
6001 /*******************************************************************
6002  *
6003  * @brief Function to free MacLcCfg
6004  *
6005  * @details
6006  *
6007  *    Function : freeMacLcCfg
6008  *
6009  *    Functionality: Function to free MacLcCfg
6010  *
6011  * @params[in] LcCfg *lcCfg,
6012  * @return void
6013  *
6014  * ****************************************************************/
6015
6016 void  freeMacLcCfg(LcCfg *lcCfg)
6017 {
6018     /* Deleting DRBQOS */
6019    if(lcCfg->drbQos)
6020    {
6021       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->drbQos, sizeof(DrbQosInfo));
6022       lcCfg->drbQos = NULLP;
6023    }
6024    /* Deleting SNSSAI */
6025    if(lcCfg->snssai)
6026    {
6027       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->snssai, sizeof(Snssai));
6028       lcCfg->snssai = NULLP;
6029    }
6030    memset(lcCfg, 0, sizeof(LcCfg));
6031 }
6032 /*******************************************************************
6033  *
6034  * @brief Free UE NR Capability received in UE Context setup request
6035  *
6036  * @details
6037  *
6038  *    Function : freeAperDecodeUeNrCapability
6039  *
6040  *    Functionality:
6041  *       Free UE NR Capability received in UE Context setup request
6042  *
6043  * @params[in]
6044  * @return ROK     - success
6045  *         RFAILED - failure
6046  *
6047  * ****************************************************************/
6048 void freeAperDecodeUeNrCapability(void *ueNrCapability)
6049 {
6050    uint8_t arrIdx =0;
6051    FeatureSets_t *featureSets =NULLP;
6052    UE_NR_Capability_t *ueNrCap = (UE_NR_Capability_t *)ueNrCapability;
6053
6054    if(ueNrCap->rf_Parameters.supportedBandListNR.list.array)
6055    {
6056       for(arrIdx = 0; arrIdx < ueNrCap->rf_Parameters.supportedBandListNR.list.count; arrIdx++)
6057       {
6058          if(ueNrCap->rf_Parameters.supportedBandListNR.list.array[arrIdx])
6059             free(ueNrCap->rf_Parameters.supportedBandListNR.list.array[arrIdx]);
6060       }
6061       free(ueNrCap->rf_Parameters.supportedBandListNR.list.array);
6062    }
6063
6064    if(ueNrCap->featureSets)
6065    {
6066       featureSets = ueNrCap->featureSets;
6067       if(featureSets->featureSetsDownlinkPerCC)
6068       {
6069          if(featureSets->featureSetsDownlinkPerCC->list.array)
6070          {
6071             for(arrIdx = 0; arrIdx < featureSets->featureSetsDownlinkPerCC->list.count; arrIdx++)
6072             {
6073                if(featureSets->featureSetsDownlinkPerCC->list.array[arrIdx])
6074                {
6075                   if(featureSets->featureSetsDownlinkPerCC->list.array[arrIdx]->supportedModulationOrderDL)
6076                      free(featureSets->featureSetsDownlinkPerCC->list.array[arrIdx]->supportedModulationOrderDL);
6077                   free(featureSets->featureSetsDownlinkPerCC->list.array[arrIdx]);
6078                }
6079             }
6080             free(featureSets->featureSetsDownlinkPerCC->list.array);
6081          }
6082          free(featureSets->featureSetsDownlinkPerCC);
6083       }
6084       if(featureSets->featureSetsUplinkPerCC)
6085       {
6086          if(featureSets->featureSetsUplinkPerCC->list.array)
6087          {
6088             for(arrIdx = 0; arrIdx < featureSets->featureSetsUplinkPerCC->list.count; arrIdx++)
6089             {
6090                if(featureSets->featureSetsUplinkPerCC->list.array[arrIdx])
6091                {
6092                   if(featureSets->featureSetsUplinkPerCC->list.array[arrIdx]->supportedModulationOrderUL)
6093                      free(featureSets->featureSetsUplinkPerCC->list.array[arrIdx]->supportedModulationOrderUL);
6094                   free(featureSets->featureSetsUplinkPerCC->list.array[arrIdx]);
6095                }
6096             }
6097             free(featureSets->featureSetsUplinkPerCC->list.array);
6098          }
6099          free(featureSets->featureSetsUplinkPerCC);
6100       }
6101       free(ueNrCap->featureSets);
6102    }
6103 }
6104
6105 /*******************************************************************
6106 *
6107 * @brief Function to free PdcchSearchSpcToAddModList
6108          where memory allocated by aper_decoder
6109 *
6110 * @details
6111 *
6112 *    Function : freeAperDecodePdcchSearchSpcToAddModList
6113 *
6114 *    Functionality: Function to free PdcchSearchSpcToAddModList
6115 *
6116 * @params[in] struct PDCCH_Config__searchSpacesToAddModList *searchSpcList
6117 * @return void
6118 *
6119 * ****************************************************************/
6120
6121 void freeAperDecodePdcchSearchSpcToAddModList(struct PDCCH_Config__searchSpacesToAddModList *searchSpcList)
6122 {
6123    uint8_t searchSpcArrIdx=0;
6124    uint8_t searchSpcArrIdx1=0;
6125    struct  SearchSpace *searchSpc=NULLP;
6126
6127
6128    if(searchSpcList->list.array)
6129    {
6130       if(searchSpcList->list.array[searchSpcArrIdx1])
6131       {
6132          searchSpc = searchSpcList->list.array[searchSpcArrIdx1];
6133          if(searchSpc->controlResourceSetId)
6134          {
6135             if(searchSpc->monitoringSlotPeriodicityAndOffset)
6136             {
6137                if(searchSpc->monitoringSymbolsWithinSlot)
6138                {
6139                   if(searchSpc->monitoringSymbolsWithinSlot->buf)
6140                   {
6141                      if(searchSpc->nrofCandidates)
6142                      {
6143                         if(searchSpc->searchSpaceType)
6144                         {
6145                            free(searchSpc->searchSpaceType->choice.ue_Specific);
6146                            free(searchSpc->searchSpaceType);
6147                         }
6148                         free(searchSpc->nrofCandidates);
6149                      }
6150                      free(searchSpc->monitoringSymbolsWithinSlot->buf);
6151                   }
6152                   free(searchSpc->monitoringSymbolsWithinSlot);
6153                }
6154                free(searchSpc->monitoringSlotPeriodicityAndOffset);
6155             }
6156             free(searchSpc->controlResourceSetId);
6157          }
6158       }
6159       for(searchSpcArrIdx = 0; searchSpcArrIdx < searchSpcList->list.count; searchSpcArrIdx++)
6160       {
6161          free(searchSpcList->list.array[searchSpcArrIdx]);
6162       }
6163       free(searchSpcList->list.array);
6164    }
6165 }
6166 /*******************************************************************
6167 *
6168 * @brief Function for free part for the memory allocated by aper_decoder
6169 *
6170 * @details
6171 *
6172 *    Function : freeAperDecodeBWPDlDedPdcchConfig
6173 *
6174 *    Functionality: Function to free BWPDlDedPdcchConfig
6175 *
6176 * @params[in]
6177 * @return void
6178 *
6179 * ****************************************************************/
6180
6181
6182 void freeAperDecodeBWPDlDedPdcchConfig(BWP_DownlinkDedicated_t *dlBwp)
6183 {
6184    uint8_t arrIdx1=0;
6185    uint8_t arrIdx2=0;
6186    struct PDCCH_Config *pdcchCfg=NULLP;
6187    struct ControlResourceSet *controlRSet=NULLP;
6188    struct PDCCH_Config__controlResourceSetToAddModList *controlRSetList=NULLP;
6189
6190    if(dlBwp->pdcch_Config->choice.setup)
6191    {
6192       pdcchCfg=dlBwp->pdcch_Config->choice.setup;
6193       if(pdcchCfg->controlResourceSetToAddModList)
6194       {
6195          controlRSetList = pdcchCfg->controlResourceSetToAddModList;
6196          if(controlRSetList->list.array)
6197          {
6198             controlRSet = controlRSetList->list.array[arrIdx2];
6199             if(controlRSet)
6200             {
6201                if(controlRSet->frequencyDomainResources.buf)
6202                {
6203                   if(controlRSet->pdcch_DMRS_ScramblingID)
6204                   {
6205                      if(pdcchCfg->searchSpacesToAddModList)
6206                      {
6207                         freeAperDecodePdcchSearchSpcToAddModList(pdcchCfg->searchSpacesToAddModList);
6208                         free(pdcchCfg->searchSpacesToAddModList);
6209                      }
6210                      free(controlRSet->pdcch_DMRS_ScramblingID);
6211                   }
6212                   free(controlRSet->frequencyDomainResources.buf);
6213                }
6214             }
6215             for(arrIdx1 = 0; arrIdx1 <controlRSetList->list.count; arrIdx1++)
6216             {
6217                free(controlRSetList->list.array[arrIdx1]);
6218             }
6219             free(controlRSetList->list.array);
6220          }
6221          free(pdcchCfg->controlResourceSetToAddModList);
6222       }
6223       free(dlBwp->pdcch_Config->choice.setup);
6224    }
6225 }
6226 /*******************************************************************
6227 *
6228 * @brief Function to free PdschTimeDomAllocationList
6229 *     where the memory allocated by aper_decoder
6230 *
6231 * @details
6232 *
6233 *    Function : freeAperDecodePdschTimeDomAllocationList
6234 *
6235 *    Functionality: Function to free PdschTimeDomAllocationList
6236 *
6237 * @params[in] struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList
6238 * @return void
6239 *
6240 * ****************************************************************/
6241
6242
6243 void freeAperDecodePdschTimeDomAllocationList( struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList)
6244 {
6245    uint8_t arrIdx=0;
6246
6247    if(timeDomAllocList->choice.setup)
6248    {
6249       if(timeDomAllocList->choice.setup->list.array)
6250       {
6251          for(arrIdx = 0; arrIdx <timeDomAllocList->choice.setup->list.count ; arrIdx++)
6252          {
6253             free(timeDomAllocList->choice.setup->list.array[arrIdx]);
6254          }
6255          free(timeDomAllocList->choice.setup->list.array);
6256       }
6257       free(timeDomAllocList->choice.setup);
6258    }
6259 }
6260
6261 /*******************************************************************
6262 *
6263 * @brief Function to free BWPDlDedPdschConfig
6264 *        where the memory allocated by aper_decoder
6265 *
6266 * @details
6267 *
6268 *    Function : freeAperDecodeBWPDlDedPdschConfig
6269 *
6270 *    Functionality: Function to free BWPDlDedPdschConfig
6271 *
6272 * @params[in] BWP_DownlinkDedicated_t *dlBwp
6273 * @return void
6274 *
6275 * ****************************************************************/
6276
6277
6278 void freeAperDecodeBWPDlDedPdschConfig(BWP_DownlinkDedicated_t *dlBwp)
6279 {
6280    struct PDSCH_Config *pdschCfg=NULLP;
6281    struct PDSCH_Config__prb_BundlingType *prbBndlType=NULLP;
6282    struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList=NULLP;
6283    struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA *dmrsDlCfg=NULLP;
6284
6285    if(dlBwp->pdsch_Config->choice.setup)
6286    {
6287       pdschCfg=dlBwp->pdsch_Config->choice.setup;
6288       if(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA)
6289       {
6290          if(pdschCfg->pdsch_TimeDomainAllocationList)
6291          {
6292             timeDomAllocList=pdschCfg->pdsch_TimeDomainAllocationList;
6293             if(pdschCfg->maxNrofCodeWordsScheduledByDCI)
6294             {
6295                prbBndlType=&pdschCfg->prb_BundlingType;
6296                free(prbBndlType->choice.staticBundling);
6297                free(pdschCfg->maxNrofCodeWordsScheduledByDCI);
6298             }
6299             freeAperDecodePdschTimeDomAllocationList(timeDomAllocList);
6300             free(pdschCfg->pdsch_TimeDomainAllocationList);
6301          }
6302          dmrsDlCfg=pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA;
6303          if(dmrsDlCfg->choice.setup)
6304          {
6305             free(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition);
6306             free(dmrsDlCfg->choice.setup);
6307          }
6308          free(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA);
6309       }
6310       free(dlBwp->pdsch_Config->choice.setup);
6311    }
6312 }
6313 /*******************************************************************
6314 *
6315 * @brief Function to free PuschTimeDomAllocListCfg
6316                  where the memory allocated by aper_decoder
6317 *
6318 * @details
6319 *
6320 *    Function : freeAperDecodePuschTimeDomAllocListCfg
6321 *
6322 *    Functionality: Function to free PuschTimeDomAllocListCfg
6323 *
6324 * @params[in] PUSCH_Config_t *puschCfg
6325 * @return void
6326 *
6327 * ****************************************************************/
6328
6329
6330 void freeAperDecodePuschTimeDomAllocListCfg(PUSCH_Config_t *puschCfg)
6331 {
6332    uint8_t arrIdx=0;
6333    uint8_t arrIdx1=0;
6334    struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList_t=NULLP;
6335
6336    if(puschCfg->pusch_TimeDomainAllocationList)
6337    {
6338       timeDomAllocList_t=puschCfg->pusch_TimeDomainAllocationList;
6339       if(timeDomAllocList_t->choice.setup)
6340       {
6341          if(timeDomAllocList_t->choice.setup->list.array)
6342          {
6343             free(timeDomAllocList_t->choice.setup->list.array[arrIdx1]->k2);
6344             for(arrIdx = 0; arrIdx<timeDomAllocList_t->choice.setup->list.count; arrIdx++)
6345             {
6346                free(timeDomAllocList_t->choice.setup->list.array[arrIdx]);
6347             }
6348             free(timeDomAllocList_t->choice.setup->list.array);
6349          }
6350          free(timeDomAllocList_t->choice.setup);
6351       }
6352       free(puschCfg->transformPrecoder);
6353       free(puschCfg->pusch_TimeDomainAllocationList);
6354    }
6355 }
6356 /*******************************************************************
6357 *
6358 * @brief Function to free InitialUlBWPConfig where memory allocated by aper_decoder
6359 *
6360 * @details
6361 *
6362 *    Function : freeAperDecodeInitialUlBWPConfig
6363 *
6364 *    Functionality: Function to free InitialUlBWPConfig
6365 *
6366 * @params[in]  BWP_UplinkDedicated_t *ulBwp
6367 * @return void
6368 *
6369 * ****************************************************************/
6370
6371
6372 void freeAperDecodeInitialUlBWPConfig(BWP_UplinkDedicated_t *ulBwp)
6373 {
6374    uint8_t  rSetIdx =0;
6375    uint8_t  rsrcIdx =0;
6376    SRS_Config_t   *srsCfg = NULLP;
6377    PUSCH_Config_t *puschCfg = NULLP;
6378    struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA *dmrsUlCfg = NULLP;
6379    struct SRS_Config__srs_ResourceSetToAddModList *rsrcSetList = NULLP;
6380    struct SRS_ResourceSet__srs_ResourceIdList *rsrcIdList = NULLP;
6381    struct SRS_Config__srs_ResourceToAddModList *resourceList = NULLP;
6382
6383    if(ulBwp->pusch_Config)
6384    {
6385       if(ulBwp->pusch_Config->choice.setup)
6386       {
6387          puschCfg=ulBwp->pusch_Config->choice.setup;
6388          if(puschCfg->dataScramblingIdentityPUSCH)
6389          {
6390             if(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA)
6391             {
6392                freeAperDecodePuschTimeDomAllocListCfg(puschCfg);
6393                dmrsUlCfg=puschCfg->dmrs_UplinkForPUSCH_MappingTypeA;
6394                if(dmrsUlCfg->choice.setup)
6395                {
6396                   if(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition)
6397                   {
6398                      if(dmrsUlCfg->choice.setup->transformPrecodingDisabled)
6399                      {
6400                         free(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0);
6401                         free(dmrsUlCfg->choice.setup->transformPrecodingDisabled);
6402                      }
6403                      free(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition);
6404                   }
6405                   free(dmrsUlCfg->choice.setup);
6406                }
6407                free(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA);
6408             }
6409             free(puschCfg->dataScramblingIdentityPUSCH);
6410          }
6411          free(ulBwp->pusch_Config->choice.setup);
6412       }
6413       free(ulBwp->pusch_Config);
6414
6415       /* Free SRS-Config */
6416       if(ulBwp->srs_Config)
6417       {
6418          if(ulBwp->srs_Config->choice.setup)
6419          {
6420             srsCfg = ulBwp->srs_Config->choice.setup;
6421
6422             /* Free Resource Set to add/mod list */
6423             if(srsCfg->srs_ResourceSetToAddModList)
6424             {
6425                rsrcSetList = srsCfg->srs_ResourceSetToAddModList;
6426                if(rsrcSetList->list.array)
6427                {
6428                   rSetIdx = 0;
6429
6430                   /* Free SRS resource Id list in this SRS resource set */
6431                   if(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList)
6432                   {
6433                      rsrcIdList =
6434                         rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList;
6435
6436                      if(rsrcIdList->list.array)
6437                      {
6438                         for(rsrcIdx = 0; rsrcIdx < rsrcIdList->list.count;
6439                               rsrcIdx++)
6440                         {
6441                            free(rsrcIdList->list.array[rsrcIdx]);
6442                         }
6443                         free(rsrcIdList->list.array);
6444                      }
6445                      free(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList);
6446                   }
6447
6448                   /* Free resource type info for this SRS resource set */
6449
6450                   free(rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic);
6451
6452                   /* Free memory for each resource set */
6453                   for(rSetIdx = 0; rSetIdx < rsrcSetList->list.count; rSetIdx++)
6454                   {
6455                      free(rsrcSetList->list.array[rSetIdx]);
6456                   }
6457                   free(rsrcSetList->list.array);
6458                }
6459                free(srsCfg->srs_ResourceSetToAddModList);
6460             }
6461
6462             /* Free resource to add/modd list */
6463             if(srsCfg->srs_ResourceToAddModList)
6464             {
6465                resourceList = srsCfg->srs_ResourceToAddModList;
6466                if(resourceList->list.array)
6467                {
6468                   rsrcIdx = 0;
6469
6470                   free(resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2);
6471                   free(resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic);
6472
6473                   for(rsrcIdx = 0; rsrcIdx < resourceList->list.count; rsrcIdx++)
6474                   {
6475                      free(resourceList->list.array[rsrcIdx]);
6476                   }
6477                   free(resourceList->list.array);
6478                }
6479                free(srsCfg->srs_ResourceToAddModList);
6480             }
6481
6482             free(ulBwp->srs_Config->choice.setup);
6483          }
6484          free(ulBwp->srs_Config);
6485       }
6486    }
6487 }
6488 /*******************************************************************
6489 *
6490 * @brief Function to free initialUplinkBWPConfig where memory allocated by aper_decoder
6491 *
6492 * @details
6493 *
6494 *    Function : freeAperDecodeinitialUplinkBWPConfig
6495 *
6496 *    Functionality: Function to free initialUplinkBWPConfig
6497 *
6498 * @params[in] UplinkConfig_t *ulCfg
6499 * @return void
6500 *
6501 * ****************************************************************/
6502
6503
6504 void freeAperDecodeinitialUplinkBWPConfig(UplinkConfig_t *ulCfg)
6505 {
6506    BWP_UplinkDedicated_t *ulBwp=NULLP;
6507    struct UplinkConfig__pusch_ServingCellConfig *puschCfg=NULLP;
6508
6509    if(ulCfg->initialUplinkBWP)
6510    {
6511       ulBwp=ulCfg->initialUplinkBWP;
6512       if(ulCfg->firstActiveUplinkBWP_Id)
6513       {
6514          if(ulCfg->pusch_ServingCellConfig)
6515          {
6516             puschCfg=ulCfg->pusch_ServingCellConfig;
6517             if(puschCfg->choice.setup)
6518             {
6519                if(puschCfg->choice.setup->ext1)
6520                {
6521                   free(puschCfg->choice.setup->ext1->processingType2Enabled);
6522                   free(puschCfg->choice.setup->ext1->maxMIMO_Layers);
6523                   free(puschCfg->choice.setup->ext1);
6524                }
6525                free(puschCfg->choice.setup);
6526             }
6527             free(ulCfg->pusch_ServingCellConfig);
6528          }
6529          free(ulCfg->firstActiveUplinkBWP_Id);
6530       }
6531       freeAperDecodeInitialUlBWPConfig(ulBwp);
6532       free(ulCfg->initialUplinkBWP);
6533    }
6534 }
6535
6536 /*******************************************************************
6537  *
6538  * @brief Function to free DuUeCfg
6539  *
6540  * @details
6541  *
6542  *    Function : freeDuUeCfg
6543  *
6544  *    Functionality: Function to free DuUeCfg
6545  *
6546  * @params[in] DuUeCfg *ueCfg
6547  * @return void
6548  *
6549  * ****************************************************************/
6550 void freeDuUeCfg(DuUeCfg *ueCfg)
6551 {
6552    uint8_t lcIdx = 0;
6553    uint8_t arrIdx = 0;
6554    SpCellConfig_t *spCellCfg = NULLP;
6555    ServingCellConfig_t *srvCellCfg = NULLP;
6556    BWP_DownlinkDedicated_t *dlBwp = NULLP;
6557    MAC_CellGroupConfig_t *macCellGrpCfg = NULLP;
6558    PhysicalCellGroupConfig_t *phyCellGrpCfg = NULLP;
6559    struct CellGroupConfigRrc__rlc_BearerToAddModList *rlcBearerList = NULLP;
6560    struct RLC_Config *rlcConfig = NULLP;
6561    struct LogicalChannelConfig *macLcConfig = NULLP;
6562    struct SchedulingRequestConfig *schedulingRequestConfig = NULLP;
6563    struct SchedulingRequestConfig__schedulingRequestToAddModList *schReqList = NULLP;
6564    struct TAG_Config *tagConfig = NULLP;
6565    struct TAG_Config__tag_ToAddModList *tagList = NULLP;
6566    struct MAC_CellGroupConfig__phr_Config *phrConfig = NULLP;
6567    struct ServingCellConfig__pdsch_ServingCellConfig *pdschCfg = NULLP;
6568    CellGroupConfigRrc_t *cellGrpCfg = ueCfg->cellGrpCfg;
6569
6570    if(ueCfg->ueNrCapability)
6571    {
6572       freeAperDecodeUeNrCapability(ueCfg->ueNrCapability);
6573       DU_FREE(ueCfg->ueNrCapability, sizeof(UE_NR_Capability_t));
6574       ueCfg->ueNrCapability = NULLP;
6575    }
6576
6577    if(ueCfg->cellGrpCfg)
6578    {
6579
6580       rlcBearerList = cellGrpCfg->rlc_BearerToAddModList;
6581       if(rlcBearerList)
6582       {
6583          if(rlcBearerList->list.array)
6584          {
6585             for(arrIdx=0; arrIdx<rlcBearerList->list.count; arrIdx++)
6586             {
6587                if(rlcBearerList->list.array[arrIdx])
6588                {
6589                   rlcConfig   = rlcBearerList->list.array[arrIdx]->rlc_Config;
6590                   macLcConfig = rlcBearerList->list.array[arrIdx]->mac_LogicalChannelConfig;
6591
6592                   if(rlcBearerList->list.array[arrIdx]->servedRadioBearer)
6593                   {
6594                      free(rlcBearerList->list.array[arrIdx]->servedRadioBearer);
6595                   }
6596                   if(rlcConfig)
6597                   {
6598                      if(rlcConfig->choice.am)
6599                      {
6600                         free(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength);
6601                         free(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength);
6602                         free(rlcConfig->choice.am);
6603                      }
6604                      free(rlcBearerList->list.array[arrIdx]->rlc_Config);
6605                   }
6606                   if(macLcConfig)
6607                   {
6608                      if(macLcConfig->ul_SpecificParameters)
6609                      {
6610                         free(macLcConfig->ul_SpecificParameters->schedulingRequestID);
6611                         free(macLcConfig->ul_SpecificParameters->logicalChannelGroup);
6612                         free(macLcConfig->ul_SpecificParameters);
6613                      }
6614                      free(rlcBearerList->list.array[arrIdx]->mac_LogicalChannelConfig);
6615                   }
6616                   free(rlcBearerList->list.array[arrIdx]);
6617                }
6618             }
6619             free(rlcBearerList->list.array);
6620          }
6621          free(cellGrpCfg->rlc_BearerToAddModList);
6622       }
6623
6624       macCellGrpCfg = cellGrpCfg->mac_CellGroupConfig;
6625       if(macCellGrpCfg)
6626       {
6627          schedulingRequestConfig = macCellGrpCfg->schedulingRequestConfig;
6628          if(schedulingRequestConfig)
6629          {
6630             schReqList = schedulingRequestConfig->schedulingRequestToAddModList;
6631             if(schReqList)
6632             {
6633                if(schReqList->list.array)
6634                {
6635                   for(arrIdx=0;arrIdx<schReqList->list.count; arrIdx++)
6636                   {
6637                      if(schReqList->list.array[arrIdx])
6638                      {
6639                         free(schReqList->list.array[arrIdx]->sr_ProhibitTimer);
6640                         free(schReqList->list.array[arrIdx]);
6641                      }
6642                   }
6643                   free(schReqList->list.array);
6644                }
6645                free(schedulingRequestConfig->schedulingRequestToAddModList);
6646             }
6647             free(macCellGrpCfg->schedulingRequestConfig);
6648          }
6649          if(macCellGrpCfg->bsr_Config)
6650          {
6651             free(macCellGrpCfg->bsr_Config);
6652          }
6653          tagConfig = macCellGrpCfg->tag_Config;
6654          if(tagConfig)
6655          {
6656             tagList = tagConfig->tag_ToAddModList;
6657             if(tagList)
6658             {
6659                if(tagList->list.array)
6660                {
6661                   for(arrIdx=0; arrIdx<tagList->list.count; arrIdx++)
6662                   {
6663                      free(tagList->list.array[arrIdx]);
6664                   }
6665                   free(tagList->list.array);
6666                }
6667                free(tagConfig->tag_ToAddModList);
6668             }
6669             free(tagConfig);
6670          }
6671
6672          phrConfig = macCellGrpCfg->phr_Config;
6673          if(phrConfig)
6674          {
6675             free(phrConfig->choice.setup);
6676             free(phrConfig);
6677          }
6678
6679          free(macCellGrpCfg);
6680       }
6681
6682       phyCellGrpCfg = cellGrpCfg->physicalCellGroupConfig;
6683       if(phyCellGrpCfg)
6684       {
6685          free(phyCellGrpCfg->p_NR_FR1);
6686          free(phyCellGrpCfg);
6687       }
6688
6689       spCellCfg = cellGrpCfg->spCellConfig;
6690       if(spCellCfg)
6691       {
6692          if(spCellCfg->servCellIndex)
6693          {
6694             if(spCellCfg->rlmInSyncOutOfSyncThreshold)
6695             {
6696                if(spCellCfg->spCellConfigDedicated)
6697                {
6698                   srvCellCfg = spCellCfg->spCellConfigDedicated;
6699                   if(srvCellCfg->initialDownlinkBWP)
6700                   {
6701                      dlBwp = srvCellCfg->initialDownlinkBWP;
6702                      if(srvCellCfg->firstActiveDownlinkBWP_Id)
6703                      {
6704                         if(srvCellCfg->defaultDownlinkBWP_Id)
6705                         {
6706                            if(srvCellCfg->uplinkConfig)
6707                            {
6708
6709                               if(srvCellCfg->pdsch_ServingCellConfig)
6710                               {
6711                                  pdschCfg=
6712                                     srvCellCfg->pdsch_ServingCellConfig;
6713                                  if(pdschCfg->choice.setup)
6714                                  {
6715
6716                                     free(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH);
6717                                     free(pdschCfg->choice.setup);
6718                                  }
6719
6720                                  free(srvCellCfg->pdsch_ServingCellConfig);
6721                               }
6722
6723                               freeAperDecodeinitialUplinkBWPConfig(srvCellCfg->uplinkConfig);
6724                               free(srvCellCfg->uplinkConfig);
6725                            }
6726                            free(srvCellCfg->defaultDownlinkBWP_Id);
6727                         }
6728
6729                         free(srvCellCfg->firstActiveDownlinkBWP_Id);
6730                      }
6731                      if(dlBwp->pdcch_Config)
6732                      {
6733                         if(dlBwp->pdsch_Config)
6734                         {
6735                            freeAperDecodeBWPDlDedPdschConfig(dlBwp);
6736                            free(dlBwp->pdsch_Config);
6737                         }
6738                         freeAperDecodeBWPDlDedPdcchConfig(dlBwp);
6739                         free(dlBwp->pdcch_Config);
6740                      }
6741                      free(srvCellCfg->initialDownlinkBWP);
6742                   }
6743
6744                   free(spCellCfg->spCellConfigDedicated);
6745                }
6746                free(spCellCfg->rlmInSyncOutOfSyncThreshold);
6747             }
6748             free(spCellCfg->servCellIndex);
6749          }
6750          free(spCellCfg);
6751       }
6752       DU_FREE(ueCfg->cellGrpCfg, sizeof(CellGroupConfigRrc_t));
6753       ueCfg->cellGrpCfg = NULLP;
6754    }
6755    if(ueCfg->ambrCfg)
6756    {
6757       memset(ueCfg->ambrCfg, 0, sizeof(AmbrCfg));
6758       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, ueCfg->ambrCfg, sizeof(AmbrCfg));
6759    }
6760    for(lcIdx = 0; lcIdx < ueCfg->numRlcLcs; lcIdx++)
6761    {
6762       freeRlcLcCfg(&ueCfg->rlcLcCfg[lcIdx]);
6763    }
6764    for(lcIdx = 0; lcIdx < ueCfg->numMacLcs; lcIdx++)
6765    {
6766       freeMacLcCfg(&ueCfg->macLcCfg[lcIdx]);
6767    }
6768    for(lcIdx = 0; lcIdx < ueCfg->numDrb; lcIdx++)
6769    {
6770       DU_FREE(ueCfg->upTnlInfo[lcIdx].tnlCfg1, sizeof(GtpTnlCfg));
6771       memset(&ueCfg->upTnlInfo[lcIdx], 0, sizeof(UpTnlCfg));
6772    }
6773 }
6774
6775 /*******************************************************************
6776  *
6777  * @brief Function to free UecontextSetupDb
6778  *
6779  * @details
6780  *
6781  *    Function : freeF1UeDb
6782  *
6783  *    Functionality: Function to free UecontextSetupDb
6784  *
6785  * @params[in] UecontextSetupDb *
6786  * @return void
6787  *
6788  * ****************************************************************/
6789
6790 void freeF1UeDb(F1UeContextSetupDb *f1UeDb)
6791 {
6792
6793    if(f1UeDb->dlRrcMsg)
6794    {
6795       if(f1UeDb->dlRrcMsg->rrcMsgPdu)
6796       {
6797          DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL,\
6798             f1UeDb->dlRrcMsg->rrcMsgPdu, f1UeDb->dlRrcMsg->rrcMsgSize);
6799       }
6800       memset(f1UeDb->dlRrcMsg, 0, sizeof(F1DlRrcMsg));
6801    }
6802    freeDuUeCfg(&f1UeDb->duUeCfg);
6803    memset(f1UeDb, 0, sizeof(F1UeContextSetupDb));
6804    DU_FREE(f1UeDb, sizeof(F1UeContextSetupDb));
6805 }
6806
6807 /*******************************************************************
6808  *
6809  * @brief Function to build Am cfg Info
6810  *
6811  * @details
6812  *
6813  *    Function : extractRlcAmCfg
6814  *
6815  *    Functionality: Function to build Am cfg Info
6816  *
6817  * @params[in] AmBearerCfg *
6818  *             void *
6819  *
6820  * @return ROK/RFAILED
6821  *
6822  * ****************************************************************/
6823
6824 void extractRlcAmCfg(AmBearerCfg *amCfgToSet, struct RLC_Config__am *rlcAmCfg)
6825 {
6826    if(rlcAmCfg)
6827    {
6828       /* UL AM */
6829       if(rlcAmCfg->dl_AM_RLC.sn_FieldLength)
6830       {
6831          amCfgToSet->ulAmCfg.snLenUl = *(rlcAmCfg->dl_AM_RLC.sn_FieldLength);
6832          /*TODO: Check the timer value when sent by real CU */
6833          amCfgToSet->ulAmCfg.reAssemTmr = rlcAmCfg->dl_AM_RLC.t_Reassembly;
6834          amCfgToSet->ulAmCfg.statProhTmr = rlcAmCfg->dl_AM_RLC.t_StatusProhibit;
6835       }
6836
6837       /* DL AM */
6838       if(rlcAmCfg->ul_AM_RLC.sn_FieldLength)
6839       {
6840          amCfgToSet->dlAmCfg.snLenDl = *(rlcAmCfg->ul_AM_RLC.sn_FieldLength);
6841          amCfgToSet->dlAmCfg.pollRetxTmr = rlcAmCfg->ul_AM_RLC.t_PollRetransmit;
6842          amCfgToSet->dlAmCfg.pollPdu   = rlcAmCfg->ul_AM_RLC.pollPDU;
6843          amCfgToSet->dlAmCfg.pollByte  = rlcAmCfg->ul_AM_RLC.pollByte;
6844          amCfgToSet->dlAmCfg.maxRetxTh = rlcAmCfg->ul_AM_RLC.maxRetxThreshold;
6845       }
6846    }
6847 }
6848
6849 /*******************************************************************
6850  *
6851  * @brief Function to build Um Bi Info
6852  *
6853  * @details
6854  *
6855  *    Function : extractRlcUmBiCfg
6856  *
6857  *    Functionality: Function to build Um Bi Info
6858  *
6859  * @params[in] UmBiDirBearerCfg *
6860  *             void *
6861  *
6862  * @return ROK/RFAILED
6863  *
6864  * ****************************************************************/
6865
6866 void extractRlcUmBiCfg(UmBiDirBearerCfg *umBiCfgToSet, struct RLC_Config__um_Bi_Directional *rlcBiCfg)
6867 {
6868    if(rlcBiCfg)
6869    {
6870       /* UL UM BI DIR Cfg */
6871       if(rlcBiCfg->dl_UM_RLC.sn_FieldLength)
6872       {
6873          umBiCfgToSet->ulUmCfg.snLenUlUm  = *(rlcBiCfg->dl_UM_RLC.sn_FieldLength);
6874          umBiCfgToSet->ulUmCfg.reAssemTmr = rlcBiCfg->dl_UM_RLC.t_Reassembly;
6875       }
6876
6877       /* DL UM BI DIR Cfg */
6878       if(rlcBiCfg->ul_UM_RLC.sn_FieldLength)
6879          umBiCfgToSet->dlUmCfg.snLenDlUm  = *(rlcBiCfg->ul_UM_RLC.sn_FieldLength);
6880    }
6881 }
6882
6883 /*******************************************************************
6884  *
6885  * @brief Function to build Um Ul Info
6886  *
6887  * @details
6888  *
6889  *    Function : extractRlcUmUlCfg
6890  *
6891  *    Functionality: Function to build Um Ul Info
6892  *
6893  * @params[in] UmUniDirUlBearerCfg *
6894  *             void *
6895  *
6896  * @return ROK/RFAILED
6897  *
6898  * ****************************************************************/
6899
6900 void extractRlcUmUlCfg(UmUniDirUlBearerCfg *umUlCfgToSet, struct RLC_Config__um_Uni_Directional_DL *umUlCfg)
6901 {
6902    if(umUlCfg)
6903    {
6904       if(umUlCfg->dl_UM_RLC.sn_FieldLength)
6905       {
6906          umUlCfgToSet->ulUmCfg.snLenUlUm  = *(umUlCfg->dl_UM_RLC.sn_FieldLength);
6907          umUlCfgToSet->ulUmCfg.reAssemTmr = umUlCfg->dl_UM_RLC.t_Reassembly;
6908       }
6909    }
6910 }
6911
6912 /*******************************************************************
6913  *
6914  * @brief Function to build Um Uni Dl Info
6915  *
6916  * @details
6917  *
6918  *    Function : extractRlcUmDlCfg
6919  *
6920  *    Functionality: Function to build Um Uni Dl Info
6921  *
6922  * @params[in] UmUniDirDlBearerCfg *
6923  *             void *
6924  *
6925  * @return ROK/RFAILED
6926  *
6927  * ****************************************************************/
6928 void extractRlcUmDlCfg(UmUniDirDlBearerCfg *umDlCfgToSet, struct RLC_Config__um_Uni_Directional_UL *umDlCfg)
6929 {
6930    if(umDlCfg)
6931    {
6932       if(umDlCfg->ul_UM_RLC.sn_FieldLength)
6933          umDlCfgToSet->dlUmCfg.snLenDlUm  = *(umDlCfg->ul_UM_RLC.sn_FieldLength);
6934    }
6935 }
6936
6937 /*******************************************************************
6938  *
6939  * @brief Function to extractRlcModeCfg
6940  *
6941  * @details
6942  *
6943  *    Function : extractRlcModeCfg
6944  *
6945  *    Functionality: Function to extractRlcModeCfg
6946  *
6947  * @params[in] RLC_Config_t *
6948  *             RlcBearerCfg *
6949  *             void  *
6950  * @return ROK/RFAILED
6951  *
6952  * ****************************************************************/
6953 void extractRlcModeCfg(uint8_t rlcMode, RlcBearerCfg *rlcDbCfg, RLC_Config_t *lcCfg)
6954 {
6955    if(lcCfg)
6956    {
6957       switch(rlcMode)
6958       {
6959          case RLC_AM :
6960             {
6961                if(lcCfg->choice.am)
6962                {
6963                   DU_ALLOC_SHRABL_BUF(rlcDbCfg->u.amCfg, sizeof(AmBearerCfg));
6964                   if(rlcDbCfg->u.amCfg)
6965                      extractRlcAmCfg(rlcDbCfg->u.amCfg, lcCfg->choice.am);
6966                }
6967                break;
6968             }
6969          case RLC_UM_BI_DIRECTIONAL :
6970             {
6971                if(lcCfg->choice.um_Bi_Directional)
6972                {
6973                   DU_ALLOC_SHRABL_BUF(rlcDbCfg->u.umBiDirCfg, sizeof(UmBiDirBearerCfg));
6974                   if(rlcDbCfg->u.umBiDirCfg)
6975                      extractRlcUmBiCfg(rlcDbCfg->u.umBiDirCfg, lcCfg->choice.um_Bi_Directional);
6976                }
6977                break;
6978             }
6979          case RLC_UM_UNI_DIRECTIONAL_UL :
6980             {
6981                if(lcCfg->choice.um_Uni_Directional_DL)
6982                {
6983                   DU_ALLOC_SHRABL_BUF(rlcDbCfg->u.umUniDirUlCfg, sizeof(UmUniDirUlBearerCfg));
6984                   if(rlcDbCfg->u.umUniDirUlCfg)
6985                      extractRlcUmUlCfg(rlcDbCfg->u.umUniDirUlCfg, lcCfg->choice.um_Uni_Directional_DL);
6986                }
6987                break;
6988             }
6989          case RLC_UM_UNI_DIRECTIONAL_DL :
6990             {
6991                if(lcCfg->choice.um_Uni_Directional_UL)
6992                {
6993                   DU_ALLOC_SHRABL_BUF(rlcDbCfg->u.umUniDirDlCfg, sizeof(UmUniDirDlBearerCfg));
6994                   if(rlcDbCfg->u.umUniDirDlCfg)
6995                      extractRlcUmDlCfg(rlcDbCfg->u.umUniDirDlCfg, lcCfg->choice.um_Uni_Directional_UL);
6996                }
6997                break;
6998             }
6999          default:
7000             DU_LOG("\nERROR  -->  DUAPP: Invalid rlcMode %d at extractRlcCfgToAddMod()", rlcMode);
7001             break;
7002       }
7003    }
7004 }
7005
7006 /*******************************************************************
7007  *
7008  * @brief Function to extract extractUlLcCfg
7009  *
7010  * @details
7011  *
7012  *    Function : extractUlLcCfg
7013  *
7014  *    Functionality: Function to extract extractUlLcCfg
7015  *
7016  * @params[in] UlLcCfg *f1UlLcCfg, LogicalChannelConfig_t *ulLcCfg
7017  * @return void
7018  *
7019  * ****************************************************************/
7020
7021 void extractUlLcCfg(UlLcCfg *f1UlLcCfg, LogicalChannelConfig_t *ulLcCfg)
7022 {
7023    if(ulLcCfg)
7024    {
7025       if(ulLcCfg->ul_SpecificParameters)
7026       {
7027          f1UlLcCfg->priority = \
7028             ulLcCfg->ul_SpecificParameters->priority;
7029       if(ulLcCfg->ul_SpecificParameters->logicalChannelGroup)
7030       {
7031          f1UlLcCfg->lcGroup = \
7032            *(ulLcCfg->ul_SpecificParameters->logicalChannelGroup);
7033       }
7034       if(ulLcCfg->ul_SpecificParameters->schedulingRequestID)
7035       {
7036          f1UlLcCfg->schReqId = \
7037            *(ulLcCfg->ul_SpecificParameters->schedulingRequestID);
7038       }
7039       f1UlLcCfg->pbr = \
7040          ulLcCfg->ul_SpecificParameters->prioritisedBitRate;
7041       f1UlLcCfg->bsd = \
7042          ulLcCfg->ul_SpecificParameters->bucketSizeDuration;
7043       }
7044    }
7045 }
7046
7047 /*******************************************************************
7048  *
7049  * @brief Function to procRlcLcCfg
7050  *
7051  * @details
7052  *
7053  *    Function : procRlcLcCfg
7054  *
7055  *    Functionality: Function to procRlcLcCfg
7056  *
7057  * @params[in] rbId, lcId, rbType, rlcMod
7058  *             RLC_Config_t *, RlcBearerCfg * ,
7059  * @return void
7060  *
7061  * ****************************************************************/
7062
7063 void procRlcLcCfg(uint8_t rbId, uint8_t lcId, uint8_t rbType, uint8_t rlcMode,\
7064    uint8_t configType, RLC_Config_t *f1RlcCfg, RlcBearerCfg *lcCfg)
7065 {
7066
7067    lcCfg->rbId   = rbId;
7068    lcCfg->configType = configType;
7069
7070    if(rbType == RB_TYPE_SRB)
7071    {
7072       lcCfg->rbType = RB_TYPE_SRB;
7073       lcCfg->lcId   = rbId;
7074       lcCfg->lcType = LCH_DCCH;
7075       lcCfg->rlcMode = RLC_AM;
7076    }
7077    else if(rbType == RB_TYPE_DRB)
7078    {
7079       lcCfg->rbType = RB_TYPE_DRB;
7080       lcCfg->lcId   = lcId;
7081       lcCfg->lcType = LCH_DTCH;
7082       lcCfg->rlcMode = rlcMode;
7083    }
7084    if(f1RlcCfg) /* rlc mode config recived */
7085    {
7086       extractRlcModeCfg(lcCfg->rlcMode, lcCfg, f1RlcCfg);
7087    }
7088 }
7089
7090
7091
7092 /*******************************************************************
7093  *
7094  * @brief Fills DrbQos Info received by CU
7095  *
7096  * @details
7097  *
7098  *    Function : extractQosInfo
7099  *
7100  *    Functionality: Fills DrbQos Info received  by CU
7101  *
7102  * @params[in] DrbQosInfo *qosToAdd,
7103  *             QoSFlowLevelQoSParameters_t *qosFlowCfg
7104  * @return void
7105  *
7106  * ****************************************************************/
7107
7108 void extractQosInfo(DrbQosInfo *qosToAdd, QoSFlowLevelQoSParameters_t *qosFlowCfg)
7109 {
7110    qosToAdd->fiveQiType = qosFlowCfg->qoS_Characteristics.present;
7111    qosToAdd->u.nonDyn5Qi.fiveQi     =\
7112          qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->fiveQI;
7113    if(qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow)
7114    {
7115       qosToAdd->u.nonDyn5Qi.avgWindow = \
7116         *(qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow);
7117    }
7118    qosToAdd->u.nonDyn5Qi.maxDataBurstVol = \
7119       *(qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume);
7120    if(qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->qoSPriorityLevel)
7121    {
7122       qosToAdd->u.nonDyn5Qi.priorLevel = \
7123          *(qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->qoSPriorityLevel);
7124    }
7125    qosToAdd->ngRanRetPri.priorityLevel = \
7126       qosFlowCfg->nGRANallocationRetentionPriority.priorityLevel;
7127    qosToAdd->ngRanRetPri.preEmptionCap = \
7128       qosFlowCfg->nGRANallocationRetentionPriority.pre_emptionCapability;
7129    qosToAdd->ngRanRetPri.preEmptionVul = \
7130       qosFlowCfg->nGRANallocationRetentionPriority.pre_emptionVulnerability;
7131    if(qosFlowCfg->gBR_QoS_Flow_Information)
7132    {
7133       memcpy(&qosToAdd->grbQosInfo.maxFlowBitRateDl, \
7134          qosFlowCfg->gBR_QoS_Flow_Information->maxFlowBitRateDownlink.buf, \
7135          qosFlowCfg->gBR_QoS_Flow_Information->maxFlowBitRateDownlink.size);
7136       memcpy(&qosToAdd->grbQosInfo.maxFlowBitRateUl, \
7137          qosFlowCfg->gBR_QoS_Flow_Information->maxFlowBitRateUplink.buf, \
7138          qosFlowCfg->gBR_QoS_Flow_Information->maxFlowBitRateUplink.size);
7139       memcpy(&qosToAdd->grbQosInfo.guarFlowBitRateDl,\
7140          qosFlowCfg->gBR_QoS_Flow_Information->guaranteedFlowBitRateDownlink.buf, \
7141          qosFlowCfg->gBR_QoS_Flow_Information->guaranteedFlowBitRateDownlink.size);
7142       memcpy(&qosToAdd->grbQosInfo.guarFlowBitRateUl,\
7143          qosFlowCfg->gBR_QoS_Flow_Information->guaranteedFlowBitRateUplink.buf, \
7144          qosFlowCfg->gBR_QoS_Flow_Information->guaranteedFlowBitRateUplink.size);
7145    }
7146    qosToAdd->pduSessionId = 0;
7147    qosToAdd->ulPduSessAggMaxBitRate = 0;
7148 }
7149
7150 /*******************************************************************
7151  *
7152  * @brief Function to extract GTP Tunnel Info from CU
7153  *
7154  * @details
7155  *
7156  *    Function : extractUpTnlInfo
7157  *
7158  *    Functionality: Function to extract GTP Tunnel Info from CU
7159  *
7160  * @params[in] F1AP message
7161  * @return ROK/RFAILED
7162  *
7163  * ****************************************************************/
7164
7165 uint8_t extractUpTnlInfo(uint8_t drbId, uint8_t configType,\
7166    ULUPTNLInformation_ToBeSetup_List_t *tnlInfo, UpTnlCfg *upTnlInfo)
7167 {
7168    uint8_t tnlIdx;
7169    uint32_t ipv4_du = 0;
7170    GTPTunnel_t *gtpTunnel = NULLP;
7171
7172    upTnlInfo->drbId = drbId;
7173    upTnlInfo->configType = configType;
7174 #ifdef O1_ENABLE
7175    cmInetAddr((S8*)g_cfg.DU_IPV4_Addr, &ipv4_du);
7176 #else
7177    cmInetAddr((char *)DU_IP_V4_ADDR, &ipv4_du);
7178 #endif
7179
7180    for(tnlIdx=0; tnlIdx < tnlInfo->list.count; tnlIdx++)
7181    {
7182       if(tnlInfo->list.array[tnlIdx]->uLUPTNLInformation.present == UPTransportLayerInformation_PR_gTPTunnel)
7183       {
7184          if(tnlInfo->list.array[tnlIdx]->uLUPTNLInformation.choice.gTPTunnel)
7185          {
7186             gtpTunnel = tnlInfo->list.array[tnlIdx]->uLUPTNLInformation.choice.gTPTunnel;
7187             DU_ALLOC(upTnlInfo->tnlCfg1, sizeof(GtpTnlCfg));
7188             if(upTnlInfo->tnlCfg1 == NULLP)
7189             {
7190                DU_LOG("\nERROR  -->  F1AP : extractUpTnlInfo: Failed to allocate mmeory for tunnel cfg 1");
7191                return RFAILED;
7192             }
7193             bitStringToInt(&gtpTunnel->transportLayerAddress, &upTnlInfo->tnlCfg1->ulTnlAddress);
7194             upTnlInfo->tnlCfg1->dlTnlAddress = ipv4_du;
7195             if(gtpTunnel->gTP_TEID.size > 0)
7196             {
7197                teIdStringToInt(gtpTunnel->gTP_TEID.buf, &upTnlInfo->tnlCfg1->teId);
7198             }
7199          }
7200          break;
7201       }
7202    }
7203    return ROK;
7204 }
7205 /*******************************************************************
7206 *
7207 * @brief Function to extract Drb Qos Cfg Info from CU
7208 *
7209 * @details
7210 *
7211 *    Function : extractDrbQosCfg
7212 *
7213 *    Functionality: Function to extract Drb Qos Cfg Info from CU
7214 *
7215 * @params[in] DRB_Information_t *drbInfo, LcCfg *macLcToAdd
7216 * @return ROK/RFAILED
7217 *
7218 * ****************************************************************/
7219
7220 uint8_t extractDrbQosCfg(DRB_Information_t *drbInfo, LcCfg *macLcToAdd )
7221 {
7222    if(!macLcToAdd->drbQos)
7223    {
7224       DU_ALLOC_SHRABL_BUF(macLcToAdd->drbQos, sizeof(DrbQosInfo));
7225       if(macLcToAdd->drbQos == NULLP)
7226       {
7227          DU_LOG("\nERROR  -->  DUAPP:Memory failed at allocating DrbQos at extractDrbCfg()");
7228          return RFAILED;
7229       }
7230
7231    }
7232    if(drbInfo->dRB_QoS.qoS_Characteristics.present == QoS_Characteristics_PR_non_Dynamic_5QI)
7233    {
7234       extractQosInfo(macLcToAdd->drbQos, &drbInfo->dRB_QoS);
7235       macLcToAdd->dlLcCfg.lcp = macLcToAdd->drbQos->ngRanRetPri.priorityLevel;
7236    }
7237    if(!macLcToAdd->snssai)
7238    {
7239       DU_ALLOC_SHRABL_BUF(macLcToAdd->snssai, sizeof(Snssai));
7240       if(macLcToAdd->snssai == NULLP)
7241       {
7242          DU_LOG("\nERROR  -->  DUAPP : Memory failed at allocating SNSSAI at extractDrbCfg()");
7243          return RFAILED;
7244       }
7245    }
7246    memcpy(&macLcToAdd->snssai->sst, drbInfo->sNSSAI.sST.buf, \
7247          drbInfo->sNSSAI.sST.size);
7248    if(drbInfo->sNSSAI.sD)
7249    {
7250       memcpy(macLcToAdd->snssai->sd, drbInfo->sNSSAI.sD->buf, \
7251             drbInfo->sNSSAI.sD->size);
7252    }
7253    return ROK;
7254 }
7255 /*******************************************************************
7256  *
7257  * @brief Function to extract DRB info received from CU
7258  *
7259  * @details
7260  *
7261  *    Function : extractDrbCfg
7262  *
7263  *    Functionality: Function to extract DRB info received from CU
7264  *
7265  * @params[in] F1AP message
7266  * @return void
7267  *
7268  * ****************************************************************/
7269 uint8_t extractDrbCfg(DRBs_ToBeSetup_Item_t *drbItem,DRBs_ToBeSetupMod_Item_t *drbSetupModItem,\
7270 LcCfg *macLcToAdd, UpTnlCfg *upTnlInfo)
7271 {
7272    DRB_Information_t *drbInfo = NULLP;
7273
7274    if(drbItem != NULLP)
7275    {
7276       if(extractUpTnlInfo(drbItem->dRBID, CONFIG_ADD, &drbItem->uLUPTNLInformation_ToBeSetup_List, upTnlInfo) != ROK)
7277       {
7278          DU_LOG("\nERROR  -->  DUAPP : Failed to extract tunnel Cfg at extractDrbCfg()");
7279          return RFAILED;
7280       }
7281       if(drbItem->qoSInformation.present == QoSInformation_PR_choice_extension)
7282       {
7283          if(drbItem->qoSInformation.choice.choice_extension->value.present == QoSInformation_ExtIEs__value_PR_DRB_Information)
7284          {
7285             drbInfo = &drbItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information;
7286             if(extractDrbQosCfg(drbInfo , macLcToAdd) != ROK)
7287             {
7288                DU_LOG("\nERROR  -->  DUAPP : Failed to extract qos Cfg at extractDrbCfg()");
7289                return RFAILED;
7290             }
7291          }
7292       }
7293    }
7294    else if(drbSetupModItem != NULLP)
7295    {
7296       if(extractUpTnlInfo(drbSetupModItem->dRBID, CONFIG_ADD, &drbSetupModItem->uLUPTNLInformation_ToBeSetup_List,\
7297       upTnlInfo) != ROK)
7298       {
7299          DU_LOG("\nERROR  -->  DUAPP : Failed to extract tunnel Cfg at extractDrbCfg()");
7300          return RFAILED;
7301       }
7302       if(drbSetupModItem->qoSInformation.present == QoSInformation_PR_choice_extension)
7303       {
7304          if(drbSetupModItem->qoSInformation.choice.choice_extension->value.present ==\
7305          QoSInformation_ExtIEs__value_PR_DRB_Information)
7306          {
7307             drbInfo = &drbSetupModItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information;
7308             if(extractDrbQosCfg(drbInfo , macLcToAdd) != ROK)
7309             {
7310                DU_LOG("\nERROR  -->  DUAPP : Failed to extract qos Cfg at extractDrbCfg()");
7311                return RFAILED;
7312             }
7313
7314          }
7315       }
7316    }
7317
7318    return ROK;
7319 }
7320
7321 /*******************************************************************
7322  *
7323  * @brief Function to extract RB info received from CU
7324  *
7325  * @details
7326  *
7327  *    Function : extractMacRbCfg
7328  *
7329  *    Functionality: Function to extract RB info received from CU
7330  *
7331  * @params[in] F1AP message
7332  * @return ROK/RFAILED
7333  *
7334  * ****************************************************************/
7335
7336 uint8_t extractMacRbCfg(uint8_t lcId, DRBs_ToBeSetup_Item_t *drbCfg,\
7337 DRBs_ToBeSetupMod_Item_t *drbSetupModCfg,  LogicalChannelConfig_t *ulLcCfg, LcCfg *lcCfg, UpTnlCfg *upTnlInfo)
7338 {
7339    if(drbCfg != NULLP)
7340    {
7341       if(extractDrbCfg(drbCfg, NULL, lcCfg, upTnlInfo) != ROK)
7342       {
7343          DU_LOG("ERROR  -->  F1AP : Failed to build Drb Qos at extractMacRbCfg()");
7344          return RFAILED;
7345       }
7346    }
7347    else if(drbSetupModCfg != NULLP)
7348    {
7349       if(extractDrbCfg(NULL, drbSetupModCfg, lcCfg, upTnlInfo) != ROK)
7350       {
7351          DU_LOG("ERROR  -->  F1AP : Failed to build Drb Qos at extractMacRbCfg()");
7352          return RFAILED;
7353       }
7354    }
7355    else
7356    {
7357       lcCfg->drbQos = NULLP;
7358       lcCfg->snssai = NULLP;
7359       if(lcCfg->lcId == SRB2_LCID)
7360          lcCfg->dlLcCfg.lcp = LC_PRIORITY_3;
7361       else
7362          lcCfg->dlLcCfg.lcp = LC_PRIORITY_1;
7363    }
7364    if(ulLcCfg)
7365    {
7366       lcCfg->ulLcCfgPres = true;
7367       extractUlLcCfg(&lcCfg->ulLcCfg, ulLcCfg);
7368    }
7369    else
7370       lcCfg->ulLcCfgPres = false;
7371    return ROK;
7372 }
7373
7374 /*******************************************************************
7375  *
7376  * @brief Function processing LC config info received from CU
7377  *
7378  * @details
7379  *
7380  *    Function : procMacLcCfg
7381  *
7382  *    Functionality: Function processing LC config info received from CU
7383  *
7384  * @params[in] F1AP message
7385  * @return ROK/RFAILED
7386  *
7387  * ****************************************************************/
7388
7389 uint8_t procMacLcCfg(uint8_t lcId, uint8_t rbType, uint8_t configType,\
7390 DRBs_ToBeSetup_Item_t *drbItem, DRBs_ToBeSetupMod_Item_t *drbSetupModItem, LogicalChannelConfig_t *ulLcCfg,\
7391 LcCfg *lcCfg, UpTnlCfg *upTnlInfo)
7392 {
7393    uint8_t ret = ROK;
7394
7395    lcCfg->lcId = lcId;
7396    lcCfg->configType = configType;
7397    if(rbType == RB_TYPE_SRB)
7398    {
7399       ret = extractMacRbCfg(lcId, NULL,NULL, ulLcCfg, lcCfg, NULL);
7400    }
7401    else if(rbType == RB_TYPE_DRB)
7402    {
7403       if(drbItem != NULL)
7404         ret = extractMacRbCfg(lcId, drbItem, NULL, ulLcCfg, lcCfg, upTnlInfo);
7405       else if(drbSetupModItem != NULL)
7406         ret = extractMacRbCfg(lcId, NULL, drbSetupModItem, ulLcCfg, lcCfg, upTnlInfo);
7407    }
7408    return ret;
7409 }
7410
7411 /*******************************************************************
7412  *
7413  * @brief Function to extract Rlc cfg To Add/Mod in CellGrp Info
7414  *
7415  * @details
7416  *
7417  *    Function : extractRlcCfgToAddMod
7418  *
7419  *    Functionality: Function to extract Rlc cfg To Add/Mod in CellGrp Info
7420  *
7421  * @params[in] CellGroupConfigRrc__rlc_BearerTo pointer
7422  *             DuUeCfg Pointer
7423  * @return ROK/RFAILED
7424  *
7425  * ****************************************************************/
7426
7427 uint8_t extractRlcCfgToAddMod(struct CellGroupConfigRrc__rlc_BearerToAddModList *lcCfg, DuUeCfg *ueCfgDb)
7428 {
7429   uint8_t idx, rbId, lcId, rlcMode, rbType;
7430   RLC_Config_t *f1RlcCfg = NULLP;
7431   LogicalChannelConfig_t *macUlLcCfg = NULLP;
7432
7433   for(idx = 0; idx < lcCfg->list.count; idx++)
7434   {
7435      lcId = lcCfg->list.array[idx]->logicalChannelIdentity;
7436      if(lcCfg->list.array[idx]->servedRadioBearer)
7437      {
7438         /* RadioBearer for SRB/DRB */
7439         if(lcCfg->list.array[idx]->servedRadioBearer->present ==\
7440         RLC_BearerConfig__servedRadioBearer_PR_srb_Identity)
7441         {
7442            rbId = lcCfg->list.array[idx]->servedRadioBearer->choice.srb_Identity;
7443            rbType = RB_TYPE_SRB;
7444         }
7445         else if(lcCfg->list.array[idx]->servedRadioBearer->present ==\
7446         RLC_BearerConfig__servedRadioBearer_PR_drb_Identity)
7447         {
7448            rbId = lcCfg->list.array[idx]->servedRadioBearer->choice.drb_Identity;
7449            rbType = RB_TYPE_DRB;
7450         }
7451         else
7452         {
7453            DU_LOG("\nERROR  -->  No components present in Bearer config to ADD/MOD");
7454            return RFAILED;
7455         }
7456         /* MAC UL LC Config */
7457         if(lcCfg->list.array[idx]->mac_LogicalChannelConfig)
7458         {
7459            macUlLcCfg = lcCfg->list.array[idx]->mac_LogicalChannelConfig;
7460         }
7461      }
7462      else
7463      {
7464         DU_LOG("\nERROR  -->  DUAPP: Received RadioBearer config is NULL");
7465         return RFAILED;
7466      }
7467      /* RLC Mode Config */
7468      if(lcCfg->list.array[idx]->rlc_Config)
7469      {
7470         rlcMode  = lcCfg->list.array[idx]->rlc_Config->present;
7471         f1RlcCfg = lcCfg->list.array[idx]->rlc_Config;
7472      }
7473
7474      /* Filling RLC/MAC Config*/
7475      memset(&ueCfgDb->macLcCfg[idx], 0, sizeof(LcCfg));
7476      memset(&ueCfgDb->rlcLcCfg[idx], 0, sizeof(RlcBearerCfg));
7477      procRlcLcCfg(rbId, lcId, rbType, rlcMode, CONFIG_UNKNOWN, f1RlcCfg, &(ueCfgDb->rlcLcCfg[idx]));
7478      if(procMacLcCfg(lcId, rbType, CONFIG_UNKNOWN, NULL, NULL, macUlLcCfg, &ueCfgDb->macLcCfg[idx], NULL) != ROK)
7479      {
7480         DU_LOG("\nERROR  -->  DU APP : Failed while filling MAC LC config at extractRlcCfgToAddMod()");
7481         return RFAILED;
7482      }
7483      (ueCfgDb->numRlcLcs)++;
7484      (ueCfgDb->numMacLcs)++;
7485   }
7486   //TODO: To send the failure cause in UeContextSetupRsp
7487   return ROK;
7488 }
7489
7490 /*******************************************************************
7491  *
7492  * @brief DeAlloc pdsch serv cell config info
7493  *
7494  * @details
7495  *
7496  *    Function : freeMacPdschServCellInfo
7497  *
7498  *    Functionality: DeAlloc pdsch serv cell config info
7499  *
7500  * @params[in] PdschServCellCfg pointer
7501  * @return void
7502  *
7503  * ****************************************************************/
7504
7505 void freeMacPdschServCellInfo(PdschServCellCfg *pdsch)
7506 {
7507    if(pdsch->xOverhead)
7508    {
7509       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, pdsch->xOverhead, sizeof(uint8_t));
7510    }
7511    if(pdsch->codeBlkGrpFlushInd)
7512    {
7513       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, pdsch->codeBlkGrpFlushInd, sizeof(bool));
7514    }
7515    if(pdsch->maxCodeBlkGrpPerTb)
7516    {
7517       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, pdsch->maxCodeBlkGrpPerTb, sizeof(uint8_t));
7518    }
7519    if(pdsch->maxMimoLayers)
7520    {
7521       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, pdsch->maxMimoLayers, sizeof(uint8_t));
7522    }
7523 }
7524
7525 /*******************************************************************
7526  *
7527  * @brief Free Serving cell Info
7528  *
7529  * @details
7530  *
7531  *    Function : freeMacServingCellInfo
7532  *
7533  *    Functionality: Free Serving cell Info
7534  *
7535  * @params[in] ServCellCfgInfo *srvCellCfg
7536  * @return void
7537  *
7538  * ****************************************************************/
7539 void freeMacServingCellInfo(ServCellCfgInfo *srvCellCfg)
7540 {
7541    freeMacPdschServCellInfo(&srvCellCfg->pdschServCellCfg);
7542    if(srvCellCfg->bwpInactivityTmr)
7543    {
7544       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, srvCellCfg->bwpInactivityTmr, sizeof(uint8_t));
7545    }
7546 }
7547
7548 /*******************************************************************
7549  *
7550  * @brief Free cell Grp Cfg Info
7551  *
7552  * @details
7553  *
7554  *    Function : freeUeReCfgCellGrpInfo
7555  *
7556  *    Functionality: Free cell Grp Cfg Info
7557  *
7558  * @params[in] MacUeCfg*  duUeCfg
7559  * @return void
7560  *
7561  * ****************************************************************/
7562
7563 void freeUeReCfgCellGrpInfo(MacUeCfg *macUeCfg)
7564 {
7565    freeMacServingCellInfo(&macUeCfg->spCellCfg.servCellCfg);
7566 }
7567
7568 /*******************************************************************
7569  *
7570  * @brief Fills Reconfig SchReqReConfig
7571  *
7572  * @details
7573  *
7574  *    Function : extractSchReqReConfig
7575  *
7576  *    Functionality: Fills Reconfig SchReqReConfig
7577  *
7578  * @params[in] SchedulingRequestConfig_t *cuSchedReq
7579  *             SchedReqCfg*  macSchedReq
7580  * @return void
7581  *
7582  * ****************************************************************/
7583 void extractSchReqReConfig(SchedulingRequestConfig_t *cuSchedReq, SchedReqCfg *macSchedReq)
7584 {
7585    uint8_t schReqIdx = 0;
7586    struct SchedulingRequestConfig__schedulingRequestToAddModList *schReqListToAdd = NULLP;
7587    struct SchedulingRequestConfig__schedulingRequestToReleaseList *schReqListToRel = NULLP;
7588
7589    if(cuSchedReq->schedulingRequestToAddModList)
7590    {
7591       schReqListToAdd = cuSchedReq->schedulingRequestToAddModList;
7592       if(schReqListToAdd->list.count)
7593       {
7594          macSchedReq->addModListCount = schReqListToAdd->list.count;
7595          for(schReqIdx = 0; schReqIdx < schReqListToAdd->list.count; schReqIdx++)
7596          {
7597             macSchedReq->addModList[schReqIdx].schedReqId = \
7598                schReqListToAdd->list.array[schReqIdx]->schedulingRequestId;
7599             macSchedReq->addModList[schReqIdx].srProhibitTmr = \
7600                *(schReqListToAdd->list.array[schReqIdx]->sr_ProhibitTimer);
7601             macSchedReq->addModList[schReqIdx].srTransMax    =\
7602                schReqListToAdd->list.array[schReqIdx]->sr_TransMax;
7603          }
7604       }
7605    }
7606    /* Scheduling Req To release */
7607    if(cuSchedReq->schedulingRequestToReleaseList)
7608    {
7609       schReqListToRel = cuSchedReq->schedulingRequestToReleaseList;
7610       if(schReqListToRel->list.count)
7611       {
7612          macSchedReq->relListCount = schReqListToRel->list.count;
7613          for(schReqIdx = 0; schReqIdx < schReqListToRel->list.count; schReqIdx++)
7614          {
7615             macSchedReq->relList[schReqIdx] = \
7616                *schReqListToRel->list.array[schReqIdx];
7617          }
7618       }
7619    }
7620 }
7621
7622 /*******************************************************************
7623  *
7624  * @brief Fills TagReconfig
7625  *
7626  * @details
7627  *
7628  *    Function : extractTagReconfig
7629  *
7630  *    Functionality: Fills extractTagReconfig
7631  *
7632  * @params[in] TAG_Config_t *cuTagCfg
7633  *             TagCfg *macTagCfg
7634  * @return void
7635  *
7636  * ****************************************************************/
7637
7638 void extractTagReconfig(TAG_Config_t *cuTagCfg, TagCfg *macTagCfg)
7639 {
7640   uint8_t tagIdx = 0;
7641   struct TAG_Config__tag_ToAddModList  *tagListToAddMod = NULLP;
7642   struct TAG_Config__tag_ToReleaseList *tagListToRel = NULLP;
7643
7644   /* Tag config to AddMod */
7645   if(cuTagCfg->tag_ToAddModList)
7646   {
7647      tagListToAddMod = cuTagCfg->tag_ToAddModList;
7648      if(tagListToAddMod->list.count)
7649      {
7650         macTagCfg->addModListCount = tagListToAddMod->list.count;
7651         for(tagIdx = 0; tagIdx < tagListToAddMod->list.count; tagIdx++)
7652         {
7653            macTagCfg->addModList[tagIdx].tagId =\
7654               tagListToAddMod->list.array[tagIdx]->tag_Id;
7655            macTagCfg->addModList[tagIdx].timeAlignTimer = \
7656
7657               tagListToAddMod->list.array[tagIdx]->timeAlignmentTimer;
7658         }
7659      }
7660   }
7661   /* Tag config to release */
7662   if(cuTagCfg->tag_ToReleaseList)
7663   {
7664      tagListToRel = cuTagCfg->tag_ToReleaseList;
7665      if(tagListToRel->list.count)
7666      {
7667         macTagCfg->relListCount = tagListToRel->list.count;
7668         for(tagIdx = 0; tagIdx < tagListToRel->list.count; tagIdx++)
7669         {
7670            macTagCfg->relList[tagIdx] = *tagListToRel->list.array[tagIdx];
7671         }
7672      }
7673   }
7674 }
7675
7676 /*******************************************************************
7677  *
7678  * @brief Fills PdcchCfg received by CU
7679  *
7680  * @details
7681  *
7682  *    Function : extractPdcchCfg
7683  *
7684  *    Functionality: Fills PdcchCfg received  by CU
7685  *
7686  * @params[in] PDCCH_Config_t *cuPdcchCfg,
7687  *             PdcchConfig *duPdcchCfg
7688  * @return void
7689  *
7690  * ****************************************************************/
7691
7692 void extractPdcchCfg(PDCCH_Config_t *cuPdcchCfg, PdcchConfig *macPdcchCfg)
7693 {
7694    uint8_t cRsetIdx = 0;
7695    uint8_t srchSpcIdx = 0;
7696
7697    struct PDCCH_Config__controlResourceSetToAddModList *cRsetToAddModList = NULLP;
7698    struct PDCCH_Config__controlResourceSetToReleaseList *cRsetToRelList = NULLP;
7699    struct PDCCH_Config__searchSpacesToAddModList *srchSpcToAddModList = NULLP;
7700    struct PDCCH_Config__searchSpacesToReleaseList *srchSpcToRelList = NULLP;
7701
7702
7703    /* Control Resource Set To Add/Mod List */
7704    if(cuPdcchCfg->controlResourceSetToAddModList)
7705    {
7706       cRsetToAddModList = cuPdcchCfg->controlResourceSetToAddModList;
7707       if(cRsetToAddModList->list.count)
7708       {
7709          macPdcchCfg->numCRsetToAddMod = cRsetToAddModList->list.count;
7710          for(cRsetIdx = 0; cRsetIdx < cRsetToAddModList->list.count; cRsetIdx++)
7711          {
7712             macPdcchCfg->cRSetToAddModList[cRsetIdx].cRSetId = \
7713               cRsetToAddModList->list.array[cRsetIdx]->controlResourceSetId;
7714             bitStringToInt(&cRsetToAddModList->list.array[cRsetIdx]->frequencyDomainResources,\
7715                macPdcchCfg->cRSetToAddModList[cRsetIdx].freqDomainRsrc);
7716             macPdcchCfg->cRSetToAddModList[cRsetIdx].duration = \
7717               cRsetToAddModList->list.array[cRsetIdx]->duration;
7718
7719             macPdcchCfg->cRSetToAddModList[cRsetIdx].cceRegMappingType = \
7720               cRsetToAddModList->list.array[cRsetIdx]->cce_REG_MappingType.present;
7721             if(macPdcchCfg->cRSetToAddModList[cRsetIdx].cceRegMappingType == CCE_REG_MAPPINGTYPE_PR_INTERLEAVED)
7722             {
7723                //TODO: handle the case for Interleaved
7724             }
7725             macPdcchCfg->cRSetToAddModList[cRsetIdx].precoderGranularity = \
7726               cRsetToAddModList->list.array[cRsetIdx]->precoderGranularity;
7727             if(cRsetToAddModList->list.array[cRsetIdx]->pdcch_DMRS_ScramblingID)
7728             {
7729                macPdcchCfg->cRSetToAddModList[cRsetIdx].dmrsScramblingId= \
7730                   *(cRsetToAddModList->list.array[cRsetIdx]->pdcch_DMRS_ScramblingID);
7731             }
7732          }
7733       }
7734
7735    }
7736    /* Control Resource Set To Release List */
7737    if(cuPdcchCfg->controlResourceSetToReleaseList)
7738    {
7739       cRsetToRelList = cuPdcchCfg->controlResourceSetToReleaseList;
7740       if(cRsetToRelList->list.count)
7741       {
7742          macPdcchCfg->numCRsetToRel = cRsetToRelList->list.count;
7743          for(cRsetIdx = 0; cRsetIdx < cRsetToRelList->list.count; cRsetIdx++)
7744          {
7745             macPdcchCfg->cRSetToRelList[cRsetIdx] = *(cRsetToRelList->list.array[cRsetIdx]);
7746          }
7747       }
7748    }
7749
7750    /* Search space To Add/Mod List */
7751    if(cuPdcchCfg->searchSpacesToAddModList)
7752    {
7753       srchSpcToAddModList = cuPdcchCfg->searchSpacesToAddModList;
7754       if(srchSpcToAddModList->list.count)
7755       {
7756          macPdcchCfg->numSearchSpcToAddMod = srchSpcToAddModList->list.count;
7757          for(srchSpcIdx = 0; srchSpcIdx < srchSpcToAddModList->list.count; srchSpcIdx++)
7758          {
7759             macPdcchCfg->searchSpcToAddModList[srchSpcIdx].searchSpaceId =\
7760                srchSpcToAddModList->list.array[srchSpcIdx]->searchSpaceId;
7761             macPdcchCfg->searchSpcToAddModList[srchSpcIdx].cRSetId =\
7762                *(srchSpcToAddModList->list.array[srchSpcIdx]->controlResourceSetId);
7763             if(srchSpcToAddModList->list.array[srchSpcIdx]->monitoringSlotPeriodicityAndOffset)
7764             {
7765                macPdcchCfg->searchSpcToAddModList[srchSpcIdx].mSlotPeriodicityAndOffset =\
7766                   srchSpcToAddModList->list.array[srchSpcIdx]->monitoringSlotPeriodicityAndOffset->present;
7767             }
7768             if(srchSpcToAddModList->list.array[srchSpcIdx]->monitoringSymbolsWithinSlot)
7769             {
7770                bitStringToInt(srchSpcToAddModList->list.array[srchSpcIdx]->monitoringSymbolsWithinSlot,\
7771                   macPdcchCfg->searchSpcToAddModList[srchSpcIdx].mSymbolsWithinSlot);
7772             }
7773             if(srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates)
7774             {
7775               macPdcchCfg->searchSpcToAddModList[srchSpcIdx].numCandidatesAggLevel1 = \
7776                   srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates->aggregationLevel1;
7777               macPdcchCfg->searchSpcToAddModList[srchSpcIdx].numCandidatesAggLevel2 = \
7778                   srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates->aggregationLevel2;
7779               macPdcchCfg->searchSpcToAddModList[srchSpcIdx].numCandidatesAggLevel4 = \
7780                   srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates->aggregationLevel4;
7781
7782               macPdcchCfg->searchSpcToAddModList[srchSpcIdx].numCandidatesAggLevel8 = \
7783                   srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates->aggregationLevel8;
7784
7785               macPdcchCfg->searchSpcToAddModList[srchSpcIdx].numCandidatesAggLevel16 = \
7786                   srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates->aggregationLevel16;
7787             }
7788             if(srchSpcToAddModList->list.array[srchSpcIdx]->searchSpaceType)
7789             {
7790                macPdcchCfg->searchSpcToAddModList[srchSpcIdx].searchSpaceType =\
7791                   srchSpcToAddModList->list.array[srchSpcIdx]->searchSpaceType->present;
7792                if(macPdcchCfg->searchSpcToAddModList[srchSpcIdx].searchSpaceType == SEARCHSPACETYPE_PR_UE_SPECIFIC)
7793                {
7794                   macPdcchCfg->searchSpcToAddModList[srchSpcIdx].ueSpecificDciFormat =\
7795                      srchSpcToAddModList->list.array[srchSpcIdx]->searchSpaceType->choice.ue_Specific->dci_Formats;
7796                }
7797
7798             }
7799          }
7800       }
7801    }
7802    /* Search space To Rel List */
7803    if(cuPdcchCfg->searchSpacesToReleaseList)
7804    {
7805       srchSpcToRelList = cuPdcchCfg->searchSpacesToReleaseList;
7806       if(srchSpcToRelList->list.count)
7807       {
7808          macPdcchCfg->numSearchSpcToRel = srchSpcToRelList->list.count;
7809          for(srchSpcIdx = 0; srchSpcIdx < srchSpcToRelList->list.count; srchSpcIdx++)
7810          {
7811             macPdcchCfg->searchSpcToRelList[srchSpcIdx] =\
7812                *(srchSpcToRelList->list.array[srchSpcIdx]);
7813          }
7814       }
7815    }
7816 }
7817
7818 /*******************************************************************
7819  *
7820  * @brief Fills PdschCfg received by CU
7821  *
7822  * @details
7823  *
7824  *    Function : extractPdschCfg
7825  *
7826  *    Functionality: Fills PdschCfg received  by CU
7827  *
7828  * @params[in] PDSCH_Config_t *cuPdschCfg,
7829  *             PdschConfig *macPdschCfg
7830  * @return void
7831  *
7832  * ****************************************************************/
7833
7834 void extractPdschCfg(PDSCH_Config_t *cuPdschCfg, PdschConfig *macPdschCfg)
7835 {
7836    uint8_t timeDomIdx;
7837    struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAlloc = NULLP;
7838
7839    if(cuPdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA)
7840    {
7841       if(cuPdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA->present == \
7842          PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA_PR_setup)
7843       {
7844          if(cuPdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA->choice.setup)
7845          {
7846             macPdschCfg->dmrsDlCfgForPdschMapTypeA.addPos = \
7847                *(cuPdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA->choice.setup->dmrs_AdditionalPosition);
7848          }
7849       }
7850    }
7851    macPdschCfg->resourceAllocType = cuPdschCfg->resourceAllocation;
7852    if(cuPdschCfg->pdsch_TimeDomainAllocationList)
7853    {
7854       timeDomAlloc = cuPdschCfg->pdsch_TimeDomainAllocationList;
7855       if(timeDomAlloc->present ==\
7856          PDSCH_Config__pdsch_TimeDomainAllocationList_PR_setup)
7857       {
7858          if(timeDomAlloc->choice.setup)
7859          {
7860             macPdschCfg->numTimeDomRsrcAlloc  = timeDomAlloc->choice.setup->list.count;
7861             for(timeDomIdx = 0; timeDomIdx < timeDomAlloc->choice.setup->list.count; timeDomIdx++)
7862             {
7863                macPdschCfg->timeDomRsrcAllociList[timeDomIdx].mappingType = \
7864                   timeDomAlloc->choice.setup->list.array[timeDomIdx]->mappingType;
7865                macPdschCfg->timeDomRsrcAllociList[timeDomIdx].startSymbolAndLength = \
7866                   timeDomAlloc->choice.setup->list.array[timeDomIdx]->startSymbolAndLength;
7867             }
7868          }
7869       }
7870    }
7871    macPdschCfg->rbgSize = cuPdschCfg->rbg_Size;
7872    if(cuPdschCfg->maxNrofCodeWordsScheduledByDCI)
7873       macPdschCfg->numCodeWordsSchByDci = *(cuPdschCfg->maxNrofCodeWordsScheduledByDCI);
7874    if(cuPdschCfg->prb_BundlingType.present == PDSCH_Config__prb_BundlingType_PR_staticBundling)
7875    {
7876       macPdschCfg->bundlingType = cuPdschCfg->prb_BundlingType.present;
7877       if(cuPdschCfg->prb_BundlingType.choice.staticBundling)
7878       {
7879          if(cuPdschCfg->prb_BundlingType.choice.staticBundling->bundleSize)
7880          {
7881             macPdschCfg->bundlingInfo.StaticBundling.size = \
7882                *(cuPdschCfg->prb_BundlingType.choice.staticBundling->bundleSize);
7883          }
7884       }
7885    }
7886    else if(cuPdschCfg->prb_BundlingType.present == PDSCH_Config__prb_BundlingType_PR_dynamicBundling)
7887    {
7888       macPdschCfg->bundlingType = cuPdschCfg->prb_BundlingType.present;
7889    }
7890
7891 }
7892
7893 /*******************************************************************
7894  *
7895  * @brief Fills PdschServingCellCfg received by CU
7896  *
7897  * @details
7898  *
7899  *    Function : extractPdschServingCellCfg
7900  *
7901  *    Functionality: Fills PdschCfg received  by CU
7902  *
7903  * @params[in] PDSCH_ServingCellConfig_t *cuPdschSrvCellCfg,
7904  *             PdschServCellCfg *macUePdschSrvCellCfg
7905  * @return ROK/RFAILED
7906  *
7907  * ****************************************************************/
7908
7909 uint8_t extractPdschServingCellCfg(PDSCH_ServingCellConfig_t *cuPdschSrvCellCfg, PdschServCellCfg *macUePdschSrvCellCfg)
7910 {
7911    if(cuPdschSrvCellCfg->codeBlockGroupTransmission)
7912    {
7913       if(cuPdschSrvCellCfg->codeBlockGroupTransmission->choice.setup)
7914       {
7915          if(macUePdschSrvCellCfg->maxCodeBlkGrpPerTb)
7916          {
7917             *(macUePdschSrvCellCfg->maxCodeBlkGrpPerTb)  = \
7918                cuPdschSrvCellCfg->codeBlockGroupTransmission->choice.setup->maxCodeBlockGroupsPerTransportBlock;
7919          }
7920          else
7921          {
7922             DU_ALLOC_SHRABL_BUF(macUePdschSrvCellCfg->maxCodeBlkGrpPerTb, sizeof(uint8_t));
7923             if(macUePdschSrvCellCfg->maxCodeBlkGrpPerTb)
7924             {
7925                *(macUePdschSrvCellCfg->maxCodeBlkGrpPerTb)  = \
7926                   cuPdschSrvCellCfg->codeBlockGroupTransmission->choice.setup->maxCodeBlockGroupsPerTransportBlock;
7927             }
7928             else
7929             {
7930                DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for maxCodeBlkGrpPerTb at extractPdschServingCellCfg()");
7931                return RFAILED;
7932             }
7933          }
7934          if(macUePdschSrvCellCfg->codeBlkGrpFlushInd)
7935          {
7936             *(macUePdschSrvCellCfg->codeBlkGrpFlushInd)  = \
7937                cuPdschSrvCellCfg->codeBlockGroupTransmission->choice.setup->codeBlockGroupFlushIndicator;
7938          }
7939          else
7940          {
7941             DU_ALLOC_SHRABL_BUF(macUePdschSrvCellCfg->maxCodeBlkGrpPerTb, sizeof(bool));
7942             if(macUePdschSrvCellCfg->codeBlkGrpFlushInd)
7943             {
7944                *(macUePdschSrvCellCfg->codeBlkGrpFlushInd)  = \
7945                   cuPdschSrvCellCfg->codeBlockGroupTransmission->choice.setup->codeBlockGroupFlushIndicator;
7946             }
7947             else
7948             {
7949                DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for codeBlkGrpFlushInd at extractPdschServingCellCfg()");
7950                return RFAILED;
7951             }
7952          }
7953       }
7954    }
7955    if(cuPdschSrvCellCfg->nrofHARQ_ProcessesForPDSCH)
7956    {
7957       macUePdschSrvCellCfg->numHarqProcForPdsch = *(cuPdschSrvCellCfg->nrofHARQ_ProcessesForPDSCH);
7958    }
7959    if(cuPdschSrvCellCfg->ext1)
7960    {
7961       if(cuPdschSrvCellCfg->ext1->maxMIMO_Layers)
7962       {
7963         if(macUePdschSrvCellCfg->maxMimoLayers)
7964         {
7965            *(macUePdschSrvCellCfg->maxMimoLayers)  = *(cuPdschSrvCellCfg->ext1->maxMIMO_Layers);
7966         }
7967         else
7968         {
7969            DU_ALLOC_SHRABL_BUF(macUePdschSrvCellCfg->maxMimoLayers, sizeof(uint8_t));
7970            if(macUePdschSrvCellCfg->maxMimoLayers)
7971            {
7972               *(macUePdschSrvCellCfg->maxMimoLayers)  = *(cuPdschSrvCellCfg->ext1->maxMIMO_Layers);
7973            }
7974            else
7975            {
7976               DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for maxMimoLayers at extractPdschServingCellCfg()");
7977               return RFAILED;
7978            }
7979         }
7980       }
7981    }
7982    if(cuPdschSrvCellCfg->xOverhead)
7983    {
7984       if(macUePdschSrvCellCfg->xOverhead)
7985       {
7986          *(macUePdschSrvCellCfg->xOverhead)  = *(cuPdschSrvCellCfg->xOverhead);
7987       }
7988       else
7989       {
7990          DU_ALLOC_SHRABL_BUF(macUePdschSrvCellCfg->xOverhead, sizeof(uint8_t));
7991          if(macUePdschSrvCellCfg->xOverhead)
7992          {
7993             *(macUePdschSrvCellCfg->xOverhead)  = *(cuPdschSrvCellCfg->xOverhead);
7994          }
7995          else
7996          {
7997             DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for xOverhead at extractPdschServingCellCfg()");
7998             return RFAILED;
7999          }
8000       }
8001    }
8002    return ROK;
8003 }
8004
8005 /*******************************************************************
8006  *
8007  * @brief Fills PuschCfg received by CU
8008  *
8009  * @details
8010  *
8011  *    Function : extractPuschCfg
8012  *
8013  *    Functionality: Fills PuschCfg received  by CU
8014  *
8015  * @params[in] BWP_UplinkDedicated__pusch_Config *cuPuschCfg,
8016  *             PuschCfg *macPuschCfg
8017  * @return void
8018  *
8019  * ****************************************************************/
8020
8021 void extractPuschCfg(struct BWP_UplinkDedicated__pusch_Config *cuPuschCfg, PuschCfg *macPuschCfg)
8022 {
8023    uint8_t timeDomIdx = 0;
8024    DMRS_UplinkConfig_t *dmrsUlCfg = NULLP;
8025    struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList = NULLP;
8026
8027    if(cuPuschCfg->present == BWP_UplinkDedicated__pusch_Config_PR_setup)
8028    {
8029       if(cuPuschCfg->choice.setup)
8030       {
8031          if(cuPuschCfg->choice.setup->dataScramblingIdentityPUSCH)
8032          {
8033              macPuschCfg->dataScramblingId = \
8034                 *(cuPuschCfg->choice.setup->dataScramblingIdentityPUSCH);
8035          }
8036          if(cuPuschCfg->choice.setup->dmrs_UplinkForPUSCH_MappingTypeA)
8037          {
8038             if(cuPuschCfg->choice.setup->dmrs_UplinkForPUSCH_MappingTypeA->present == PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA_PR_setup)
8039             {
8040                if(cuPuschCfg->choice.setup->dmrs_UplinkForPUSCH_MappingTypeA->choice.setup)
8041                {
8042                   dmrsUlCfg = (cuPuschCfg->choice.setup->dmrs_UplinkForPUSCH_MappingTypeA->choice.setup);
8043                   if(dmrsUlCfg->dmrs_AdditionalPosition)
8044                   {
8045                      macPuschCfg->dmrsUlCfgForPuschMapTypeA.addPos =\
8046                         *(dmrsUlCfg->dmrs_AdditionalPosition);
8047                   }
8048                   if(dmrsUlCfg->transformPrecodingDisabled)
8049                   {
8050                      if(dmrsUlCfg->transformPrecodingDisabled->scramblingID0)
8051                      {
8052                         macPuschCfg->dmrsUlCfgForPuschMapTypeA.transPrecodDisabled.scramblingId0 = \
8053                            *(dmrsUlCfg->transformPrecodingDisabled->scramblingID0);
8054                      }
8055                   }
8056                }
8057             }
8058          }
8059          /*Res Alloc Type for UL */
8060          if(cuPuschCfg->choice.setup->resourceAllocation)
8061          {
8062             macPuschCfg->resourceAllocType = \
8063                cuPuschCfg->choice.setup->resourceAllocation;
8064          }
8065          if(cuPuschCfg->choice.setup->pusch_TimeDomainAllocationList)
8066          {
8067             timeDomAllocList = cuPuschCfg->choice.setup->pusch_TimeDomainAllocationList;
8068             if(timeDomAllocList->present == PUSCH_Config__pusch_TimeDomainAllocationList_PR_setup)
8069             {
8070                if(timeDomAllocList->choice.setup)
8071                {
8072                   macPuschCfg->numTimeDomRsrcAlloc = timeDomAllocList->choice.setup->list.count;
8073                   for(timeDomIdx = 0; timeDomIdx <timeDomAllocList->choice.setup->list.count; timeDomIdx++)
8074                   {
8075                      macPuschCfg->timeDomRsrcAllocList[timeDomIdx].k2 = \
8076                         *(timeDomAllocList->choice.setup->list.array[timeDomIdx]->k2);
8077                      macPuschCfg->timeDomRsrcAllocList[timeDomIdx].mappingType = \
8078                         timeDomAllocList->choice.setup->list.array[timeDomIdx]->mappingType;
8079                      macPuschCfg->timeDomRsrcAllocList[timeDomIdx].startSymbolAndLength = \
8080                         timeDomAllocList->choice.setup->list.array[timeDomIdx]->startSymbolAndLength;
8081                   }
8082                }
8083             }
8084          }
8085          if(cuPuschCfg->choice.setup->transformPrecoder)
8086             macPuschCfg->transformPrecoder = *(cuPuschCfg->choice.setup->transformPrecoder);
8087       }
8088    }
8089 }
8090
8091 /*******************************************************************
8092  *
8093  * @brief Function to fill pucch Power Control
8094  *
8095  * @details
8096  *
8097  *    Function : extractPucchPowerControl
8098  *
8099  *    Functionality: Function to fill pucch Power Control
8100  *
8101  * @params[in] PucchPowerControl *pwrCtrl,
8102  *             struct PUCCH_PowerControl *cuPwrCtrlCfg
8103  * @return void
8104  *
8105  * ****************************************************************/
8106
8107 void extractPucchPowerControl(PucchPowerControl *pwrCtrl, struct PUCCH_PowerControl *cuPwrCtrlCfg)
8108 {
8109    uint8_t arrIdx;
8110
8111    if(cuPwrCtrlCfg->deltaF_PUCCH_f0)
8112       pwrCtrl->deltaF_Format0 = *cuPwrCtrlCfg->deltaF_PUCCH_f0;
8113    if(cuPwrCtrlCfg->deltaF_PUCCH_f1)
8114       pwrCtrl->deltaF_Format1 = *cuPwrCtrlCfg->deltaF_PUCCH_f1;
8115    if(cuPwrCtrlCfg->deltaF_PUCCH_f2)
8116       pwrCtrl->deltaF_Format2 = *cuPwrCtrlCfg->deltaF_PUCCH_f2;
8117    if(cuPwrCtrlCfg->deltaF_PUCCH_f3)
8118       pwrCtrl->deltaF_Format3 = *cuPwrCtrlCfg->deltaF_PUCCH_f3;
8119    if(cuPwrCtrlCfg->deltaF_PUCCH_f4)
8120       pwrCtrl->deltaF_Format4 = *cuPwrCtrlCfg->deltaF_PUCCH_f4;
8121    if(cuPwrCtrlCfg->p0_Set)
8122    {
8123       pwrCtrl->p0SetCount = cuPwrCtrlCfg->p0_Set->list.count;
8124       for(arrIdx=0; arrIdx < pwrCtrl->p0SetCount; arrIdx++)
8125       {
8126          pwrCtrl->p0Set[arrIdx].p0PucchId =\
8127             cuPwrCtrlCfg->p0_Set->list.array[arrIdx]->p0_PUCCH_Id;
8128          pwrCtrl->p0Set[arrIdx].p0PucchVal =\
8129             cuPwrCtrlCfg->p0_Set->list.array[arrIdx]->p0_PUCCH_Value;
8130       }
8131    }
8132    if(cuPwrCtrlCfg->pathlossReferenceRSs)
8133    {
8134       pwrCtrl->pathLossRefRSListCount = cuPwrCtrlCfg->pathlossReferenceRSs->list.count;
8135       for(arrIdx = 0; arrIdx < pwrCtrl->pathLossRefRSListCount; arrIdx++)
8136       {
8137          pwrCtrl->pathLossRefRSList[arrIdx].pathLossRefRSId =\
8138             cuPwrCtrlCfg->pathlossReferenceRSs->list.array[arrIdx]->pucch_PathlossReferenceRS_Id;
8139       }
8140    }
8141 }
8142
8143  /*******************************************************************
8144  *
8145  * @brief Function to extractResrcSetToAddModList sent by CU
8146  *
8147  * @details
8148  *
8149  *    Function : extractResrcSetToAddModList
8150  *
8151  *    Functionality: Fucntion to extractResrcSetToAddModList
8152  *
8153  * @params[in] PucchResrcSetCfg pointer,
8154  *             struct PUCCH_Config__resourceSetToAddModList pointer
8155  * @return void
8156  *
8157  * ****************************************************************/
8158
8159 void extractResrcSetToAddModList(PucchResrcSetCfg *macRsrcSetList, struct PUCCH_Config__resourceSetToAddModList *cuRsrcSetList)
8160 {
8161    uint8_t arrIdx, rsrcListIdx;
8162
8163    macRsrcSetList->resrcSetToAddModListCount = cuRsrcSetList->list.count;
8164    for(arrIdx = 0; arrIdx < macRsrcSetList->resrcSetToAddModListCount; arrIdx++)
8165    {
8166       macRsrcSetList->resrcSetToAddModList[arrIdx].resrcSetId     =\
8167          cuRsrcSetList->list.array[arrIdx]->pucch_ResourceSetId;
8168       macRsrcSetList->resrcSetToAddModList[arrIdx].resrcListCount =\
8169          cuRsrcSetList->list.array[arrIdx]->resourceList.list.count;
8170       for(rsrcListIdx = 0; rsrcListIdx < macRsrcSetList->resrcSetToAddModList[arrIdx].resrcListCount; rsrcListIdx++)
8171       {
8172          macRsrcSetList->resrcSetToAddModList[arrIdx].resrcList[rsrcListIdx] =\
8173             *cuRsrcSetList->list.array[arrIdx]->resourceList.list.array[rsrcListIdx];
8174       }
8175       macRsrcSetList->resrcSetToAddModList[arrIdx].maxPayLoadSize =\
8176          *cuRsrcSetList->list.array[arrIdx]->maxPayloadMinus1;
8177    }
8178 }/* End of extractResrcSetToAddModList */
8179
8180 /*******************************************************************
8181  *
8182  * @brief Fills extractResrcToAddModList sent by CU
8183  *
8184  * @details
8185  *
8186  *    Function : extractResrcToAddModList
8187  *
8188  *    Functionality: Fills extractResrcToAddModList
8189  *
8190  * @params[in] PucchResrcCfg pointer,
8191  *             struct PUCCH_Config__resourceToAddModList pointer
8192  * @return ROk/RFAILED
8193  *
8194  * ****************************************************************/
8195
8196 uint8_t extractResrcToAddModList(PucchResrcCfg *macResrcList, struct PUCCH_Config__resourceToAddModList *cuResrcList)
8197 {
8198    uint8_t arrIdx;
8199
8200    macResrcList->resrcToAddModListCount = cuResrcList->list.count;
8201    for(arrIdx = 0; arrIdx < macResrcList->resrcToAddModListCount; arrIdx++)
8202    {
8203       macResrcList->resrcToAddModList[arrIdx].resrcId      =\
8204         cuResrcList->list.array[arrIdx]->pucch_ResourceId;
8205       macResrcList->resrcToAddModList[arrIdx].startPrb     =\
8206         cuResrcList->list.array[arrIdx]->startingPRB;
8207       if(cuResrcList->list.array[arrIdx]->intraSlotFrequencyHopping)
8208       {
8209          macResrcList->resrcToAddModList[arrIdx].intraFreqHop =\
8210            *cuResrcList->list.array[arrIdx]->intraSlotFrequencyHopping;
8211       }
8212       if(cuResrcList->list.array[arrIdx]->secondHopPRB)
8213       {
8214          macResrcList->resrcToAddModList[arrIdx].secondPrbHop =\
8215            *cuResrcList->list.array[arrIdx]->secondHopPRB;
8216       }
8217       /* PUCCH RSRC FORMAT */
8218       if(cuResrcList->list.array[arrIdx]->format.present == PUCCH_Resource__format_PR_format0)
8219       {
8220          macResrcList->resrcToAddModList[arrIdx].pucchFormat = PUCCH_FORMAT_0;
8221          if(cuResrcList->list.array[arrIdx]->format.choice.format0)
8222          {
8223             DU_ALLOC_SHRABL_BUF(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format0, sizeof(PucchFormat0));
8224             if(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format0 == NULLP)
8225             {
8226                DU_LOG("\nERROR  --> F1AP : Failed to allocate memory for Format0 in extractResrcToAddModList()");
8227                return RFAILED;
8228             }
8229             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format0->initialCyclicShift =\
8230                cuResrcList->list.array[arrIdx]->format.choice.format0->initialCyclicShift;
8231             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format0->numSymbols =\
8232                cuResrcList->list.array[arrIdx]->format.choice.format0->nrofSymbols;
8233             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format0->startSymbolIdx =\
8234                cuResrcList->list.array[arrIdx]->format.choice.format0->startingSymbolIndex;
8235          }
8236       }
8237       else if(cuResrcList->list.array[arrIdx]->format.present == PUCCH_Resource__format_PR_format1)
8238       {
8239          macResrcList->resrcToAddModList[arrIdx].pucchFormat = PUCCH_FORMAT_1;
8240          if(cuResrcList->list.array[arrIdx]->format.choice.format1)
8241          {
8242             DU_ALLOC_SHRABL_BUF(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1, sizeof(PucchFormat1));
8243             if(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1 == NULLP)
8244             {
8245                DU_LOG("\nERROR  --> F1AP : Failed to allocate memory for Format1 in extractResrcToAddModList()");
8246                return RFAILED;
8247             }
8248             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1->initialCyclicShift =\
8249                 cuResrcList->list.array[arrIdx]->format.choice.format1->initialCyclicShift;
8250             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1->numSymbols =\
8251                 cuResrcList->list.array[arrIdx]->format.choice.format1->nrofSymbols;
8252             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1->startSymbolIdx =\
8253                 cuResrcList->list.array[arrIdx]->format.choice.format1->startingSymbolIndex;
8254             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1->timeDomOCC =\
8255                 cuResrcList->list.array[arrIdx]->format.choice.format1->timeDomainOCC;
8256          }
8257       }
8258       else if(cuResrcList->list.array[arrIdx]->format.present == PUCCH_Resource__format_PR_format2)
8259       {
8260          macResrcList->resrcToAddModList[arrIdx].pucchFormat = PUCCH_FORMAT_2;
8261          if(cuResrcList->list.array[arrIdx]->format.choice.format2)
8262          {
8263             DU_ALLOC_SHRABL_BUF(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format2, sizeof(PucchFormat2_3));
8264             if(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format2 == NULLP)
8265             {
8266                DU_LOG("\nERROR  --> F1AP : Failed to allocate memory for Format2 in extractResrcToAddModList()");
8267                return RFAILED;
8268             }
8269             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format2->numPrbs =\
8270                 cuResrcList->list.array[arrIdx]->format.choice.format2->nrofPRBs;
8271             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format2->numSymbols =\
8272                 cuResrcList->list.array[arrIdx]->format.choice.format2->nrofSymbols;
8273             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format2->startSymbolIdx =\
8274                 cuResrcList->list.array[arrIdx]->format.choice.format2->startingSymbolIndex;
8275          }
8276       }
8277       else if(cuResrcList->list.array[arrIdx]->format.present == PUCCH_Resource__format_PR_format3)
8278       {
8279          macResrcList->resrcToAddModList[arrIdx].pucchFormat = PUCCH_FORMAT_3;
8280          if(cuResrcList->list.array[arrIdx]->format.choice.format3)
8281          {
8282             DU_ALLOC_SHRABL_BUF(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format3, sizeof(PucchFormat2_3));
8283             if(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format3 == NULLP)
8284             {
8285                DU_LOG("\nERROR  --> F1AP : Failed to allocate memory for Format3 in extractResrcToAddModList()");
8286                return RFAILED;
8287             }
8288             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format3->numPrbs =\
8289                 cuResrcList->list.array[arrIdx]->format.choice.format3->nrofPRBs;
8290             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format3->numSymbols =\
8291                 cuResrcList->list.array[arrIdx]->format.choice.format3->nrofSymbols;
8292             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format3->startSymbolIdx =\
8293                 cuResrcList->list.array[arrIdx]->format.choice.format3->startingSymbolIndex;
8294          }
8295       }
8296       else if(cuResrcList->list.array[arrIdx]->format.present == PUCCH_Resource__format_PR_format4)
8297       {
8298          macResrcList->resrcToAddModList[arrIdx].pucchFormat = PUCCH_FORMAT_4;
8299          if(cuResrcList->list.array[arrIdx]->format.choice.format4)
8300          {
8301             DU_ALLOC_SHRABL_BUF(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4, sizeof(PucchFormat4));
8302             if(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4 == NULLP)
8303             {
8304                DU_LOG("\nERROR  --> F1AP : Failed to allocate memory for Format4 in extractResrcToAddModList()");
8305                return RFAILED;
8306             }
8307             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4->numSymbols =\
8308                 cuResrcList->list.array[arrIdx]->format.choice.format4->nrofSymbols;
8309             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4->occLen =\
8310                 cuResrcList->list.array[arrIdx]->format.choice.format4->occ_Length;
8311             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4->occIdx =\
8312                 cuResrcList->list.array[arrIdx]->format.choice.format4->occ_Index;
8313             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4->startSymbolIdx =\
8314                 cuResrcList->list.array[arrIdx]->format.choice.format4->startingSymbolIndex;
8315          }
8316       }
8317    }
8318    return ROK;
8319
8320 }/* End of extractResrcToAddModList */
8321
8322 /*******************************************************************
8323  *
8324  * @brief Fills fillPucchSchedReqPeriodAndOffset sent by CU
8325  *
8326  * @details
8327  *
8328  *    Function : fillPucchSchedReqPeriodAndOffset
8329  *
8330  *    Functionality: To fillPucchSchedReqPeriodAndOffset
8331  *
8332  * @params[in] macPeriodicty,
8333  *     SchedulingRequestResourceConfig__periodicityAndOffset pointer
8334  * @return void
8335  *
8336  * ****************************************************************/
8337
8338 void fillPucchSchedReqPeriodAndOffset(uint8_t macPeriodicty, uint16_t  macOffset,\
8339    struct SchedulingRequestResourceConfig__periodicityAndOffset *cuPeriodicty)
8340 {
8341    macPeriodicty = cuPeriodicty->present;
8342    switch(macPeriodicty)
8343    {
8344       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sym2:
8345          {
8346             macOffset     = cuPeriodicty->choice.sym2;
8347             break;
8348          }
8349       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sym6or7:
8350          {
8351             macOffset     = cuPeriodicty->choice.sym6or7;
8352             break;
8353          }
8354       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl1:
8355          {
8356             macOffset     = cuPeriodicty->choice.sl1;
8357             break;
8358          }
8359       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl2:
8360          {
8361             macOffset = cuPeriodicty->choice.sl2;
8362             break;
8363          }
8364       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl4:
8365          {
8366             macOffset = cuPeriodicty->choice.sl4;
8367             break;
8368          }
8369       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl5:
8370          {
8371             macOffset = cuPeriodicty->choice.sl5;
8372             break;
8373          }
8374       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl8:
8375          {
8376             macOffset = cuPeriodicty->choice.sl8;
8377             break;
8378          }
8379       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl10:
8380          {
8381             macOffset = cuPeriodicty->choice.sl10;
8382             break;
8383          }
8384       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl16:
8385          {
8386             macOffset = cuPeriodicty->choice.sl16;
8387             break;
8388          }
8389       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl20:
8390          {
8391             macOffset = cuPeriodicty->choice.sl20;
8392             break;
8393          }
8394       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl40:
8395          {
8396             macOffset = cuPeriodicty->choice.sl40;
8397             break;
8398          }
8399       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl80:
8400          {
8401             macOffset = cuPeriodicty->choice.sl80;
8402             break;
8403          }
8404       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl160:
8405          {
8406             macOffset = cuPeriodicty->choice.sl160;
8407             break;
8408          }
8409       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl320:
8410          {
8411             macOffset = cuPeriodicty->choice.sl320;
8412             break;
8413          }
8414       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl640:
8415          {
8416             macOffset = cuPeriodicty->choice.sl640;
8417             break;
8418          }
8419       default :
8420          DU_LOG("\nERROR  -->  F1AP : Invalid periodicity %d", macPeriodicty);
8421    }
8422 }
8423
8424 /*******************************************************************
8425  *
8426  * @brief Function to extractPucchFormatCfg sent by CU
8427  *
8428  * @details
8429  *
8430  *    Function : extractPucchFormatCfg
8431  *
8432  *    Functionality: Function to extractPucchFormatCfg
8433  *
8434  * @params[in] PucchFormatCfg pointer,
8435  *             PUCCH_FormatConfig_t pointer
8436  * @return void
8437  *
8438  * ****************************************************************/
8439
8440 void extractPucchFormatCfg(PucchFormatCfg *macFormatCfg, PUCCH_FormatConfig_t *cuFormatCfg)
8441  {
8442     if(cuFormatCfg->interslotFrequencyHopping)
8443        macFormatCfg->interSlotFreqHop = *cuFormatCfg->interslotFrequencyHopping;
8444     if(cuFormatCfg->additionalDMRS)
8445        macFormatCfg->addDmrs = *cuFormatCfg->additionalDMRS;
8446     if(cuFormatCfg->maxCodeRate)
8447        macFormatCfg->maxCodeRate = *cuFormatCfg->maxCodeRate;
8448     if(cuFormatCfg->nrofSlots)
8449        macFormatCfg->numSlots = *cuFormatCfg->nrofSlots;
8450     if(cuFormatCfg->pi2BPSK)
8451        macFormatCfg->pi2BPSK = *cuFormatCfg->pi2BPSK;
8452     if(cuFormatCfg->simultaneousHARQ_ACK_CSI)
8453        macFormatCfg->harqAckCSI = *cuFormatCfg->simultaneousHARQ_ACK_CSI;
8454  }/* End of extractPucchFormatCfg */
8455
8456 /*******************************************************************
8457  *
8458  * @brief Function to extractSchedReqCfgToAddMod sent by CU
8459  *
8460  * @details
8461  *
8462  *    Function : extractSchedReqCfgToAddMod
8463  *
8464  *    Functionality: Function to extractSchedReqCfgToAddMod
8465  *
8466  * @params[in] PucchSchedReqCfg pointer,
8467  *      PUCCH_Config__schedulingRequestResourceToAddModList pointer
8468  * @return void
8469  *
8470  * ****************************************************************/
8471
8472 void extractSchedReqCfgToAddMod(PucchSchedReqCfg *macSchedReqCfg, struct PUCCH_Config__schedulingRequestResourceToAddModList *cuSchedReqList)
8473 {
8474    uint8_t arrIdx;
8475
8476    macSchedReqCfg->schedAddModListCount = cuSchedReqList->list.count;
8477    for(arrIdx = 0; arrIdx <  macSchedReqCfg->schedAddModListCount; arrIdx++)
8478    {
8479       macSchedReqCfg->schedAddModList[arrIdx].resrcId =\
8480          cuSchedReqList->list.array[arrIdx]->schedulingRequestResourceId;
8481       macSchedReqCfg->schedAddModList[arrIdx].requestId =\
8482          cuSchedReqList->list.array[arrIdx]->schedulingRequestID;
8483       if(cuSchedReqList->list.array[arrIdx]->periodicityAndOffset)
8484       {
8485          fillPucchSchedReqPeriodAndOffset(macSchedReqCfg->schedAddModList[arrIdx].periodicity,\
8486             macSchedReqCfg->schedAddModList[arrIdx].offset, cuSchedReqList->list.array[arrIdx]->periodicityAndOffset);
8487       }
8488       if(cuSchedReqList->list.array[arrIdx]->resource)
8489       {
8490          macSchedReqCfg->schedAddModList[arrIdx].resrc =\
8491             *cuSchedReqList->list.array[arrIdx]->resource;
8492       }
8493    }
8494
8495 }/* End of extractSchedReqCfgToAddMod */
8496
8497  /*******************************************************************
8498  *
8499  * @brief Fills PucchCfg received by CU
8500  *
8501  * @details
8502  *
8503  *    Function : extractPucchCfg
8504  *
8505  *    Functionality: Fills PucchCfg received  by CU
8506  *
8507  * @params[in] BWP_UplinkDedicated__pucch_Config *cuPucchCfg,
8508  *             PucchCfg *macPucchCfg
8509  * @return ROK/RFAILED
8510  *
8511  * ****************************************************************/
8512
8513 uint8_t extractPucchCfg(struct BWP_UplinkDedicated__pucch_Config *cuPucchCfg, PucchCfg *macPucchCfg)
8514 {
8515    uint8_t arrIdx;
8516
8517    if(cuPucchCfg->present == BWP_UplinkDedicated__pucch_Config_PR_setup)
8518    {
8519       if(cuPucchCfg->choice.setup)
8520       {
8521          /* Resource Set Cfg */
8522          if(cuPucchCfg->choice.setup->resourceSetToAddModList)
8523          {
8524             DU_ALLOC_SHRABL_BUF(macPucchCfg->resrcSet, sizeof(PucchResrcSetCfg));
8525             if(macPucchCfg->resrcSet == NULLP)
8526             {
8527                DU_LOG("\nERROR --> F1AP : Failed to extract Resrc set List in extractPucchCfg()");
8528                return RFAILED;
8529             }
8530             memset(macPucchCfg->resrcSet, 0, sizeof(PucchResrcSetCfg));
8531             extractResrcSetToAddModList(macPucchCfg->resrcSet, cuPucchCfg->choice.setup->resourceSetToAddModList);
8532          }
8533
8534          /* Resource Cfg */
8535          if(cuPucchCfg->choice.setup->resourceToAddModList)
8536          {
8537             DU_ALLOC_SHRABL_BUF(macPucchCfg->resrc, sizeof(PucchResrcCfg));
8538             if(macPucchCfg->resrc == NULLP)
8539             {
8540                DU_LOG("\nERROR --> F1AP : Failed to extract Resrc List in extractPucchCfg()");
8541                return RFAILED;
8542             }
8543             memset(macPucchCfg->resrc, 0, sizeof(PucchResrcCfg));
8544             extractResrcToAddModList(macPucchCfg->resrc, cuPucchCfg->choice.setup->resourceToAddModList);
8545          }
8546
8547          /* Format 1 Cfg */
8548          if(cuPucchCfg->choice.setup->format1)
8549          {
8550             DU_ALLOC_SHRABL_BUF(macPucchCfg->format1, sizeof(PucchFormatCfg));
8551             if(macPucchCfg->format1 == NULLP)
8552             {
8553                DU_LOG("\nERROR --> F1AP : Failed to extract format 1 Cfg in  extractPucchCfg()");
8554                return RFAILED;
8555             }
8556             memset(macPucchCfg->format1, 0, sizeof(PucchFormatCfg));
8557             extractPucchFormatCfg(macPucchCfg->format1,\
8558                cuPucchCfg->choice.setup->format1->choice.setup);
8559          }
8560
8561          /* Format 2 Cfg */
8562          if(cuPucchCfg->choice.setup->format2)
8563          {
8564             DU_ALLOC_SHRABL_BUF(macPucchCfg->format2, sizeof(PucchFormatCfg));
8565             if(macPucchCfg->format2 == NULLP)
8566             {
8567                DU_LOG("\nERROR --> F1AP : Failed to extract format 2 Cfg in  extractPucchCfg()");
8568                return RFAILED;
8569             }
8570             memset(macPucchCfg->format2, 0, sizeof(PucchFormatCfg));
8571             extractPucchFormatCfg(macPucchCfg->format2,\
8572                cuPucchCfg->choice.setup->format2->choice.setup);
8573          }
8574
8575          /* Format 3 Cfg */
8576          if(cuPucchCfg->choice.setup->format3)
8577          {
8578             DU_ALLOC_SHRABL_BUF(macPucchCfg->format3, sizeof(PucchFormatCfg));
8579             if(macPucchCfg->format3 == NULLP)
8580             {
8581                DU_LOG("\nERROR --> F1AP : Failed to extract format 3 Cfg in  extractPucchCfg()");
8582                return RFAILED;
8583             }
8584             memset(macPucchCfg->format3, 0, sizeof(PucchFormatCfg));
8585             extractPucchFormatCfg(macPucchCfg->format3,\
8586                cuPucchCfg->choice.setup->format3->choice.setup);
8587          }
8588
8589          /* Format 4 Cfg */
8590          if(cuPucchCfg->choice.setup->format4)
8591          {
8592             DU_ALLOC_SHRABL_BUF(macPucchCfg->format4, sizeof(PucchFormatCfg));
8593             if(macPucchCfg->format4 == NULLP)
8594             {
8595                DU_LOG("\nERROR --> F1AP : Failed to extract format 4 Cfg in  extractPucchCfg()");
8596                return RFAILED;
8597             }
8598             memset(macPucchCfg->format4, 0, sizeof(PucchFormatCfg));
8599             extractPucchFormatCfg(macPucchCfg->format4,\
8600                cuPucchCfg->choice.setup->format4->choice.setup);
8601          }
8602
8603          /* Sched Req List */
8604          if(cuPucchCfg->choice.setup->schedulingRequestResourceToAddModList)
8605          {
8606             DU_ALLOC_SHRABL_BUF(macPucchCfg->schedReq, sizeof(PucchSchedReqCfg));
8607             if(macPucchCfg->schedReq == NULLP)
8608             {
8609                DU_LOG("\nERROR --> F1AP : Failed to extract schedReqCfg in  extractPucchCfg()");
8610                return RFAILED;
8611             }
8612             memset(macPucchCfg->schedReq, 0, sizeof(PucchSchedReqCfg));
8613             extractSchedReqCfgToAddMod(macPucchCfg->schedReq,\
8614             cuPucchCfg->choice.setup->schedulingRequestResourceToAddModList);
8615          }
8616
8617          /*TODO: Add support for  Spatial Info */
8618
8619          /* MultiCsiCfg */
8620          if(cuPucchCfg->choice.setup->multi_CSI_PUCCH_ResourceList)
8621          {
8622             DU_ALLOC_SHRABL_BUF(macPucchCfg->multiCsiCfg, sizeof(PucchMultiCsiCfg));
8623             if(macPucchCfg->multiCsiCfg == NULLP)
8624             {
8625                DU_LOG("\nERROR --> F1AP : Failed to extract multiCsiCfg in  extractPucchCfg()");
8626                return RFAILED;
8627             }
8628             memset(macPucchCfg->multiCsiCfg, 0, sizeof(PucchMultiCsiCfg));
8629             macPucchCfg->multiCsiCfg->multiCsiResrcListCount = cuPucchCfg->choice.setup->multi_CSI_PUCCH_ResourceList->list.count;
8630             for(arrIdx =0; arrIdx < macPucchCfg->multiCsiCfg->multiCsiResrcListCount; arrIdx++)
8631             {
8632                macPucchCfg->multiCsiCfg->multiCsiResrcList[arrIdx] =\
8633                  *cuPucchCfg->choice.setup->multi_CSI_PUCCH_ResourceList->list.array[arrIdx];
8634             }
8635          }
8636
8637          /* Dl_DataToUL_ACK */
8638          if(cuPucchCfg->choice.setup->dl_DataToUL_ACK)
8639          {
8640             DU_ALLOC_SHRABL_BUF(macPucchCfg->dlDataToUlAck, sizeof(PucchDlDataToUlAck));
8641             if(macPucchCfg->dlDataToUlAck == NULLP)
8642             {
8643                DU_LOG("\nERROR --> F1AP : Failed to extract Dl_DataToUL_ACK in extractPucchCfg()");
8644                return RFAILED;
8645             }
8646             memset(macPucchCfg->dlDataToUlAck, 0, sizeof(PucchDlDataToUlAck));
8647             macPucchCfg->dlDataToUlAck->dlDataToUlAckListCount = cuPucchCfg->choice.setup->dl_DataToUL_ACK->list.count;
8648             for(arrIdx = 0; arrIdx < macPucchCfg->dlDataToUlAck->dlDataToUlAckListCount; arrIdx++)
8649             {
8650                macPucchCfg->dlDataToUlAck->dlDataToUlAckList[arrIdx] =\
8651                   *cuPucchCfg->choice.setup->dl_DataToUL_ACK->list.array[arrIdx];
8652             }
8653          }
8654
8655          /* Power Control */
8656          if(cuPucchCfg->choice.setup->pucch_PowerControl)
8657          {
8658             DU_ALLOC_SHRABL_BUF(macPucchCfg->powerControl, sizeof(PucchPowerControl));
8659             if(macPucchCfg->powerControl == NULLP)
8660             {
8661                DU_LOG("\nERROR --> F1AP : Failed to extract power control in extractPucchCfg()");
8662                return RFAILED;
8663             }
8664             extractPucchPowerControl(macPucchCfg->powerControl,\
8665                cuPucchCfg->choice.setup->pucch_PowerControl);
8666          }
8667       }
8668    }
8669    return ROK;
8670 }
8671
8672 /*******************************************************************
8673  *
8674  * @brief Fills ServingCellReconfig received by CU
8675  *
8676  * @details
8677  *
8678  *    Function : extractSpCellDedicatedCfg
8679  *
8680  *    Functionality: Fills ServingCellReconfig received  by CU
8681  *
8682  * @params[in] ServingCellConfig_t *cuSrvCellCfg
8683  *             ServCellCfgInfo *macSrvCellCfg
8684  * @return ROK/RFAILD
8685  *
8686  * ****************************************************************/
8687 uint8_t extractSpCellDedicatedCfg(ServingCellConfig_t *cuSrvCellCfg, ServCellCfgInfo *macSrvCellCfg)
8688 {
8689    uint8_t ret = ROK;
8690    BWP_DownlinkDedicated_t *dlBwp = NULLP;
8691    BWP_UplinkDedicated_t   *ulBwp = NULLP;
8692
8693    if(cuSrvCellCfg->initialDownlinkBWP)
8694    {
8695       dlBwp = ((BWP_DownlinkDedicated_t *)(cuSrvCellCfg->initialDownlinkBWP));
8696       if(dlBwp->pdcch_Config)
8697       {
8698          if(dlBwp->pdcch_Config->choice.setup)
8699          {
8700             macSrvCellCfg->initDlBwp.pdcchPresent = true;
8701             extractPdcchCfg(dlBwp->pdcch_Config->choice.setup, &macSrvCellCfg->initDlBwp.pdcchCfg);
8702          }
8703       }
8704       if(dlBwp->pdsch_Config)
8705       {
8706          if(dlBwp->pdsch_Config->choice.setup)
8707          {
8708             macSrvCellCfg->initDlBwp.pdschPresent = true;
8709             extractPdschCfg(dlBwp->pdsch_Config->choice.setup, &macSrvCellCfg->initDlBwp.pdschCfg);
8710          }
8711       }
8712    }
8713    if(cuSrvCellCfg->firstActiveDownlinkBWP_Id)
8714       macSrvCellCfg->firstActvDlBwpId = *(cuSrvCellCfg->firstActiveDownlinkBWP_Id);
8715    if(cuSrvCellCfg->defaultDownlinkBWP_Id)
8716       macSrvCellCfg->defaultDlBwpId = *(cuSrvCellCfg->defaultDownlinkBWP_Id);
8717    if(cuSrvCellCfg->bwp_InactivityTimer)
8718    {
8719       if(macSrvCellCfg->bwpInactivityTmr)
8720       {
8721          memcpy(macSrvCellCfg->bwpInactivityTmr, cuSrvCellCfg->bwp_InactivityTimer, sizeof(uint8_t));
8722       }
8723       else
8724       {
8725          macSrvCellCfg->bwpInactivityTmr = NULLP;
8726          DU_ALLOC_SHRABL_BUF(macSrvCellCfg->bwpInactivityTmr, sizeof(uint8_t));
8727          if(macSrvCellCfg->bwpInactivityTmr)
8728          {
8729             memcpy(macSrvCellCfg->bwpInactivityTmr, cuSrvCellCfg->bwp_InactivityTimer, sizeof(uint8_t));
8730          }
8731          else
8732          {
8733             DU_LOG("\nERROR  --> F1AP : Memory Alloc failed for bwpInactivityTmr at extractSpCellDedicatedCfg()");
8734             return RFAILED;
8735          }
8736       }
8737    }
8738    if(cuSrvCellCfg->pdsch_ServingCellConfig)
8739    {
8740       if(cuSrvCellCfg->pdsch_ServingCellConfig->choice.setup)
8741       {
8742          ret = extractPdschServingCellCfg(cuSrvCellCfg->pdsch_ServingCellConfig->choice.setup, &macSrvCellCfg->pdschServCellCfg);
8743          if(ret == RFAILED)
8744          {
8745             DU_LOG("\nERROR --> F1AP : Failed at extractPdschServingCellCfg()");
8746             return RFAILED;
8747          }
8748       }
8749    }
8750    if(cuSrvCellCfg->uplinkConfig)
8751    {
8752      if(cuSrvCellCfg->uplinkConfig->initialUplinkBWP)
8753      {
8754         ulBwp = ((BWP_UplinkDedicated_t *)(cuSrvCellCfg->uplinkConfig->initialUplinkBWP));
8755         if(ulBwp->pusch_Config)
8756         {
8757            macSrvCellCfg->initUlBwp.puschPresent = true;
8758            extractPuschCfg(ulBwp->pusch_Config, &macSrvCellCfg->initUlBwp.puschCfg);
8759         }
8760         if(ulBwp->pucch_Config)
8761         {
8762            macSrvCellCfg->initUlBwp.pucchPresent = true;
8763            memset(&macSrvCellCfg->initUlBwp.pucchCfg, 0, sizeof(PucchCfg));
8764            extractPucchCfg(ulBwp->pucch_Config, &macSrvCellCfg->initUlBwp.pucchCfg);
8765         }
8766      }
8767      if(cuSrvCellCfg->uplinkConfig->firstActiveUplinkBWP_Id)
8768         macSrvCellCfg->firstActvUlBwpId = *(cuSrvCellCfg->uplinkConfig->firstActiveUplinkBWP_Id);
8769    }
8770    return ret;
8771 }
8772 /*******************************************************************
8773  *
8774  * @brief Fills Reconfig Cell group Info received by CU
8775  *
8776  * @details
8777  *
8778  *    Function : extractUeReCfgCellInfo
8779  *
8780  *    Functionality: Fills Reconfig Cell group Info received by CU
8781  *
8782  * @params[in] CellGroupConfigRrc_t *macCellGrpCfg
8783  *             MacUeCfg*  macUeCfg
8784  * @return ROK/RFAILED
8785  *
8786  * ****************************************************************/
8787 uint8_t extractUeReCfgCellInfo(CellGroupConfigRrc_t *cellGrp, MacUeCfg *macUeCfg)
8788 {
8789    uint8_t ret = ROK;
8790    MAC_CellGroupConfig_t     *macCellGroup = NULLP;
8791    PhysicalCellGroupConfig_t *phyCellGrpCfg = NULLP;
8792    SpCellConfig_t            *spcellCfg = NULLP;
8793    ServingCellConfig_t       *servCellCfg = NULLP;
8794
8795    if(cellGrp)
8796    {
8797       /* Fill MacCell Group Reconfig  */
8798       if(cellGrp->mac_CellGroupConfig)
8799       {
8800          macUeCfg->macCellGrpCfgPres = true;
8801          macCellGroup = ((MAC_CellGroupConfig_t *)(cellGrp->mac_CellGroupConfig));
8802          if(macCellGroup->schedulingRequestConfig)
8803          {
8804             extractSchReqReConfig(macCellGroup->schedulingRequestConfig, &macUeCfg->macCellGrpCfg.schReqCfg);
8805          }
8806          if(macCellGroup->tag_Config)
8807          {
8808             extractTagReconfig(macCellGroup->tag_Config, &macUeCfg->macCellGrpCfg.tagCfg);
8809          }
8810          if(macCellGroup->bsr_Config)
8811          {
8812             macUeCfg->macCellGrpCfg.bsrTmrCfg.periodicTimer = macCellGroup->bsr_Config->periodicBSR_Timer;
8813             macUeCfg->macCellGrpCfg.bsrTmrCfg.retxTimer     = macCellGroup->bsr_Config->retxBSR_Timer;
8814             if(macCellGroup->bsr_Config->logicalChannelSR_DelayTimer)
8815             {
8816                macUeCfg->macCellGrpCfg.bsrTmrCfg.srDelayTimer  =\
8817                *(macCellGroup->bsr_Config->logicalChannelSR_DelayTimer);
8818             }
8819          }
8820          if(macCellGroup->phr_Config)
8821          {
8822             if(macCellGroup->phr_Config->present == MAC_CellGroupConfig__phr_Config_PR_setup)
8823             {
8824                macUeCfg->macCellGrpCfg.phrCfgSetupPres = true;
8825                if(macCellGroup->phr_Config->choice.setup)
8826                {
8827                   macUeCfg->macCellGrpCfg.phrCfg.periodicTimer     = \
8828                   macCellGroup->phr_Config->choice.setup->phr_PeriodicTimer;
8829                   macUeCfg->macCellGrpCfg.phrCfg.prohibitTimer     = \
8830                   macCellGroup->phr_Config->choice.setup->phr_ProhibitTimer;
8831                   macUeCfg->macCellGrpCfg.phrCfg.txPowerFactor     = \
8832                   macCellGroup->phr_Config->choice.setup->phr_Tx_PowerFactorChange;
8833                   macUeCfg->macCellGrpCfg.phrCfg.multiplePHR       = \
8834                   macCellGroup->phr_Config->choice.setup->multiplePHR;
8835                   macUeCfg->macCellGrpCfg.phrCfg.dummy             = \
8836                   macCellGroup->phr_Config->choice.setup->dummy;
8837                   macUeCfg->macCellGrpCfg.phrCfg.phrType2OtherCell = \
8838                   macCellGroup->phr_Config->choice.setup->phr_Type2OtherCell;
8839                   macUeCfg->macCellGrpCfg.phrCfg.phrOtherCG        = \
8840                   macCellGroup->phr_Config->choice.setup->phr_ModeOtherCG;
8841                }
8842             }
8843          }
8844       }
8845       /* Fill Physical Cell Group Reconfig */
8846       if(cellGrp->physicalCellGroupConfig)
8847       {
8848          macUeCfg->phyCellGrpCfgPres = true;
8849          phyCellGrpCfg = ((PhysicalCellGroupConfig_t *)(cellGrp->physicalCellGroupConfig));
8850          if(phyCellGrpCfg->p_NR_FR1)
8851          {
8852             if(*(phyCellGrpCfg->p_NR_FR1) != macUeCfg->phyCellGrpCfg.pNrFr1)
8853                macUeCfg->phyCellGrpCfg.pNrFr1 = *(phyCellGrpCfg->p_NR_FR1);
8854          }
8855          macUeCfg->phyCellGrpCfg.pdschHarqAckCodebook = phyCellGrpCfg->pdsch_HARQ_ACK_Codebook;
8856       }
8857       /* Fill SpCell Reconfig */
8858       if(cellGrp->spCellConfig)
8859       {
8860          macUeCfg->spCellCfgPres = true;
8861          spcellCfg = ((SpCellConfig_t *)(cellGrp->spCellConfig));
8862          if(spcellCfg->servCellIndex)
8863          {
8864             macUeCfg->spCellCfg.servCellIdx = *(spcellCfg->servCellIndex);
8865          }
8866          /* Fill Serving cell Reconfig info */
8867          if(cellGrp->spCellConfig->spCellConfigDedicated)
8868          {
8869             servCellCfg = ((ServingCellConfig_t *)(cellGrp->spCellConfig->spCellConfigDedicated));
8870             ret = extractSpCellDedicatedCfg(servCellCfg, &macUeCfg->spCellCfg.servCellCfg);
8871             if(ret == RFAILED)
8872             {
8873                DU_LOG("\nERROR --> F1AP : Failed at extractSpCellDedicatedCfg()");
8874             }
8875          }
8876       }
8877    }
8878    return ret;
8879 }
8880 /*******************************************************************
8881 *
8882 * @brief free the memory allocated by decoder
8883 *
8884 * @details
8885 *
8886 *    Function : freeAperDecodeNrcgi
8887 *
8888 *    Functionality: Free Nrcgi values
8889 *
8890 * @params[in] NRCGI_t *nrcgi
8891 * @return void
8892 *
8893 * ****************************************************************/
8894
8895
8896 void freeAperDecodeNrcgi(NRCGI_t *nrcgi)
8897 {
8898     if(nrcgi->pLMN_Identity.buf != NULLP)
8899     {
8900        free(nrcgi->pLMN_Identity.buf);
8901     }
8902     if(nrcgi->nRCellIdentity.buf != NULLP)
8903     {
8904        free(nrcgi->nRCellIdentity.buf);
8905     }
8906 }
8907 /*******************************************************************
8908 *
8909 * @brief free the memory allocated by decoder
8910 *
8911 * @details
8912 *
8913 *    Function : freeAperDecodeCuToDuInfo
8914 *
8915 *    Functionality:  Free Cu To Du Information
8916 *
8917 * @params[in] CUtoDURRCInformation_t *rrcMsg
8918 * @return void
8919 *
8920 * ****************************************************************/
8921
8922
8923 void freeAperDecodeCuToDuInfo(CUtoDURRCInformation_t *rrcMsg)
8924 {
8925    uint8_t ieIdx =0;
8926    uint8_t arrIdx =0;
8927
8928    if(rrcMsg->uE_CapabilityRAT_ContainerList)
8929    {
8930       if(rrcMsg->uE_CapabilityRAT_ContainerList->buf)
8931          free(rrcMsg->uE_CapabilityRAT_ContainerList->buf);
8932       free(rrcMsg->uE_CapabilityRAT_ContainerList);
8933    }
8934
8935    if(rrcMsg->iE_Extensions)
8936    {
8937       if(rrcMsg->iE_Extensions->list.array)
8938       {
8939          for(ieIdx= 0; ieIdx < rrcMsg->iE_Extensions->list.count; ieIdx++)
8940          {
8941             if(rrcMsg->iE_Extensions->list.array[ieIdx])
8942             {
8943                switch(rrcMsg->iE_Extensions->list.array[ieIdx]->id)
8944                {
8945                   case ProtocolIE_ID_id_CellGroupConfig:
8946                      if(rrcMsg->iE_Extensions->list.array[ieIdx]->extensionValue.choice.CellGroupConfig.buf != NULLP)
8947                      {
8948                         free(rrcMsg->iE_Extensions->list.array[ieIdx]->extensionValue.choice.CellGroupConfig.buf);
8949                      }
8950                      break;
8951                   default:
8952                      DU_LOG("\nERROR  -->  F1AP : Invalid Event type %ld at FreeCuToDuInfo()", \
8953                            rrcMsg->iE_Extensions->list.array[ieIdx]->id);
8954                      break;
8955                }
8956             }
8957          }
8958          for(arrIdx = 0; arrIdx < ieIdx; arrIdx++)
8959          {
8960             free(rrcMsg->iE_Extensions->list.array[arrIdx]);
8961          }
8962          free(rrcMsg->iE_Extensions->list.array);
8963
8964       }
8965
8966       free(rrcMsg->iE_Extensions);
8967    }
8968 }
8969 /*******************************************************************
8970 *
8971 * @brief free the memory allocated by decoder
8972 *
8973 * @details
8974 *
8975 *    Function : freeAperDecodeSplCellList
8976 *
8977 *    Functionality: Free Spl Cell List
8978                     where memory allocated by aper_decoder
8979 *
8980 * @params[in]  SCell_ToBeSetup_List_t *spCellLst
8981 * @return void
8982 *
8983 * ****************************************************************/
8984
8985
8986 void freeAperDecodeSplCellList(SCell_ToBeSetup_List_t *spCellLst)
8987 {
8988     uint8_t  cellIdx =0;
8989
8990     if(spCellLst->list.array != NULLP)
8991     {
8992        for(cellIdx=0; cellIdx<spCellLst->list.count; cellIdx++)
8993        {
8994           if(cellIdx==0&&spCellLst->list.array[cellIdx]!=NULLP)
8995           {
8996              freeAperDecodeNrcgi(&spCellLst->list.array[cellIdx]->value.choice.SCell_ToBeSetup_Item.sCell_ID);
8997           }
8998           if(spCellLst->list.array[cellIdx]!=NULLP)
8999           {
9000              free(spCellLst->list.array[cellIdx]);
9001           }
9002        }
9003        free(spCellLst->list.array);
9004     }
9005 }
9006 /*******************************************************************
9007 *
9008 * @brief free the memory allocated by decoder
9009 *
9010 * @details
9011 *
9012 *    Function : freeAperDecodeSRBSetup
9013 *
9014 *    Functionality: added free part for the memory allocated by aper_decoder
9015 *
9016 * @params[in] SRBs_ToBeSetup_List_t *srbSet
9017 * @return void
9018 *
9019 ****************************************************************/
9020
9021
9022 void freeAperDecodeSRBSetup(SRBs_ToBeSetup_List_t *srbSet)
9023 {
9024     uint8_t srbIdx =0;
9025     if(srbSet->list.array != NULLP)
9026     {
9027        for(srbIdx=0; srbIdx<srbSet->list.count; srbIdx++)
9028        {
9029           if(srbSet->list.array[srbIdx]!=NULLP)
9030           {
9031              free(srbSet->list.array[srbIdx]);
9032           }
9033        }
9034        free(srbSet->list.array);
9035     }
9036 }
9037
9038 /*******************************************************************
9039 *
9040 * @brief free the memory allocated by decoder
9041 *
9042 * @details
9043 *
9044 *    Function : freeAperDecodeULTnlInfo
9045 *
9046 *    Functionality: added free part for the memory allocated by aper_decoder
9047 *
9048 * @params[in] ULUPTNLInformation_ToBeSetup_List_t *ulInfo
9049 * @return void
9050 *
9051 * ****************************************************************/
9052
9053
9054 void freeAperDecodeULTnlInfo(ULUPTNLInformation_ToBeSetup_List_t *ulInfo)
9055 {
9056    uint8_t ulIdx=0;
9057    if(ulInfo->list.array != NULLP)
9058    {
9059       for(ulIdx=0; ulIdx<ulInfo->list.count; ulIdx++)
9060       {
9061          if(ulIdx==0&&ulInfo->list.array[ulIdx]!=NULLP)
9062          {
9063             if(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel!=NULLP)
9064             {
9065                if(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel->\
9066                      transportLayerAddress.buf != NULLP)
9067                {
9068                   if(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf\
9069                         !=NULLP)
9070                   {
9071                      free(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf);
9072                   }
9073                   free(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel->\
9074                         transportLayerAddress.buf);
9075                }
9076                free(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel);
9077             }
9078          }
9079          if(ulInfo->list.array[ulIdx]!=NULLP)
9080          {
9081             free(ulInfo->list.array[ulIdx]);
9082          }
9083       }
9084       free(ulInfo->list.array);
9085    }
9086 }
9087 /*******************************************************************
9088 *
9089 * @brief free the memory allocated by decoder
9090 *
9091 * @details
9092 *
9093 *    Function : freeAperDecodeDRBSetup
9094 *
9095 *    Functionality: free DRBSetup which is allocated by decoder
9096 *
9097 * @params[in]  DRBs_ToBeSetup_List_t *drbSet
9098 * @return void
9099 *
9100 * ****************************************************************/
9101
9102 void freeAperDecodeDRBSetup(DRBs_ToBeSetup_List_t *drbSet)
9103 {
9104    DRBs_ToBeSetup_Item_t *drbSetItem = NULLP;
9105    uint8_t  flowIdx =0;
9106    uint8_t  drbIdx =0;
9107
9108    if(drbSet->list.array != NULLP)
9109    {
9110       for(drbIdx=0; drbIdx<drbSet->list.count; drbIdx++)
9111       {
9112          if(drbIdx==0&&drbSet->list.array[drbIdx] != NULLP)
9113          {
9114             drbSetItem =&drbSet->list.array[drbIdx]->value.choice.DRBs_ToBeSetup_Item;
9115             if(drbSetItem->qoSInformation.choice.choice_extension != NULLP)
9116             {
9117                if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
9118                      qoS_Characteristics.choice.non_Dynamic_5QI !=NULLP)
9119                {
9120                   if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
9121                         qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow!=NULLP)
9122                   {
9123                      if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
9124                            qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume!=NULLP)
9125                      {
9126
9127                         if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sST.buf!=NULLP)
9128                         {
9129
9130                            if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD!=NULLP)
9131                            {
9132
9133                               if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD->\
9134                                     buf!=NULLP)
9135                               {
9136
9137                                  if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.\
9138                                        flows_Mapped_To_DRB_List.list.array != NULLP)
9139                                  {
9140
9141                                     for(flowIdx=0;flowIdx<drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9142                                           DRB_Information.flows_Mapped_To_DRB_List.list.count; flowIdx++)
9143                                     {
9144
9145                                        if(flowIdx==0&&drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9146                                              DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]!=NULLP)
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!=NULLP)
9152                                           {
9153                                              if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9154                                                    DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
9155                                                    qoSFlowLevelQoSParameters.\
9156                                                    qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow!=NULLP)
9157                                              {
9158
9159                                                 if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9160                                                       DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
9161                                                       qoSFlowLevelQoSParameters.\
9162                                                       qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume!=NULLP)
9163                                                 {
9164
9165
9166                                                    free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9167                                                          DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
9168                                                          qoSFlowLevelQoSParameters.\
9169                                                          qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume);
9170                                                 }
9171
9172                                                 free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9173                                                       DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
9174                                                       qoSFlowLevelQoSParameters.\
9175                                                       qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow);
9176                                              }
9177
9178                                              free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9179
9180                                                    DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
9181                                                    qoSFlowLevelQoSParameters.\
9182                                                    qoS_Characteristics.choice.non_Dynamic_5QI);
9183                                           }
9184                                        }
9185                                        if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9186                                              DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]!=NULLP)
9187                                        {
9188
9189                                           free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9190                                                 DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]);
9191                                        }
9192                                     }
9193
9194                                     free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9195                                           DRB_Information.flows_Mapped_To_DRB_List.list.array);
9196                                  }
9197
9198                                  free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9199                                        DRB_Information.sNSSAI.sD->buf);
9200                               }
9201
9202                               free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD);
9203                            }
9204
9205                            free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sST.buf);
9206
9207                         }
9208
9209                         free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
9210
9211                               qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume);
9212                      }
9213
9214                      free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
9215                            qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow);
9216                   }
9217
9218                   free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
9219                         qoS_Characteristics.choice.non_Dynamic_5QI);
9220                }
9221                free(drbSetItem->qoSInformation.choice.choice_extension);
9222             }
9223             freeAperDecodeULTnlInfo(&drbSetItem->uLUPTNLInformation_ToBeSetup_List);
9224             if(drbSetItem->uLConfiguration)
9225             {
9226                free(drbSetItem->uLConfiguration);
9227             }
9228          }
9229          if(drbSet->list.array[drbIdx]!=NULLP)
9230          {
9231             free(drbSet->list.array[drbIdx]);
9232          }
9233       }
9234       free(drbSet->list.array);
9235    }
9236 }
9237
9238
9239 /*******************************************************************
9240  *
9241  * @brief builds Mac Cell Cfg
9242  *
9243  * @details
9244  *
9245  *    Function : procUeReCfgCellInfo
9246  *
9247  *    Functionality: builds Mac Cell Cfg
9248  *
9249  * @params[in] MacUeCfg pointer
9250  *             void pointer
9251  *
9252  * @return void
9253  *
9254  * ****************************************************************/
9255 uint8_t procUeReCfgCellInfo(MacUeCfg *macUeCfg, void *cellInfo)
9256 {
9257    uint8_t ret = ROK;
9258    CellGroupConfigRrc_t *cellGrp = NULLP;
9259
9260    if(cellInfo)
9261    {
9262       cellGrp = (CellGroupConfigRrc_t *)cellInfo;
9263       ret = extractUeReCfgCellInfo(cellGrp, macUeCfg);
9264       if(ret == RFAILED)
9265          DU_LOG("\nERROR  -->  F1AP : Failed at procUeReCfgCellInfo()");
9266    }
9267    if(ret == RFAILED)
9268    {
9269       freeUeReCfgCellGrpInfo(macUeCfg);
9270    }
9271    return ret;
9272 }
9273
9274 /*******************************************************************
9275  *
9276  * @brief Filling modulation info in mac ue cfg
9277  *
9278  * @details
9279  *
9280  *    Function : duFillModulationDetails
9281  *
9282  *    Functionality: Filling modulation info in mac ue cfg
9283  *
9284  * @params[in] MAC UE Config to be updated
9285  *             Current UE configuration
9286  *             UE NR capability from CU
9287  * @return ROK     - success
9288  *         RFAILED - failure
9289  *
9290  * ****************************************************************/
9291 void duFillModulationDetails(MacUeCfg *ueCfg, MacUeCfg *oldUeCfg, void *ueCap)
9292 {
9293    UE_NR_Capability_t *ueNrCap;
9294
9295    if(ueCap)
9296       ueNrCap = (UE_NR_Capability_t *)ueCap;
9297
9298    /* Filling DL modulation info */
9299    if(ueNrCap->featureSets && ueNrCap->featureSets->featureSetsDownlinkPerCC && \
9300          ueNrCap->featureSets->featureSetsDownlinkPerCC->list.array[0] && \
9301          ueNrCap->featureSets->featureSetsDownlinkPerCC->list.array[0]->supportedModulationOrderDL)
9302    {
9303       switch(*(ueNrCap->featureSets->featureSetsDownlinkPerCC->list.array[0]->supportedModulationOrderDL))
9304       {
9305          case ModulationOrder_qpsk:
9306             {
9307                ueCfg->dlModInfo.modOrder = MOD_ORDER_QPSK;
9308                break;
9309             }
9310          case ModulationOrder_qam16:
9311             {
9312                ueCfg->dlModInfo.modOrder = MOD_ORDER_QAM16;
9313                break;
9314             }
9315          case ModulationOrder_qam64:
9316             {
9317                ueCfg->dlModInfo.modOrder = MOD_ORDER_QAM64;
9318                ueCfg->dlModInfo.mcsIndex = PDSCH_MCS_INDEX;
9319                ueCfg->dlModInfo.mcsTable = MCS_TABLE_QAM64;
9320                break;
9321             }
9322          case ModulationOrder_qam256:
9323             {
9324                ueCfg->dlModInfo.modOrder = MOD_ORDER_QAM256;
9325                break;
9326             }
9327          default:
9328             {
9329                DU_LOG("\nERROR  -->  DU APP: Incorrect downlink modulation order received. Reatining old modulation configuration");
9330                memcpy(&ueCfg->dlModInfo, &oldUeCfg->dlModInfo, sizeof(ModulationInfo));
9331                break;
9332             }
9333       }
9334    }
9335    else
9336    {
9337       memcpy(&ueCfg->dlModInfo, &oldUeCfg->dlModInfo, sizeof(ModulationInfo));
9338    }
9339
9340    /* Filling UL modulation info */
9341    if(ueNrCap->featureSets && ueNrCap->featureSets->featureSetsUplinkPerCC && \
9342          ueNrCap->featureSets->featureSetsUplinkPerCC->list.array[0] && \
9343          ueNrCap->featureSets->featureSetsUplinkPerCC->list.array[0]->supportedModulationOrderUL)
9344    {
9345       switch(*(ueNrCap->featureSets->featureSetsUplinkPerCC->list.array[0]->supportedModulationOrderUL))
9346       {
9347          case ModulationOrder_qpsk:
9348             {
9349                ueCfg->ulModInfo.modOrder = MOD_ORDER_QPSK;
9350                break;
9351             }
9352          case ModulationOrder_qam16:
9353             {
9354                ueCfg->ulModInfo.modOrder = MOD_ORDER_QAM16;
9355                ueCfg->ulModInfo.mcsIndex = PUSCH_MCS_INDEX;
9356                ueCfg->ulModInfo.mcsTable = MCS_TABLE_QAM64;
9357                break;
9358             }
9359          case ModulationOrder_qam64:
9360             {
9361                ueCfg->ulModInfo.modOrder = MOD_ORDER_QAM64;
9362                break;
9363             }
9364          case ModulationOrder_qam256:
9365             {
9366                ueCfg->ulModInfo.modOrder = MOD_ORDER_QAM256;
9367                break;
9368             }
9369          default:
9370             {
9371                DU_LOG("\nERROR  -->  DU APP: Incorrect uplink modulation order received. Reatining old modulation configuration");
9372                memcpy(&ueCfg->ulModInfo, &oldUeCfg->ulModInfo, sizeof(ModulationInfo));
9373                break;
9374             }
9375       }
9376    }
9377    else
9378    {
9379       memcpy(&ueCfg->ulModInfo, &oldUeCfg->ulModInfo, sizeof(ModulationInfo));
9380    }
9381 }
9382
9383 /*******************************************************************
9384  *
9385  * @brief Function to extract cellGrp Info present in cutoDu cont
9386  *
9387  * @details
9388  *
9389  *    Function : extractCellGrpInfo
9390  *
9391  *    Functionality: Function to extract cellGrp Info present
9392  *                   in cutoDu cont
9393  *
9394  * @params[in] ProtocolExtensionContainer_4624P16_t pointer
9395  *
9396  * @return CellGroupConfigRrc_t *
9397  *
9398  * ****************************************************************/
9399
9400 CellGroupConfigRrc_t *extractCellGrpInfo(ProtocolExtensionContainer_4624P16_t *protocolIeExtn,\
9401       DuUeCfg *ueCfgDb)
9402 {
9403    uint8_t idx2 =0;
9404    uint16_t id =0;
9405    uint16_t recvBufLen =0;
9406    CellGroupConfigRrc_t *cellGrpCfg = NULLP;
9407    CUtoDURRCInformation_ExtIEs_t *extIeInfo = NULLP;
9408    asn_dec_rval_t rval; /* Decoder return value */
9409    memset(&rval, 0, sizeof(asn_dec_rval_t));
9410
9411    if(protocolIeExtn)
9412    {
9413       for(idx2 = 0; idx2 < protocolIeExtn->list.count; idx2++)
9414       {
9415          extIeInfo = ((CUtoDURRCInformation_ExtIEs_t *)(protocolIeExtn->list.array[idx2]));
9416          id = extIeInfo->id;
9417          switch(id)
9418          {
9419             case ProtocolIE_ID_id_CellGroupConfig:
9420             {
9421                recvBufLen = extIeInfo->extensionValue.choice.CellGroupConfig.size;
9422                /* decoding the CellGroup Buf received */
9423                DU_ALLOC(cellGrpCfg, sizeof(CellGroupConfigRrc_t));
9424                if(cellGrpCfg)
9425                {
9426                   memset(cellGrpCfg, 0, sizeof(CellGroupConfigRrc_t));
9427                   rval = aper_decode(0, &asn_DEF_CellGroupConfigRrc, (void **)&cellGrpCfg,
9428                      extIeInfo->extensionValue.choice.CellGroupConfig.buf, recvBufLen, 0, 0);
9429                   if(rval.code == RC_FAIL || rval.code == RC_WMORE)
9430                   {
9431                      DU_LOG("\nERROR  -->  F1AP : ASN decode failed at decodeCellGrpCfg()");
9432                      return NULLP;
9433                   }
9434                   xer_fprint(stdout, &asn_DEF_CellGroupConfigRrc, cellGrpCfg);
9435                   if(extractRlcCfgToAddMod(cellGrpCfg->rlc_BearerToAddModList, ueCfgDb))
9436                      return NULLP;
9437                }
9438                break;
9439             }
9440             default:
9441                DU_LOG("\nERROR  -->  F1AP : Invalid IE received CUtoDURRCInformation:%d at decodeCellGrpCfg()", id);
9442                break;
9443          }
9444       }
9445    }
9446    return cellGrpCfg;
9447 }
9448
9449 /*******************************************************************
9450  *
9451  * @brief Fills Srb List received by CU
9452  *
9453  * @details
9454  *
9455  *    Function : procSrbListToSetup
9456  *
9457  *    Functionality: Fills Srb List received  by CU
9458  *
9459  * @params[in] SRBs_ToBeSetup_Item_t *cuSrbItem
9460  *             LcCfg pointer
9461  *             RlcBearerCfg pointer
9462  * @return void
9463  *
9464  * ****************************************************************/
9465 uint8_t procSrbListToSetup(SRBs_ToBeSetup_Item_t * srbItem, LcCfg *macLcToAdd, RlcBearerCfg *rlcLcToAdd)
9466 {
9467    uint8_t ret = ROK;
9468
9469    /* Filling RLC INFO */
9470    procRlcLcCfg(srbItem->sRBID, srbItem->sRBID, RB_TYPE_SRB, RLC_AM, CONFIG_ADD, NULL, rlcLcToAdd);
9471
9472    /* Filling MAC INFO */
9473    ret = procMacLcCfg(srbItem->sRBID, RB_TYPE_SRB, CONFIG_ADD, NULL,NULL, NULL, macLcToAdd, NULL);
9474    if(ret == RFAILED)
9475    {
9476       DU_LOG("\nERROR  -->  F1AP : Failed at MAC LC Cfg in procSrbListToSetup()");
9477       return ret;
9478    }
9479    return ret;
9480 }
9481
9482
9483
9484 /*******************************************************************
9485  *
9486  * @brief extract Srb List received by CU
9487  *
9488  * @details
9489  *
9490  *    Function : extractSrbListToSetup
9491  *
9492  *    Functionality: extract Srb List received by CU
9493  *                   for both MAC and RLC
9494  *
9495  * @params[in] SRBs_ToBeSetup_Item_t pointer
9496  *             DuUeCfg pointer
9497  * @return ROK/RFAIED
9498  *
9499  * ****************************************************************/
9500
9501 uint8_t extractSrbListToSetup(SRBs_ToBeSetup_List_t *srbCfg, DuUeCfg *ueCfgDb)
9502 {
9503    uint8_t ret, srbIdx;
9504    SRBs_ToBeSetup_Item_t *srbItem = NULLP;
9505
9506    if(srbCfg)
9507    {
9508       for(srbIdx = 0; srbIdx < srbCfg->list.count; srbIdx++)
9509       {
9510          srbItem = &srbCfg->list.array[srbIdx]->value.choice.SRBs_ToBeSetup_Item;
9511          if(ueCfgDb->numMacLcs > MAX_NUM_LC)
9512          {
9513             DU_LOG("\nERROR   -->  F1AP:  MAX LC Reached in MAC");
9514             ret = RFAILED;
9515             break;
9516          }
9517          if(ueCfgDb->numRlcLcs > MAX_NUM_LC)
9518          {
9519             DU_LOG("\nERROR   -->  F1AP:  MAX LC Reached in RLC");
9520             ret = RFAILED;
9521             break;
9522          }
9523          memset(&ueCfgDb->macLcCfg[ueCfgDb->numMacLcs], 0, sizeof(LcCfg));
9524          memset(&ueCfgDb->rlcLcCfg[ueCfgDb->numRlcLcs], 0, sizeof(RlcBearerCfg));
9525          ret = procSrbListToSetup(srbItem, &ueCfgDb->macLcCfg[ueCfgDb->numMacLcs],\
9526             &ueCfgDb->rlcLcCfg[ueCfgDb->numRlcLcs]);
9527          ueCfgDb->numRlcLcs++;
9528          ueCfgDb->numMacLcs++;
9529          if(ret == RFAILED)
9530          {
9531             DU_LOG("\nERROR  -->  F1AP:  Failed at extractSrbListToSetup()");
9532             break;
9533          }
9534       }
9535    }
9536    else
9537       ret = RFAILED;
9538
9539    return ret;
9540 }
9541
9542 /*******************************************************************
9543  *
9544  * @brief Fills Drb List received by CU
9545  *
9546  * @details
9547  *
9548  *    Function : procDrbListToSetup
9549  *
9550  *    Functionality: Fills Drb List received by CU
9551  *                   for both MAC and RLC
9552  *
9553  * @params[in] SRBs_ToBeSetup_Item_t pointer
9554  *             LcCfg pointer,
9555  *             RlcBearerCfg pointer
9556  * @return void
9557  *
9558  * ****************************************************************/
9559
9560 uint8_t procDrbListToSetup(uint8_t lcId, DRBs_ToBeSetup_Item_t *drbItem,\
9561 DRBs_ToBeSetupMod_Item_t *drbSetupModItem, LcCfg *macLcToAdd, RlcBearerCfg *rlcLcToAdd, UpTnlCfg *upTnlInfo)
9562 {
9563
9564    if(drbItem != NULLP)
9565    {
9566       /* Filling RLC INFO */
9567       procRlcLcCfg(drbItem->dRBID, lcId, RB_TYPE_DRB, drbItem->rLCMode, CONFIG_ADD, NULL, rlcLcToAdd);
9568
9569       /* Filling MAC INFO */
9570       if(procMacLcCfg(lcId, RB_TYPE_DRB, CONFIG_ADD, drbItem, NULL, NULL, macLcToAdd, upTnlInfo) != ROK)
9571       {
9572          DU_LOG("\nERROR  --> F1AP : Failed at RLC LC Cfg in procDrbListToSetup()");
9573          return RFAILED;
9574       }
9575    }
9576    else if(drbSetupModItem != NULLP)
9577    {
9578       procRlcLcCfg(drbSetupModItem->dRBID, lcId, RB_TYPE_DRB, drbSetupModItem->rLCMode, CONFIG_ADD, NULL, rlcLcToAdd);
9579
9580       if(procMacLcCfg(lcId, RB_TYPE_DRB, CONFIG_ADD, NULL, drbSetupModItem, NULL, macLcToAdd, upTnlInfo) != ROK)
9581       {
9582          DU_LOG("\nERROR  --> F1AP : Failed at RLC LC Cfg in procDrbListToSetup()");
9583          return RFAILED;
9584       }
9585    }
9586    return ROK;
9587 }
9588
9589 /*******************************************************************
9590  *
9591  * @brief extract Drb List received by CU
9592  *
9593  * @details
9594  *
9595  *    Function : extractDrbListToSetup
9596  *
9597  *    Functionality: extract Drb List received by CU
9598  *                   for both MAC and RLC
9599  *
9600  * @params[in] DRBs_ToBeSetup_Item_t pointer
9601  *             DuUeCfg pointer
9602  * @return ROK/RFAIED
9603  *
9604  * ****************************************************************/
9605
9606 uint8_t extractDrbListToSetup(uint8_t lcId, DRBs_ToBeSetup_List_t *drbCfg,DRBs_ToBeSetupMod_List_t *drbSetupModCfg,\
9607 uint8_t drbCount, DuUeCfg *ueCfgDb)
9608 {
9609    uint8_t ret, drbIdx;
9610    DRBs_ToBeSetup_Item_t *drbItem = NULLP;
9611    DRBs_ToBeSetupMod_ItemIEs_t *drbSetupModItem = NULLP;
9612
9613    ret = ROK;
9614    if(drbCount > 0)
9615    {
9616       for(drbIdx = 0; drbIdx < drbCount; drbIdx++)
9617       {
9618          if(ueCfgDb->numMacLcs > MAX_NUM_LC)
9619          {
9620             DU_LOG("\nERROR  -->  F1AP :  MAX LC Reached in MAC at extractDrbListToSetup()");
9621             ret = RFAILED;
9622             break;
9623          }
9624          if(ueCfgDb->numRlcLcs > MAX_NUM_LC)
9625          {
9626             DU_LOG("\nERROR  -->  F1AP :  MAX LC Reached in RLC at extractDrbListToSetup()");
9627             ret = RFAILED;
9628             break;
9629          }
9630          memset(&ueCfgDb->macLcCfg[ueCfgDb->numMacLcs], 0, sizeof(LcCfg));
9631          memset(&ueCfgDb->rlcLcCfg[ueCfgDb->numRlcLcs], 0, sizeof(RlcBearerCfg));
9632
9633          if(drbCfg != NULL)
9634          {
9635             drbItem = &drbCfg->list.array[drbIdx]->value.choice.DRBs_ToBeSetup_Item;
9636             ret = procDrbListToSetup(lcId, drbItem, NULL, &ueCfgDb->macLcCfg[ueCfgDb->numMacLcs],\
9637                &ueCfgDb->rlcLcCfg[ueCfgDb->numRlcLcs], &ueCfgDb->upTnlInfo[ueCfgDb->numDrb]);
9638             if(ret == RFAILED)
9639             {
9640                DU_LOG("\nERROR  --> F1AP : Failed at extractDrbListToSetup()");
9641                break;
9642             }
9643          }
9644          else if(drbSetupModCfg != NULL)
9645          {
9646             drbSetupModItem = (DRBs_ToBeSetupMod_ItemIEs_t *) drbSetupModCfg->list.array[drbIdx];
9647             ret = procDrbListToSetup(lcId, NULL, &(drbSetupModItem->value.choice.DRBs_ToBeSetupMod_Item) ,\
9648             &ueCfgDb->macLcCfg[ueCfgDb->numMacLcs], &ueCfgDb->rlcLcCfg[ueCfgDb->numRlcLcs],\
9649             &ueCfgDb->upTnlInfo[ueCfgDb->numDrb]);
9650             if(ret == RFAILED)
9651             {
9652                DU_LOG("\nERROR  --> F1AP : Failed at extractDrbListToSetup()");
9653                break;
9654             }
9655          }
9656          ueCfgDb->numRlcLcs++;
9657          ueCfgDb->numMacLcs++;
9658          ueCfgDb->numDrb++;
9659          if(ret == RFAILED)
9660          {
9661             DU_LOG("\nERROR  --> F1AP : Failed at extractDrbListToSetup()");
9662             break;
9663          }
9664       }
9665    }
9666    else
9667       ret = RFAILED;
9668
9669    return ret;
9670 }
9671
9672 /*******************************************************************
9673  *
9674  * @brief Function to extract Dl RRC Msg received from CU
9675  *
9676  * @details
9677  *
9678  *    Function : extractDlRrcMsg
9679  *
9680  *    Functionality: Function to extract Dl RRC Msg received from CU
9681  *
9682  * @params[in] F1AP message
9683  * @return ROK     - success
9684  *         RFAILED - failure
9685  *
9686  * ****************************************************************/
9687
9688 uint8_t extractDlRrcMsg(uint32_t gnbDuUeF1apId, uint32_t gnbCuUeF1apId, \
9689    F1DlRrcMsg *dlRrcMsg, RRCContainer_t *rrcContainer)
9690 {
9691    uint8_t ret = ROK;
9692    dlRrcMsg->rrcMsgSize = rrcContainer->size;
9693    if(dlRrcMsg->rrcMsgSize > 0)
9694    {
9695       DU_ALLOC_SHRABL_BUF(dlRrcMsg->rrcMsgPdu, dlRrcMsg->rrcMsgSize);
9696       if(!dlRrcMsg->rrcMsgPdu)
9697       {
9698          DU_LOG("\nERROR  --> DU APP : Memory allocation failed for RRC Msg in extractDlRrcMsg()");
9699          ret = RFAILED;
9700       }
9701       else
9702       {
9703          dlRrcMsg->gnbDuUeF1apId = gnbDuUeF1apId;
9704          dlRrcMsg->gnbCuUeF1apId = gnbCuUeF1apId;
9705          dlRrcMsg->srbId = SRB1_LCID;
9706          memcpy(dlRrcMsg->rrcMsgPdu, rrcContainer->buf, dlRrcMsg->rrcMsgSize);
9707       }
9708    }
9709    return ret;
9710 }
9711
9712 /*******************************************************************
9713  *
9714  * @brief Extract UE capability info
9715  *
9716  * @details
9717  *
9718  *    Function : extractUeCapability
9719  *
9720  *    Functionality: Extract UE capability info and stores in ue Cb
9721  *
9722  * @params[in] Octet string of UE capability RAT container list
9723  * @return ROK     - success
9724  *         RFAILED - failure
9725  *
9726  * ****************************************************************/
9727 UE_NR_Capability_t *extractUeCapability(UE_CapabilityRAT_ContainerList_t *ueCapablityListBuf, DuUeCb *ueCb)
9728 {
9729    uint8_t  idx;
9730    uint16_t recvBufLen;
9731    asn_dec_rval_t rval;
9732    UE_NR_Capability_t  *ueNrCap = NULLP;
9733    UE_CapabilityRAT_ContainerListRRC_t  *ueCapRatContList = NULLP;
9734
9735    /* Decoding UE Capability RAT Container List */
9736    recvBufLen = ueCapablityListBuf->size;
9737    DU_ALLOC(ueCapRatContList, sizeof(UE_CapabilityRAT_ContainerListRRC_t));
9738    if(!ueCapRatContList)
9739    {
9740       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in extractUeCapability");
9741       return NULLP;
9742    }
9743    memset(ueCapRatContList, 0, sizeof(UE_CapabilityRAT_ContainerListRRC_t));
9744    memset(&rval, 0, sizeof(asn_dec_rval_t));
9745    rval = aper_decode(0, &asn_DEF_UE_CapabilityRAT_ContainerListRRC, (void **)&ueCapRatContList,
9746           ueCapablityListBuf->buf, recvBufLen, 0, 0);
9747    if(rval.code == RC_FAIL || rval.code == RC_WMORE)
9748    {
9749       DU_LOG("\nERROR  -->  F1AP : ASN decode failed at decodeCellGrpCfg()");
9750       return NULLP;
9751    }
9752    xer_fprint(stdout, &asn_DEF_UE_CapabilityRAT_ContainerListRRC, ueCapRatContList);
9753
9754    /* Free encoded buffer after decoding */
9755
9756    for(idx = 0; idx < ueCapRatContList->list.count; idx++)
9757    {
9758       if(ueCapRatContList->list.array[idx]->rat_Type == RAT_Type_nr)
9759       {
9760          /* Decoding UE NR Capability */
9761           recvBufLen = ueCapRatContList->list.array[idx]->ue_CapabilityRAT_Container.size;
9762           DU_ALLOC(ueNrCap, sizeof(UE_NR_Capability_t));
9763           if(!ueNrCap)
9764           {
9765              DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in extractUeCapability");
9766              DU_FREE(ueCapRatContList, sizeof(UE_CapabilityRAT_ContainerListRRC_t));
9767              return NULLP;
9768           }
9769           memset(ueNrCap, 0, sizeof(UE_NR_Capability_t));
9770           memset(&rval, 0, sizeof(asn_dec_rval_t));
9771           rval = aper_decode(0, &asn_DEF_UE_NR_Capability, (void **)&ueNrCap,
9772                  ueCapRatContList->list.array[idx]->ue_CapabilityRAT_Container.buf, recvBufLen, 0, 0);
9773           if(rval.code == RC_FAIL || rval.code == RC_WMORE)
9774           {
9775              DU_LOG("\nERROR  -->  F1AP : ASN decode failed at decodeCellGrpCfg()");
9776              return NULLP;
9777           }
9778           xer_fprint(stdout, &asn_DEF_UE_NR_Capability, ueNrCap);
9779
9780           /* Free encoded buffer after decoding */
9781           free(ueCapRatContList->list.array[idx]->ue_CapabilityRAT_Container.buf);
9782       }
9783       free(ueCapRatContList->list.array[idx]);
9784    }
9785
9786    /* Free Memory*/
9787    free(ueCapRatContList->list.array);
9788    DU_FREE(ueCapRatContList, sizeof(UE_CapabilityRAT_ContainerListRRC_t));
9789    return ueNrCap;
9790 }
9791
9792 /*******************************************************************
9793 *
9794 * @brief free UE context setup request from CU
9795 *
9796 * @details
9797 *
9798 *    Function : freeAperDecodeF1UeContextSetupReq
9799 *
9800 *    Functionality: freeing part for the memory allocated by aper_decoder
9801 *
9802 * @params[in] F1AP message
9803 * @return ROK     - success
9804 *         RFAILED - failure
9805 *
9806 * ****************************************************************/
9807 void freeAperDecodeF1UeContextSetupReq(UEContextSetupRequest_t   *ueSetReq)
9808 {
9809    uint8_t ieIdx = 0;
9810
9811    if(ueSetReq->protocolIEs.list.array != NULLP)
9812    {
9813       for(ieIdx = 0; ieIdx < ueSetReq->protocolIEs.list.count; ieIdx++)
9814       {
9815          if(ueSetReq->protocolIEs.list.array[ieIdx])
9816          {
9817             switch(ueSetReq->protocolIEs.list.array[ieIdx]->id)
9818             {
9819                case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
9820                   break;
9821                case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
9822                   break;
9823                case ProtocolIE_ID_id_SpCell_ID:
9824                   freeAperDecodeNrcgi(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.NRCGI);
9825                   break;
9826                case ProtocolIE_ID_id_ServCellIndex:
9827                   break;
9828                case ProtocolIE_ID_id_SpCellULConfigured:
9829                   break;
9830                case ProtocolIE_ID_id_CUtoDURRCInformation:
9831
9832                   freeAperDecodeCuToDuInfo(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.CUtoDURRCInformation);
9833                   break;
9834                case ProtocolIE_ID_id_SCell_ToBeSetup_List:
9835
9836                   freeAperDecodeSplCellList(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.SCell_ToBeSetup_List);
9837                   break;
9838                case ProtocolIE_ID_id_SRBs_ToBeSetup_List:
9839
9840                   freeAperDecodeSRBSetup(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.SRBs_ToBeSetup_List);
9841                   break;
9842                case ProtocolIE_ID_id_DRBs_ToBeSetup_List:
9843
9844                   freeAperDecodeDRBSetup(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.DRBs_ToBeSetup_List);
9845                   break;
9846                case ProtocolIE_ID_id_RRCContainer:
9847                   {
9848
9849                      if(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf != NULLP)
9850                      {
9851
9852                         free(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf);
9853                      }
9854                      break;
9855                   }
9856                case ProtocolIE_ID_id_RRCDeliveryStatusRequest:
9857                   break;
9858                case ProtocolIE_ID_id_GNB_DU_UE_AMBR_UL:
9859                   {
9860                      if(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.BitRate.buf)
9861                      {
9862                         free(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.BitRate.buf);
9863                      }
9864                      break;
9865                   }
9866                default:
9867                   DU_LOG("\nERROR  -->  F1AP: Invalid event type %ld " ,ueSetReq->protocolIEs.list.array[ieIdx]->id);
9868             }
9869             free(ueSetReq->protocolIEs.list.array[ieIdx]);
9870          }
9871       }
9872       free(ueSetReq->protocolIEs.list.array);
9873    }
9874 }
9875 /*******************************************************************
9876  *
9877  * @brief Process UE context setup request from CU
9878  *
9879  * @details
9880  *
9881  *    Function : procF1UeContextSetupReq
9882  *
9883  *    Functionality: Process UE context setup request from CU
9884  *
9885  * @params[in] F1AP message
9886  * @return ROK     - success
9887  *         RFAILED - failure
9888  *
9889  * ****************************************************************/
9890 uint8_t procF1UeContextSetupReq(F1AP_PDU_t *f1apMsg)
9891 {
9892    uint8_t  ret=0, ieIdx=0, ueIdx=0, lcId=0, cellIdx=0;
9893    bool ueCbFound = false;
9894    uint32_t gnbCuUeF1apId=0, gnbDuUeF1apId=0, bitRateSize=0;
9895    DuUeCb   *duUeCb = NULL;
9896    UEContextSetupRequest_t   *ueSetReq = NULL;
9897    DRBs_ToBeSetup_List_t *drbCfg = NULL;
9898
9899    ret = ROK;
9900
9901    ueSetReq = &f1apMsg->choice.initiatingMessage->value.choice.UEContextSetupRequest;
9902    for(ieIdx=0; (ieIdx < ueSetReq->protocolIEs.list.count && ret == ROK); ieIdx++)
9903    {
9904       switch(ueSetReq->protocolIEs.list.array[ieIdx]->id)
9905       {
9906          case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
9907             {
9908                gnbCuUeF1apId = ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID;
9909                break;
9910             }
9911          case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
9912             {
9913                gnbDuUeF1apId = ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID;
9914                break;
9915             }
9916          case ProtocolIE_ID_id_ServCellIndex:
9917             {
9918                cellIdx = ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.ServCellIndex;
9919                for(ueIdx = 0; ueIdx < MAX_NUM_UE; ueIdx++)
9920                {
9921                   if((duCb.actvCellLst[cellIdx]->ueCb[ueIdx].gnbDuUeF1apId == gnbDuUeF1apId)&&\
9922                         (duCb.actvCellLst[cellIdx]->ueCb[ueIdx].gnbCuUeF1apId == gnbCuUeF1apId))
9923                   {
9924                      ueCbFound = true;
9925                      duUeCb = &duCb.actvCellLst[cellIdx]->ueCb[ueIdx];
9926                      DU_ALLOC(duUeCb->f1UeDb, sizeof(F1UeContextSetupDb));
9927                      if(duUeCb->f1UeDb)
9928                      {
9929                         memset(duUeCb->f1UeDb, 0, sizeof(F1UeContextSetupDb));
9930                         duUeCb->f1UeDb->actionType = UE_CTXT_SETUP;
9931                         duUeCb->f1UeDb->cellIdx = cellIdx;
9932                      }
9933                      else
9934                      {
9935                         DU_LOG("\nERROR  -->  F1AP: Memory Alloc Failed at procF1UeContextSetupReq()");
9936                         ret = RFAILED;
9937                      }
9938                   }
9939                   else
9940                      ueCbFound = false;
9941
9942                }
9943                if(!ueCbFound)
9944                {
9945                   DU_LOG("\nERROR  -->  F1AP: DuUeCb is not found at procF1UeContextSetupReq()");
9946                   ret = RFAILED;
9947                }
9948                break;
9949             }
9950          case ProtocolIE_ID_id_SpCellULConfigured:
9951             /* Indicates whether the gNB-CU requests the gNB-DU to configure the uplink as no UL,
9952                UL, SUL or UL+SUL for the indicated cell for the UE */
9953             break;
9954          case ProtocolIE_ID_id_CUtoDURRCInformation:
9955             {
9956                if(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.CUtoDURRCInformation.uE_CapabilityRAT_ContainerList)
9957                {
9958                   duUeCb->f1UeDb->duUeCfg.ueNrCapability = \
9959                   extractUeCapability(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.CUtoDURRCInformation.\
9960                   uE_CapabilityRAT_ContainerList, duUeCb);
9961                }
9962                if(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.CUtoDURRCInformation.iE_Extensions)
9963                {
9964                   duUeCb->f1UeDb->duUeCfg.cellGrpCfg = extractCellGrpInfo(ueSetReq->protocolIEs.list.array[ieIdx]->\
9965                         value.choice.CUtoDURRCInformation.iE_Extensions, &duUeCb->f1UeDb->duUeCfg);
9966                   if(!duUeCb->f1UeDb->duUeCfg.cellGrpCfg)
9967                   {
9968                      DU_LOG("\nERROR  -->  F1AP: Failed to extract cell Grp Info");
9969                      //TODO: Update the failure cause in ue context Setup Response
9970                      ret = RFAILED;
9971                   }
9972                }
9973                break;
9974             }
9975          case ProtocolIE_ID_id_SCell_ToBeSetup_List:
9976             {
9977                DU_LOG("\nINFO   -->  DU_APP: Received SCell_ToBeSetup_List but  Not processing the list");
9978                break;
9979             }
9980          case ProtocolIE_ID_id_SRBs_ToBeSetup_List:
9981             {
9982                if(extractSrbListToSetup(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.SRBs_ToBeSetup_List,\
9983                &duUeCb->f1UeDb->duUeCfg))
9984                {
9985                   DU_LOG("\nERROR  -->  DU APP : Failed at extractSrbListToSetup()");
9986                   //TODO: Update the failure cause in ue context Setup Response
9987                   ret = RFAILED;
9988                }
9989                break;
9990             }
9991          case ProtocolIE_ID_id_DRBs_ToBeSetup_List:
9992             {
9993                lcId = getDrbLcId(&duUeCb->drbBitMap);
9994                if(lcId != RFAILED)
9995                {
9996                   drbCfg = &ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.DRBs_ToBeSetup_List;
9997                   if(extractDrbListToSetup(lcId, drbCfg, NULL, drbCfg->list.count, &duUeCb->f1UeDb->duUeCfg))
9998                   {
9999                      DU_LOG("\nERROR  -->  DU APP : Failed at extractDrbListToSetup()");
10000                      //TODO: Update the failure cause in ue context Setup Response
10001                      ret = RFAILED;
10002                   }
10003                }
10004                else
10005                   ret = RFAILED;
10006                break;
10007             }
10008          case ProtocolIE_ID_id_RRCContainer:
10009             {
10010                /* Filling Dl RRC Msg Info */
10011                DU_ALLOC_SHRABL_BUF(duUeCb->f1UeDb->dlRrcMsg, sizeof(F1DlRrcMsg));
10012                if(!duUeCb->f1UeDb->dlRrcMsg)
10013                {
10014                   DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for DL RRC Msg in procUeCtxtSetupReq()");
10015                   ret = RFAILED;
10016                }
10017                else
10018                {
10019                   duUeCb->f1UeDb->dlRrcMsgPres = true;
10020                   memset(duUeCb->f1UeDb->dlRrcMsg, 0, sizeof(F1DlRrcMsg));
10021                   ret = extractDlRrcMsg(gnbDuUeF1apId, gnbCuUeF1apId, duUeCb->f1UeDb->dlRrcMsg,\
10022                         &ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer);
10023                }
10024                break;
10025             }
10026          case ProtocolIE_ID_id_RRCDeliveryStatusRequest:
10027             {
10028                if(duUeCb->f1UeDb->dlRrcMsg->rrcMsgPdu)
10029                {
10030                   duUeCb->f1UeDb->dlRrcMsg->deliveryStatRpt = true;
10031                }
10032                else
10033                {
10034                   DU_LOG("\nERROR  -->  Ignoring delivery report, since rrcContainer is not present");
10035                }
10036                break;
10037             }
10038          case ProtocolIE_ID_id_GNB_DU_UE_AMBR_UL:
10039             {
10040                /* MaximumBitRate Uplink */
10041                bitRateSize = ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.BitRate.size;
10042                if(bitRateSize > 0)
10043                {
10044                   DU_ALLOC_SHRABL_BUF(duUeCb->f1UeDb->duUeCfg.ambrCfg, bitRateSize);
10045                   if(!duUeCb->f1UeDb->duUeCfg.ambrCfg)
10046                   {
10047                      DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for bitRate in procUeCtxtSetupReq");
10048                      ret = RFAILED;
10049                   }
10050                   else
10051                   {
10052                      memset(duUeCb->f1UeDb->duUeCfg.ambrCfg, 0, sizeof(AmbrCfg));
10053                      memcpy(&duUeCb->f1UeDb->duUeCfg.ambrCfg->ulBr,
10054                            ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.BitRate.buf, bitRateSize);
10055                   }
10056                }
10057                else
10058                   ret = RFAILED;
10059                break;
10060             }
10061          default:
10062             {
10063                break;
10064             }
10065       }
10066    }
10067    if(ret == RFAILED)
10068    {
10069       /*TODO : Negative case*/
10070       // BuildAndSendUeContextSetupRsp(ueIdx, cellId);
10071       DU_LOG("\nERROR  -->  F1AP: Failed to process UE CNTXT SETUP REQ at procF1UeContextSetupReq()");
10072    }
10073    else
10074       ret = duProcUeContextSetupRequest(duUeCb);
10075
10076    freeAperDecodeF1UeContextSetupReq(ueSetReq);
10077    return ret;
10078
10079 }
10080 /*******************************************************************
10081  * @brief Free the memory allocated for Dl Tunnel Info
10082  *
10083  * @details
10084  *
10085  *    Function : freeDlTnlInfo
10086  *
10087  *    Functionality:
10088  *       Free the memory allocated for Dl Tunnel Info
10089  *
10090  * @params[in] DLUPTNLInformation_ToBeSetup_List_t *
10091  * @return void
10092  *
10093  * ****************************************************************/
10094
10095 void freeDlTnlInfo(DLUPTNLInformation_ToBeSetup_List_t *tnlInfo)
10096 {
10097    uint8_t arrIdx = 0;
10098
10099    for(arrIdx=0; arrIdx < tnlInfo->list.count; arrIdx++)
10100    {
10101       DU_FREE(tnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel, sizeof(GTPTunnel_t));
10102    }
10103 }
10104
10105 /*******************************************************************
10106  * @brief Free the memory allocated for DRB setup List
10107  *
10108  * @details
10109  *
10110  *    Function : freeDrbSetupList
10111  *
10112  *    Functionality:
10113  *       Free the memory allocated for DRB setup list
10114  *
10115  * @params[in] DRBs_Setup_List_t *
10116  * @return void
10117  *
10118  * ****************************************************************/
10119 void freeDrbSetupList(DRBs_Setup_List_t *drbSetupList)
10120 {
10121    uint8_t arrIdx = 0;
10122    DRBs_Setup_ItemIEs_t *drbItemIe = NULLP;
10123
10124    for(arrIdx = 0; arrIdx < drbSetupList->list.count; arrIdx++)
10125    {
10126       drbItemIe = ((DRBs_Setup_ItemIEs_t *)drbSetupList->list.array[arrIdx]);
10127       freeDlTnlInfo(&drbItemIe->value.choice.DRBs_Setup_Item.dLUPTNLInformation_ToBeSetup_List);
10128    }
10129 }
10130
10131 /*******************************************************************
10132  * @brief Free the memory allocated for UE Setup response
10133  *
10134  * @details
10135  *
10136  *    Function : FreeUeContextSetupRsp
10137  *
10138  *    Functionality:
10139  *       Free the memory allocated for UE Setup response
10140  *
10141  * @params[in] F1AP PDU for UE setup response
10142  * @return ROK     - success
10143  *         RFAILED - failure
10144  *
10145  * ****************************************************************/
10146 void FreeUeContextSetupRsp(F1AP_PDU_t *f1apMsg)
10147 {
10148    uint8_t idx;
10149    UEContextSetupResponse_t *ueSetRsp = NULLP;
10150
10151    if(f1apMsg)
10152    {
10153       if(f1apMsg->choice.successfulOutcome)
10154       {
10155          ueSetRsp = &f1apMsg->choice.successfulOutcome->value.choice.\
10156                     UEContextSetupResponse;
10157          if(ueSetRsp->protocolIEs.list.array)
10158          {
10159             for(idx = 0; idx < ueSetRsp->protocolIEs.list.count; idx++)
10160             {
10161                if(ueSetRsp->protocolIEs.list.array[idx])
10162                {
10163                   switch(ueSetRsp->protocolIEs.list.array[idx]->id)
10164                   {
10165                      case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
10166                         break;
10167                      case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
10168                         break;
10169                      case ProtocolIE_ID_id_DUtoCURRCInformation:
10170                         {
10171                            CellGroupConfig_t *cellGrpCfg = NULLP;
10172                            cellGrpCfg  = &ueSetRsp->protocolIEs.list.array[idx]->value.choice.\
10173                                          DUtoCURRCInformation.cellGroupConfig;
10174                            if(cellGrpCfg->buf != NULLP)
10175                            {
10176                               DU_FREE(cellGrpCfg->buf, cellGrpCfg->size);
10177                               cellGrpCfg = NULLP;
10178                            }
10179                            break;
10180                         }
10181                     case ProtocolIE_ID_id_DRBs_Setup_List:
10182                         {
10183                            freeDrbSetupList(&ueSetRsp->protocolIEs.list.array[idx]->value.choice.DRBs_Setup_List);
10184                            break;
10185                         }
10186                      default:
10187                         DU_LOG("\nERROR  -->  DUAPP: Invalid Id %ld at FreeUeContextSetupRsp()",\
10188                         ueSetRsp->protocolIEs.list.array[idx]->id);
10189                         break;
10190                   }
10191                   DU_FREE(ueSetRsp->protocolIEs.list.array[idx],\
10192                         sizeof(UEContextSetupResponseIEs_t));
10193                }
10194             }
10195             DU_FREE(ueSetRsp->protocolIEs.list.array, \
10196                   ueSetRsp->protocolIEs.list.size);
10197          }
10198          DU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
10199       }
10200       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
10201    }
10202 }
10203
10204 /*******************************************************************
10205  *
10206  * @brief Builds Ue context Setup Rsp DU To CU Info
10207  *
10208  * @details
10209  *
10210  *    Function : EncodeUeCntxtDuToCuInfo
10211  *
10212  *    Functionality: Builds Ue context Setup Rsp DU To CU Info
10213  *
10214  * @params[in] CellGroupConfig_t *, CellGroupConfigRrc_t *
10215  *
10216  * @return ROK     - success
10217  *         RFAILED - failure
10218  *
10219  ******************************************************************/
10220
10221 uint8_t EncodeUeCntxtDuToCuInfo(CellGroupConfig_t *duToCuCellGrp, CellGroupConfigRrc_t *duCellGrpCfg)
10222 {
10223    asn_enc_rval_t        encRetVal;
10224
10225    xer_fprint(stdout, &asn_DEF_CellGroupConfigRrc, duCellGrpCfg);
10226    memset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
10227    encBufSize = 0;
10228    encRetVal = aper_encode(&asn_DEF_CellGroupConfigRrc, 0, duCellGrpCfg, PrepFinalEncBuf, encBuf);
10229    /* Encode results */
10230    if(encRetVal.encoded == ENCODE_FAIL)
10231    {
10232       DU_LOG( "\nERROR  -->  F1AP : Could not encode UeCntxtDuToCuInfo (at %s)\n",\
10233             encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
10234       return RFAILED;
10235    }
10236    else
10237    {
10238       DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for UeCntxtDuToCuInfo\n");
10239       for(int i=0; i< encBufSize; i++)
10240       {
10241          printf("%x",encBuf[i]);
10242       }
10243    }
10244    duToCuCellGrp->size = encBufSize;
10245    DU_ALLOC(duToCuCellGrp->buf, duToCuCellGrp->size);
10246    if(!duToCuCellGrp->buf)
10247    {
10248       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in UeCntxtDuToCuInfo");
10249    }
10250    memcpy(duToCuCellGrp->buf, encBuf, duToCuCellGrp->size);
10251    return ROK;
10252 }
10253
10254 /*******************************************************************
10255  *
10256  * @brief Fills Dl Gtp tunnel Info
10257  *
10258  * @details
10259  *
10260  *    Function : fillGtpTunnelforDl
10261  *
10262  *    Functionality: Fills Dl Gtp tunnel Info
10263  *
10264  * @params[in]
10265  *
10266  * @return ROK     - success
10267  *         RFAILED - failure
10268  *
10269  * ****************************************************************/
10270
10271 uint8_t fillGtpTunnelforDl(GTPTunnel_t *gtpDl, GtpTnlCfg *gtpUeCfg)
10272 {
10273    uint8_t bufSize = 0;
10274
10275    gtpDl->transportLayerAddress.size    = 4*sizeof(uint8_t);
10276    DU_ALLOC(gtpDl->transportLayerAddress.buf, gtpDl->transportLayerAddress.size);
10277    if(gtpDl->transportLayerAddress.buf == NULLP)
10278    {
10279       return RFAILED;
10280    }
10281    memcpy(gtpDl->transportLayerAddress.buf, &gtpUeCfg->dlTnlAddress, gtpDl->transportLayerAddress.size);
10282
10283    /*GTP TEID*/
10284    gtpDl->gTP_TEID.size = 4 * sizeof(uint8_t);
10285    DU_ALLOC(gtpDl->gTP_TEID.buf, gtpDl->gTP_TEID.size);
10286    if(gtpDl->gTP_TEID.buf == NULLP)
10287    {
10288       return RFAILED;
10289    }
10290    bufSize = 3; /*forming an Octect String*/
10291    fillTeIdString(bufSize, gtpUeCfg->teId, gtpDl->gTP_TEID.buf);
10292
10293    return ROK;
10294 }
10295
10296 /*******************************************************************
10297  *
10298  * @brief Fills DL Tunnel Setup List
10299  *
10300  * @details
10301  *
10302  *    Function : fillDlTnlSetupList
10303  *
10304  *    Functionality: Fills the DL Tunnel Setup List
10305  *
10306  * @params[in]
10307  *
10308  * @return ROK     - success
10309  *         RFAILED - failure
10310  *
10311  * ****************************************************************/
10312
10313 uint8_t fillDlTnlSetupList(DLUPTNLInformation_ToBeSetup_List_t *dlTnlInfo, UpTnlCfg *tnlCfg)
10314 {
10315    uint8_t ret = ROK, arrIdx = 0, eleCount = 0;
10316
10317    eleCount = 1;
10318    dlTnlInfo->list.count = eleCount;
10319    dlTnlInfo->list.size = (eleCount * sizeof(DLUPTNLInformation_ToBeSetup_Item_t *));
10320
10321    /* Initialize the DL Tnl Setup List Members */
10322    DU_ALLOC(dlTnlInfo->list.array, dlTnlInfo->list.size);
10323    if(dlTnlInfo->list.array == NULLP)
10324    {
10325       DU_LOG(" ERROR  -->  F1AP : Memory allocation for DL Tnl Setup List in fillDlTnlSetupList()");
10326       ret = RFAILED;
10327    }
10328    for(arrIdx=0; arrIdx < eleCount; arrIdx++)
10329    {
10330       DU_ALLOC(dlTnlInfo->list.array[arrIdx], sizeof(DLUPTNLInformation_ToBeSetup_Item_t));
10331       if(dlTnlInfo->list.array[arrIdx] == NULLP)
10332       {
10333          DU_LOG(" ERROR  -->  F1AP : Memory allocation for arrIdx [%d] failed in fillDlTnlSetupList()", arrIdx);
10334          return RFAILED;
10335       }
10336       dlTnlInfo->list.array[arrIdx]->dLUPTNLInformation.present = UPTransportLayerInformation_PR_gTPTunnel;
10337       DU_ALLOC(dlTnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel, sizeof(GTPTunnel_t));
10338       if(dlTnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel == NULLP)
10339       {
10340          DU_LOG(" ERROR  -->  F1AP : Memory allocation for DL tunnel info in fillDlTnlSetupList()");
10341          return RFAILED;
10342       }
10343       ret = fillGtpTunnelforDl(dlTnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel,\
10344                tnlCfg->tnlCfg1);
10345       if(ret != ROK)
10346          break;
10347    }
10348    return ret;
10349 }
10350
10351 /*******************************************************************
10352  *
10353  * @brief Fills the Drb Setup List for Ue Context Setup Response
10354  *
10355  * @details
10356  *
10357  *    Function : fillDrbSetupList
10358  *
10359  *    Functionality: Fills the Drb Setup List for Ue Context Setup Response
10360  *
10361  * @params[in]
10362  *
10363  * @return ROK     - success
10364  *         RFAILED - failure
10365  *
10366  * ****************************************************************/
10367 uint8_t fillDrbSetupList(DRBs_Setup_List_t *drbSetupList, DuUeCfg *ueCfg)
10368 {
10369    uint8_t ret = ROK, arrIdx = 0, eleCount = 0;
10370    DRBs_Setup_ItemIEs_t *drbItemIe = NULLP;
10371
10372    eleCount = ueCfg->numDrb;
10373    drbSetupList->list.count = eleCount;
10374    drbSetupList->list.size = \
10375         (eleCount * sizeof(DRBs_Setup_Item_t *));
10376
10377    /* Initialize the Drb Setup List Members */
10378    DU_ALLOC(drbSetupList->list.array, drbSetupList->list.size);
10379    if(drbSetupList->list.array == NULLP)
10380    {
10381       DU_LOG(" ERROR  -->  F1AP : Memory allocation for DRB Setup List in fillDrbSetupList()");
10382       ret = RFAILED;
10383    }
10384
10385    for(arrIdx=0; arrIdx < eleCount; arrIdx++)
10386    {
10387       DU_ALLOC(drbSetupList->list.array[arrIdx], sizeof(DRBs_Setup_Item_t));
10388       if(drbSetupList->list.array[arrIdx] == NULLP)
10389       {
10390          DU_LOG(" ERROR  -->  F1AP : Memory allocation for arrIdx [%d] failed in fillDrbSetupList()", arrIdx);
10391          return RFAILED;
10392       }
10393       drbItemIe = ((DRBs_Setup_ItemIEs_t *)drbSetupList->list.array[arrIdx]);
10394       drbItemIe->id = ProtocolIE_ID_id_DRBs_Setup_Item;
10395       drbItemIe->criticality = Criticality_reject;
10396       drbItemIe->value.present = DRBs_Setup_ItemIEs__value_PR_DRBs_Setup_Item;
10397       drbItemIe->value.choice.DRBs_Setup_Item.dRBID = ueCfg->upTnlInfo[arrIdx].drbId;
10398       ret = fillDlTnlSetupList(&drbItemIe->value.choice.DRBs_Setup_Item.dLUPTNLInformation_ToBeSetup_List,\
10399           &ueCfg->upTnlInfo[arrIdx]);
10400       if(ret != ROK)
10401          break;
10402    }
10403    return ret;
10404 }
10405
10406 /*******************************************************************
10407  *
10408  * @brief Builds and sends the UE Setup Response
10409  *
10410  * @details
10411  *
10412  *    Function : BuildAndSendUeContextSetupRsp
10413  *
10414  *    Functionality: Constructs the UE Setup Response and sends
10415  *                   it to the DU through SCTP.
10416  *
10417  * @params[in]
10418  *
10419  * @return ROK     - success
10420  *         RFAILED - failure
10421  *
10422  * ****************************************************************/
10423 uint8_t BuildAndSendUeContextSetupRsp(uint8_t ueIdx, uint8_t cellId)
10424 {
10425    uint8_t   idx, ret, cellIdx, elementCnt;
10426    uint32_t  gnbCuUeF1apId;   /* gNB-CU UE F1AP Id */
10427    uint32_t  gnbDuUeF1apId;   /* gNB-DU UE F1AP Id */
10428    asn_enc_rval_t  encRetVal;        /* Encoder return value */
10429    F1AP_PDU_t               *f1apMsg = NULLP;
10430    UEContextSetupResponse_t *ueSetRsp = NULLP;
10431    CellGroupConfigRrc_t     *cellGrpCfg = NULLP;
10432    DuUeCb                   *ueCb = NULLP;
10433
10434    DU_LOG("\n INFO   -->  F1AP : Building UE Context Setup Response for cellId %d, ueIdx %d\n", cellId, ueIdx);
10435
10436    while(true)
10437    {
10438       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
10439       if(f1apMsg == NULLP)
10440       {
10441          DU_LOG(" ERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
10442          ret = RFAILED;
10443          break;
10444       }
10445
10446       f1apMsg->present = F1AP_PDU_PR_successfulOutcome;
10447       DU_ALLOC(f1apMsg->choice.successfulOutcome,
10448             sizeof(SuccessfulOutcome_t));
10449       if(f1apMsg->choice.successfulOutcome == NULLP)
10450       {
10451          DU_LOG(" ERROR  -->  F1AP : Memory allocation for      F1AP-PDU failed");
10452          ret = RFAILED;
10453          break;
10454       }
10455
10456       f1apMsg->choice.successfulOutcome->procedureCode = \
10457                                                          ProcedureCode_id_UEContextSetup;
10458       f1apMsg->choice.successfulOutcome->criticality = Criticality_reject;
10459       f1apMsg->choice.successfulOutcome->value.present = \
10460                                                          SuccessfulOutcome__value_PR_UEContextSetupResponse;
10461
10462       ueSetRsp =
10463          &f1apMsg->choice.successfulOutcome->value.choice.UEContextSetupResponse;
10464       elementCnt = 4;
10465       ueSetRsp->protocolIEs.list.count = elementCnt;
10466       ueSetRsp->protocolIEs.list.size = \
10467                                         elementCnt * sizeof(UEContextSetupResponse_t *);
10468
10469       /* Initialize the UESetup members */
10470       DU_ALLOC(ueSetRsp->protocolIEs.list.array, \
10471             ueSetRsp->protocolIEs.list.size);
10472       if(ueSetRsp->protocolIEs.list.array == NULLP)
10473       {
10474          DU_LOG(" ERROR  -->  F1AP : Memory allocation for UE Setup Response failed");
10475          ret = RFAILED;
10476          break;
10477       }
10478
10479       for(idx=0; idx<elementCnt; idx++)
10480       {
10481          DU_ALLOC(ueSetRsp->protocolIEs.list.array[idx],\
10482                sizeof(UEContextSetupResponseIEs_t));
10483          if(ueSetRsp->protocolIEs.list.array[idx] == NULLP)
10484          {
10485             DU_LOG(" ERROR  -->  F1AP : Memory allocation for UE Setup Response failed");
10486             ret = RFAILED;
10487             break;
10488          }
10489       }
10490       /* Fetching Ue Cb Info*/
10491       GET_CELL_IDX(cellId, cellIdx);
10492       gnbDuUeF1apId = duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].gnbDuUeF1apId;
10493       gnbCuUeF1apId = duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].gnbCuUeF1apId;
10494       ueCb = &duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1];
10495
10496       idx = 0;
10497       /*GNB CU UE F1AP ID*/
10498       ueSetRsp->protocolIEs.list.array[idx]->id = \
10499                                                   ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
10500       ueSetRsp->protocolIEs.list.array[idx]->criticality = Criticality_reject;
10501       ueSetRsp->protocolIEs.list.array[idx]->value.present = \
10502                                                              UEContextSetupResponseIEs__value_PR_GNB_CU_UE_F1AP_ID;
10503       ueSetRsp->protocolIEs.list.array[idx]->value.choice.GNB_CU_UE_F1AP_ID = gnbCuUeF1apId;
10504
10505       /*GNB DU UE F1AP ID*/
10506       idx++;
10507       ueSetRsp->protocolIEs.list.array[idx]->id = \
10508                                                   ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
10509       ueSetRsp->protocolIEs.list.array[idx]->criticality = Criticality_reject;
10510       ueSetRsp->protocolIEs.list.array[idx]->value.present = \
10511                                                              UEContextSetupResponseIEs__value_PR_GNB_DU_UE_F1AP_ID;
10512       ueSetRsp->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID = gnbDuUeF1apId;
10513
10514
10515       /*DUtoCURRC Information */
10516       idx++;
10517       ueSetRsp->protocolIEs.list.array[idx]->id  = \
10518                                                    ProtocolIE_ID_id_DUtoCURRCInformation;
10519       ueSetRsp->protocolIEs.list.array[idx]->criticality = Criticality_reject;
10520       ueSetRsp->protocolIEs.list.array[idx]->value.present =\
10521                                                             UEContextSetupResponseIEs__value_PR_DUtoCURRCInformation;
10522       if(ueCb->f1UeDb)
10523       {
10524          if(ueCb->f1UeDb->duUeCfg.cellGrpCfg)
10525          {
10526             cellGrpCfg = (CellGroupConfigRrc_t*)ueCb->f1UeDb->duUeCfg.cellGrpCfg;
10527             ret = EncodeUeCntxtDuToCuInfo(&ueSetRsp->protocolIEs.list.array[idx]->value.\
10528                      choice.DUtoCURRCInformation.cellGroupConfig, cellGrpCfg);
10529             if(ret == RFAILED)
10530             {
10531                DU_LOG("\nERROR  -->  F1AP : Failed to EncodeUeCntxtDuToCuInfo in BuildAndSendUeContextSetupRsp()");
10532                freeF1UeDb(ueCb->f1UeDb);
10533                ueCb->f1UeDb = NULLP;
10534                break;
10535             }
10536          }
10537       }
10538       else
10539       {
10540          DU_LOG("\nERROR  -->  F1AP : Failed to form DUtoCU RRCInfo at BuildAndSendUeContextSetupRsp()");
10541          ret = RFAILED;
10542          break;
10543       }
10544
10545       /* Drb Setup List */
10546       idx++;
10547       ueSetRsp->protocolIEs.list.array[idx]->id  = \
10548                                  ProtocolIE_ID_id_DRBs_Setup_List;
10549       ueSetRsp->protocolIEs.list.array[idx]->criticality = Criticality_reject;
10550       ueSetRsp->protocolIEs.list.array[idx]->value.present =\
10551                                  UEContextSetupResponseIEs__value_PR_DRBs_Setup_List;
10552       ret = fillDrbSetupList(&ueSetRsp->protocolIEs.list.array[idx]->value.choice.DRBs_Setup_List,\
10553                &ueCb->f1UeDb->duUeCfg);
10554       if(ret == RFAILED)
10555       {
10556          DU_LOG("\nERROR  -->  F1AP : Failed to fillDrbSetupList in BuildAndSendUeContextSetupRsp()");
10557          freeF1UeDb(ueCb->f1UeDb);
10558          ueCb->f1UeDb = NULLP;
10559          break;
10560       }
10561
10562        /* Free UeContext Db created during Ue context Req */
10563        freeF1UeDb(ueCb->f1UeDb);
10564        ueCb->f1UeDb = NULLP;
10565
10566       /* TODO: To send Drb list */
10567       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
10568
10569       /* Encode the UE context setup response type as APER */
10570       memset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
10571       encBufSize = 0;
10572       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
10573             encBuf);
10574       /* Encode results */
10575       if(encRetVal.encoded == ENCODE_FAIL)
10576       {
10577          DU_LOG( "\nERROR  -->  F1AP : Could not encode UE Context Setup Response structure (at %s)\n",\
10578                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
10579          ret = RFAILED;
10580          break;
10581       }
10582       else
10583       {
10584          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for UE Context Setup Response\n");
10585          for(int i=0; i< encBufSize; i++)
10586          {
10587             printf("%x",encBuf[i]);
10588          }
10589       }
10590
10591       /* Sending  msg  */
10592       if(SendF1APMsg(DU_APP_MEM_REGION,DU_POOL) != ROK)
10593       {
10594          DU_LOG("\nERROR  -->  F1AP : Sending UE Context Setup Response failed");
10595          ret = RFAILED;
10596          break;
10597       }
10598       break;
10599    }
10600    FreeUeContextSetupRsp(f1apMsg);
10601    return ret;
10602 }/* End of BuildAndSendUeContextSetupRsp */
10603 /*******************************************************************
10604 *
10605 * @brief  Build And Send Ue Context Rsp
10606 *
10607 * @details
10608 *
10609 *    Function : BuildAndSendUeCtxtRsp
10610 *
10611 *    Functionality : Build And Send Ue Context Rsp
10612
10613 * @params[in]
10614 * @return sucess = ROK
10615 *         failure = RFAILED
10616 *
10617 * ****************************************************************/
10618 uint8_t BuildAndSendUeCtxtRsp(uint8_t ueIdx, uint8_t cellId)
10619 {
10620    uint8_t cellIdx = 0, actionType = 0;
10621
10622    GET_CELL_IDX(cellId, cellIdx);
10623    actionType = duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].f1UeDb->actionType;
10624
10625    switch(actionType)
10626    {
10627       case UE_CTXT_SETUP:
10628          BuildAndSendUeContextSetupRsp(ueIdx, cellId);
10629          break;
10630       case UE_CTXT_MOD:
10631          BuildAndSendUeContextModResp(ueIdx, cellId);
10632          break;
10633       default:
10634          DU_LOG("ERROR  -->  F1AP: Invalid Action Type %d at BuildAndSendUeCtxtRsp()", actionType);
10635          break;
10636
10637    }
10638    return ROK;
10639 }
10640
10641 /*******************************************************************
10642  *
10643  * @brief deallocating the memory of  F1reset msg
10644  *
10645  * @details
10646  *
10647  *    Function : FreeF1ResetReq
10648  *
10649  *    Functionality :
10650  *         - freeing memory of F1reset request msg
10651  *
10652  * @params[in]
10653  * @return void
10654  *
10655  *
10656  * ****************************************************************/
10657 void FreeF1ResetReq(F1AP_PDU_t *f1apMsg)
10658 {
10659    uint8_t idx =0 ;
10660    Reset_t *f1ResetMsg;
10661
10662    if(f1apMsg)
10663    {
10664       if(f1apMsg->choice.initiatingMessage)
10665       {
10666          f1ResetMsg = &f1apMsg->choice.initiatingMessage->value.choice.Reset;
10667
10668          if(f1ResetMsg->protocolIEs.list.array)
10669          {
10670             for(idx=0 ;idx < f1ResetMsg->protocolIEs.list.count ; idx++)
10671             {
10672                if(f1ResetMsg->protocolIEs.list.array[idx])
10673                {
10674                   DU_FREE(f1ResetMsg->protocolIEs.list.array[idx],sizeof(ResetIEs_t));
10675                }
10676             }
10677             DU_FREE(f1ResetMsg->protocolIEs.list.array,f1ResetMsg->protocolIEs.list.size);
10678          }
10679          DU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
10680       }
10681       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
10682    }
10683 }
10684 /*******************************************************************
10685  *
10686  * @brief Build and Send F1reset request
10687  *
10688  * @details
10689  *
10690  *    Function : BuildAndSendF1ResetReq
10691  *
10692  *    Functionality:
10693  *         - Build and Send F1reset request msg
10694  *
10695  * @params[in]
10696  * @return ROK     - success
10697  *         RFAILED - failure
10698  *
10699  * ****************************************************************/
10700 uint8_t BuildAndSendF1ResetReq()
10701 {
10702    uint8_t          elementCnt=0;
10703    uint8_t          idx=0;
10704    uint8_t          ret= RFAILED;
10705    Reset_t          *f1ResetMsg = NULLP;
10706    F1AP_PDU_t       *f1apMsg = NULLP;
10707    asn_enc_rval_t   encRetVal;
10708    DU_LOG("\nINFO   -->  F1AP : Building F1 Reset request \n");
10709    do
10710    {
10711       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
10712       if(f1apMsg == NULLP)
10713       {
10714          break;
10715       }
10716       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
10717       DU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
10718       if(f1apMsg->choice.initiatingMessage == NULLP)
10719       {
10720          break;
10721       }
10722       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_Reset;
10723       f1apMsg->choice.initiatingMessage->criticality = Criticality_reject;
10724       f1apMsg->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_Reset;
10725
10726       f1ResetMsg = &f1apMsg->choice.initiatingMessage->value.choice.Reset;
10727
10728       elementCnt = 3;
10729       f1ResetMsg->protocolIEs.list.count = elementCnt;
10730       f1ResetMsg->protocolIEs.list.size = elementCnt * sizeof(ResetIEs_t *);
10731
10732       /* Initialize the F1Setup members */
10733       DU_ALLOC(f1ResetMsg->protocolIEs.list.array,f1ResetMsg->protocolIEs.list.size);
10734       if(f1ResetMsg->protocolIEs.list.array == NULLP)
10735       {
10736          break;
10737       }
10738       for(idx=0; idx<elementCnt; idx++)
10739       {
10740          DU_ALLOC(f1ResetMsg->protocolIEs.list.array[idx],sizeof(ResetIEs_t));
10741          if(f1ResetMsg->protocolIEs.list.array[idx] == NULLP)
10742          {
10743             break;
10744          }
10745       }
10746
10747       /*TransactionID*/
10748       idx=0;
10749       f1ResetMsg->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_TransactionID;
10750       f1ResetMsg->protocolIEs.list.array[idx]->criticality = Criticality_reject;
10751       f1ResetMsg->protocolIEs.list.array[idx]->value.present = ResetIEs__value_PR_TransactionID;
10752       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.TransactionID = 1;
10753
10754       /*Cause*/
10755       idx++;
10756       f1ResetMsg->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_Cause;
10757       f1ResetMsg->protocolIEs.list.array[idx]->criticality = Criticality_ignore;
10758       f1ResetMsg->protocolIEs.list.array[idx]->value.present = ResetIEs__value_PR_Cause;
10759       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.Cause.present = Cause_PR_radioNetwork;
10760       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.Cause.choice.radioNetwork = CauseRadioNetwork_action_desirable_for_radio_reasons;
10761
10762       /*Reset Type*/
10763       idx++;
10764       f1ResetMsg->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_ResetType;
10765       f1ResetMsg->protocolIEs.list.array[idx]->criticality = Criticality_reject;
10766       f1ResetMsg->protocolIEs.list.array[idx]->value.present = ResetIEs__value_PR_ResetType;
10767       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.ResetType.present = ResetType_PR_f1_Interface;
10768       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.ResetType.choice.f1_Interface = ResetAll_reset_all;
10769
10770       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
10771
10772       /* Encode the F1SetupRequest type as APER */
10773       memset(encBuf, 0, ENC_BUF_MAX_LEN);
10774       encBufSize = 0;
10775       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
10776             encBuf);
10777
10778       /* Encode results */
10779       if(encRetVal.encoded == ENCODE_FAIL)
10780       {
10781          DU_LOG("\nERROR  -->  F1AP : Could not encode F1Reset structure (at %s)\n",\
10782                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
10783          break;
10784       }
10785       else
10786       {
10787          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for F1Reset\n");
10788          for(idx=0; idx< encBufSize; idx++)
10789          {
10790             printf("%x",encBuf[idx]);
10791          }
10792       }
10793
10794       if(SendF1APMsg(DU_APP_MEM_REGION, DU_POOL) != ROK)
10795       {
10796          DU_LOG("\nERROR  -->  F1AP : Sending F1 Reset request failed");
10797          break;
10798       }
10799
10800       ret = ROK;
10801       break;
10802    }while(true);
10803
10804    FreeF1ResetReq(f1apMsg);
10805    return ret;
10806 }
10807 /*******************************************************************
10808  *
10809  * @brief Build And Send F1ResetAck
10810  *
10811  * @details
10812  *
10813  *    Function : BuildAndSendF1ResetAck
10814  *
10815  *    Functionality:
10816  *         - Build And Send  F1ResetRSP
10817  *
10818  * @return ROK     - success
10819  *         RFAILED - failure
10820  *
10821  * ****************************************************************/
10822 void FreeF1ResetAck(F1AP_PDU_t *f1apMsg)
10823 {
10824    uint8_t idx;
10825    ResetAcknowledge_t *f1ResetAck;
10826
10827    if(f1apMsg)
10828    {
10829       if(f1apMsg->choice.successfulOutcome)
10830       {
10831          f1ResetAck= &f1apMsg->choice.successfulOutcome->value.choice.ResetAcknowledge;
10832
10833          if(f1ResetAck->protocolIEs.list.array)
10834          {
10835             for(idx=0; idx<f1ResetAck->protocolIEs.list.count ; idx++)
10836             {
10837                if(f1ResetAck->protocolIEs.list.array[idx])
10838                {
10839                   DU_FREE(f1ResetAck->protocolIEs.list.array[idx], sizeof(ResetAcknowledgeIEs_t));
10840                }
10841             }
10842             DU_FREE(f1ResetAck->protocolIEs.list.array, f1ResetAck->protocolIEs.list.size );
10843          }
10844          DU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
10845       }
10846       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
10847    }
10848 }
10849
10850 /*******************************************************************
10851  *
10852  * @brief Build And Send F1ResetAck
10853  *
10854  * @details
10855  *
10856  *    Function : BuildAndSendF1ResetAck
10857  *
10858  *    Functionality:
10859  *         - Build And Send  F1ResetRSP
10860  *
10861  *  @params[in]
10862  * @return ROK     - success
10863  *         RFAILED - failure
10864  *
10865  * ****************************************************************/
10866 uint8_t BuildAndSendF1ResetAck()
10867 {
10868    uint8_t                idx = 0;
10869    uint8_t                elementCnt = 0;
10870    uint8_t                ret = RFAILED;
10871    F1AP_PDU_t             *f1apMsg = NULL;
10872    ResetAcknowledge_t     *f1ResetAck = NULLP;
10873    asn_enc_rval_t         encRetVal;
10874    DU_LOG("\nINFO   -->  F1AP : Building F1 Reset Acknowledgment \n");
10875
10876    do{
10877       /* Allocate the memory for F1ResetRequest_t */
10878       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
10879       if(f1apMsg == NULLP)
10880       {
10881          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
10882          break;
10883       }
10884
10885       f1apMsg->present =  F1AP_PDU_PR_successfulOutcome;
10886
10887       DU_ALLOC(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
10888       if(f1apMsg->choice.successfulOutcome == NULLP)
10889       {
10890          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
10891          break;
10892       }
10893       f1apMsg->choice.successfulOutcome->criticality   = Criticality_reject;
10894       f1apMsg->choice.successfulOutcome->value.present = SuccessfulOutcome__value_PR_ResetAcknowledge;
10895       f1ResetAck = &f1apMsg->choice.successfulOutcome->value.choice.ResetAcknowledge;
10896
10897       elementCnt = 1;
10898
10899       f1ResetAck->protocolIEs.list.count = elementCnt;
10900       f1ResetAck->protocolIEs.list.size = elementCnt*sizeof(ResetAcknowledgeIEs_t *);
10901
10902       DU_ALLOC(f1ResetAck->protocolIEs.list.array, f1ResetAck->protocolIEs.list.size );
10903       if(f1ResetAck->protocolIEs.list.array == NULLP)
10904       {
10905          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1ResetAckIEs failed");
10906          break;
10907       }
10908
10909       for(idx=0; idx<elementCnt; idx++)
10910       {
10911          DU_ALLOC(f1ResetAck->protocolIEs.list.array[idx], sizeof(ResetAcknowledgeIEs_t));
10912          if(f1ResetAck->protocolIEs.list.array[idx] == NULLP)
10913          {
10914             break;
10915          }
10916       }
10917       /*TransactionID*/
10918       idx = 0;
10919       f1ResetAck->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_TransactionID;
10920       f1ResetAck->protocolIEs.list.array[idx]->criticality = Criticality_reject;
10921       f1ResetAck->protocolIEs.list.array[idx]->value.present = ResetAcknowledgeIEs__value_PR_TransactionID;
10922       f1ResetAck->protocolIEs.list.array[idx]->value.choice.TransactionID = TRANS_ID;
10923
10924       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
10925
10926       /* Encode the F1SetupRequest type as UPER */
10927       memset(encBuf, 0, ENC_BUF_MAX_LEN);
10928       encBufSize = 0;
10929       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
10930
10931       /* Check encode results */
10932       if(encRetVal.encoded == ENCODE_FAIL)
10933       {
10934          DU_LOG("\nERROR  -->  F1AP : Could not encode F1ResetAck structure (at %s)\n",\
10935                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
10936          break;
10937       }
10938       else
10939       {
10940          DU_LOG("\nDUBUG   -->  F1AP : Created APER encoded buffer for F1ResetAck\n");
10941          for(int i=0; i< encBufSize; i++)
10942          {
10943             printf("%x",encBuf[i]);
10944          }
10945       }
10946       /* Sending msg */
10947       if(SendF1APMsg(DU_APP_MEM_REGION, DU_POOL) != ROK)
10948       {
10949          DU_LOG("\nERROR  -->  F1AP : Sending F1 Reset Acknowledgement failed");
10950          break;
10951       }
10952
10953       ret = ROK;
10954       break;
10955    }while(true);
10956
10957    FreeF1ResetAck(f1apMsg);
10958    return ret;
10959 }
10960 /******************************************************************
10961 *
10962 * @brief free F1 reset msg allocated by aper_decoder
10963 *
10964 * @details
10965 *
10966 *    Function : freeAperDecodeF1ResetMsg
10967 *
10968 *    Functionality: free F1 reset msg allocated by aper_decoder
10969 *
10970 * @params[in] Reset_t *f1ResetMsg
10971 * @return void
10972 *
10973 * ****************************************************************/
10974
10975 void freeAperDecodeF1ResetMsg(Reset_t *f1ResetMsg)
10976 {
10977    uint8_t ieIdx =0;
10978    if(f1ResetMsg->protocolIEs.list.array)
10979    {
10980       for(ieIdx=0 ;ieIdx < f1ResetMsg->protocolIEs.list.count ; ieIdx++)
10981       {
10982          if(f1ResetMsg->protocolIEs.list.array[ieIdx])
10983          {
10984             free(f1ResetMsg->protocolIEs.list.array[ieIdx]);
10985          }
10986       }
10987       free(f1ResetMsg->protocolIEs.list.array);
10988    }
10989 }
10990
10991 /******************************************************************
10992  *
10993  * @brief Processes DL RRC Message Transfer  sent by CU
10994  *
10995  * @details
10996  *
10997  *    Function : procF1ResetReq
10998  *
10999  *    Functionality: Processes DL RRC Message Transfer sent by CU
11000  *
11001  * @params[in] F1AP_PDU_t ASN decoded F1AP message
11002  * @return ROK     - success
11003  *         RFAILED - failure
11004  *
11005  * ****************************************************************/
11006 uint8_t procF1ResetReq(F1AP_PDU_t *f1apMsg)
11007 {
11008    /* we are currently not supporting Ue release. right now we are supporting only init case of fireset */
11009    uint8_t       ieIdx = 0;
11010    uint8_t        ret = ROK;
11011    Reset_t       *f1ResetMsg = NULLP;
11012
11013    DU_LOG("\nINFO   -->  Processing F1 reset request");
11014    f1ResetMsg = &f1apMsg->choice.initiatingMessage->value.choice.Reset;
11015
11016    for(ieIdx=0; ieIdx<f1ResetMsg->protocolIEs.list.count; ieIdx++)
11017    {
11018       switch(f1ResetMsg->protocolIEs.list.array[ieIdx]->id)
11019       {
11020          case ProtocolIE_ID_id_TransactionID:
11021             break;
11022
11023          case ProtocolIE_ID_id_Cause:
11024             break;
11025
11026          case ProtocolIE_ID_id_ResetType:
11027             {
11028                break;
11029             }
11030
11031          default:
11032             break;
11033       }
11034    }
11035    ret = BuildAndSendF1ResetAck();
11036    DU_LOG("\nINFO   -->  UE release is not supported for now");
11037
11038    freeAperDecodeF1ResetMsg(f1ResetMsg);
11039
11040    return ret;
11041 }
11042
11043 /*******************************************************************
11044  *
11045  * @brief free the RRC delivery report
11046  *
11047  * @details
11048  *
11049  *    Function : freeRrcDeliveryReport
11050  *
11051  *    Functionality: free the RRC delivery report
11052  *
11053  * @params[in]
11054  * @return ROK     - success
11055  *         RFAILED - failure
11056  *
11057  * ****************************************************************/
11058 void freeRrcDeliveryReport(F1AP_PDU_t  *f1apMsg )
11059 {
11060    uint8_t idx=0;
11061    RRCDeliveryReport_t *rrcDeliveryReport= NULLP;
11062
11063    if(f1apMsg)
11064    {
11065       if(f1apMsg->choice.initiatingMessage)
11066       {
11067          rrcDeliveryReport = &f1apMsg->choice.initiatingMessage->value.choice.RRCDeliveryReport;
11068          if(rrcDeliveryReport->protocolIEs.list.array)
11069          {
11070             for(idx =0 ;idx <rrcDeliveryReport->protocolIEs.list.count ;
11071                   idx++)
11072             {
11073                if(rrcDeliveryReport->protocolIEs.list.array[idx])
11074                {
11075                   DU_FREE(rrcDeliveryReport->protocolIEs.list.array[idx],
11076                         sizeof(RRCDeliveryReportIEs_t));
11077                }
11078             }
11079             DU_FREE(rrcDeliveryReport->protocolIEs.list.array,
11080                   rrcDeliveryReport->protocolIEs.list.size);
11081          }
11082          DU_FREE(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
11083       }
11084       DU_FREE(f1apMsg,
11085             sizeof(F1AP_PDU_t));
11086    }
11087 }
11088
11089 /*******************************************************************
11090 *
11091 * @brief Builds and sends the RRC delivery report
11092 *
11093 * @details
11094 *
11095 *    Function : BuildAndSendRrcDeliveryReport
11096 *
11097 *    Functionality: Builds and sends the RRC delivery report
11098 *
11099 * @params[in]
11100 *
11101 * @return ROK     - success
11102 *         RFAILED - failure
11103 *
11104 * ****************************************************************/
11105 uint8_t BuildAndSendRrcDeliveryReport(uint32_t gnbCuUeF1apId, \
11106    uint32_t gnbDuUeF1apId, RrcDeliveryReport *rrcDelivery)
11107 {
11108    uint8_t             ret = RFAILED;
11109    uint8_t             idx    = 0;
11110    uint8_t             idx1   = 0;
11111    uint8_t             elementCnt = 0;
11112    F1AP_PDU_t          *f1apMsg = NULLP;
11113    asn_enc_rval_t      encRetVal;
11114    RRCDeliveryReport_t *rrcDeliveryReport= NULLP;
11115
11116    do{
11117
11118       DU_LOG("\nINFO   -->  F1AP : Building RRC delivery Message Transfer Message\n");
11119       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
11120       if(f1apMsg == NULLP)
11121       {
11122          DU_LOG(" ERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
11123          break;
11124       }
11125       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
11126       DU_ALLOC(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
11127       if(f1apMsg->choice.initiatingMessage == NULLP)
11128       {
11129          DU_LOG(" ERROR  -->  F1AP : Memory allocation for  F1AP-PDU  failed");
11130          break;
11131       }
11132       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_RRCDeliveryReport;
11133       f1apMsg->choice.initiatingMessage->criticality   = Criticality_ignore;
11134       f1apMsg->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_RRCDeliveryReport;
11135
11136       rrcDeliveryReport = &f1apMsg->choice.initiatingMessage->value.choice.RRCDeliveryReport;
11137       elementCnt = 4;
11138       rrcDeliveryReport->protocolIEs.list.count = elementCnt;
11139       rrcDeliveryReport->protocolIEs.list.size = elementCnt * sizeof(RRCDeliveryReportIEs_t *);
11140
11141       /* Initialize the F1Setup members */
11142       DU_ALLOC(rrcDeliveryReport->protocolIEs.list.array, rrcDeliveryReport->protocolIEs.list.size);
11143       if(rrcDeliveryReport->protocolIEs.list.array == NULLP)
11144       {
11145          DU_LOG(" ERROR  -->  F1AP : Memory allocation for RRC Delivery  failed");
11146          break;
11147       }
11148       for(idx =0 ;idx <elementCnt; idx++)
11149       {
11150          DU_ALLOC(rrcDeliveryReport->protocolIEs.list.array[idx], sizeof(RRCDeliveryReportIEs_t));
11151          if(rrcDeliveryReport->protocolIEs.list.array[idx] == NULLP)
11152          {
11153             break;
11154          }
11155       }
11156
11157       idx1 = 0;
11158
11159       /*GNB CU UE F1AP ID*/
11160       rrcDeliveryReport->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
11161       rrcDeliveryReport->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
11162       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.present = RRCDeliveryReportIEs__value_PR_GNB_CU_UE_F1AP_ID;
11163       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.choice.GNB_CU_UE_F1AP_ID = gnbCuUeF1apId;
11164
11165       /*GNB DU UE F1AP ID*/
11166       idx1++;
11167       rrcDeliveryReport->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
11168       rrcDeliveryReport->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
11169       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.present = RRCDeliveryReportIEs__value_PR_GNB_DU_UE_F1AP_ID;
11170       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.choice.GNB_DU_UE_F1AP_ID = gnbDuUeF1apId;
11171
11172       /*RRC delivery status*/
11173       idx1++;
11174       rrcDeliveryReport->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_RRCDeliveryStatus;
11175       rrcDeliveryReport->protocolIEs.list.array[idx1]->criticality = Criticality_ignore;
11176       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.present = RRCDeliveryReportIEs__value_PR_RRCDeliveryStatus;
11177       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.choice.RRCDeliveryStatus.delivery_status =\
11178       rrcDelivery->rrcDeliveryStatus.deliveryStatus;
11179       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.choice.RRCDeliveryStatus.triggering_message =\
11180       rrcDelivery->rrcDeliveryStatus.triggeringMessage;
11181
11182       /* SRB ID */
11183       idx1++;
11184       rrcDeliveryReport->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_SRBID;
11185       rrcDeliveryReport->protocolIEs.list.array[idx1]->criticality = Criticality_ignore;
11186       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.present = RRCDeliveryReportIEs__value_PR_SRBID;
11187       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.choice.SRBID =  rrcDelivery->srbId;
11188
11189       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
11190
11191       /* Encode the RRC DELIVERY REPORT type as APER */
11192       memset(encBuf, 0, ENC_BUF_MAX_LEN);
11193       encBufSize = 0;
11194       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
11195             encBuf);
11196
11197       /* Encode results */
11198       if(encRetVal.encoded == ENCODE_FAIL)
11199       {
11200          DU_LOG("\nERROR  -->  F1AP : Could not encode RRC Delivery Msg structure (at %s)\n",\
11201                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
11202          break;
11203       }
11204       else
11205       {
11206          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for RRC Delivery Msg \n");
11207          for(idx=0; idx< encBufSize; idx++)
11208          {
11209             printf("%x",encBuf[idx]);
11210          }
11211       }
11212
11213       /* Sending msg */
11214       if(SendF1APMsg(DU_APP_MEM_REGION, DU_POOL) != ROK)
11215       {
11216          DU_LOG("\nERROR  -->  F1AP : Sending RRC delivery  msg request failed");
11217          break;
11218       }
11219       ret = ROK;
11220       break;
11221
11222    }while(true);
11223
11224    freeRrcDeliveryReport(f1apMsg);
11225    return ret;
11226 }
11227
11228 /*******************************************************************
11229  *
11230  * @brief Processes cells to be activated
11231  *
11232  * @details
11233  *
11234  *    Function : extractCellsToBeActivated
11235  *
11236  *    Functionality:
11237  *      - Processes cells to be activated list received in F1SetupRsp
11238  *
11239  * @params[in] void
11240  * @return ROK     - success
11241  *         RFAILED - failure
11242  *
11243  * ****************************************************************/
11244
11245 uint8_t extractCellsToBeActivated(Cells_to_be_Activated_List_t cellsToActivate)
11246 {
11247    uint8_t  ret = ROK;
11248    uint16_t idx, nci, pci = 0;
11249    Cells_to_be_Activated_List_Item_t cell;
11250
11251    for(idx=0; idx<cellsToActivate.list.count; idx++)
11252    {
11253       nci = 0;
11254       cell = cellsToActivate.list.array[idx]->value.choice.Cells_to_be_Activated_List_Item;
11255       bitStringToInt(&cell.nRCGI.nRCellIdentity, &nci);
11256
11257       if(cell.nRPCI)
11258       {
11259          pci = *cell.nRPCI;
11260       }
11261       ret = duProcCellsToBeActivated(cell.nRCGI.pLMN_Identity.buf, nci, pci);
11262    }
11263    return ret;
11264 }
11265 /******************************************************************
11266 *
11267 * @brief Processes F1 Setup Response allocated by aper_decoder
11268 *
11269 * @details
11270 *
11271 *    Function : freeF1SetupRsp
11272 *
11273 *    Functionality: free F1 Setup Response allocated by aper_decoder
11274 *
11275 * @params[in] F1SetupResponse_t *f1SetRspMsg
11276 * @return void
11277 *
11278 * ****************************************************************/
11279
11280 void freeAperDecodeF1SetupRsp(F1SetupResponse_t *f1SetRspMsg)
11281 {
11282    uint8_t ieIdx =0;
11283    uint8_t arrIdx =0;
11284    Cells_to_be_Activated_List_t *cellToActivate =NULLP;
11285    RRC_Version_t      *rrcVer =NULLP;
11286
11287    if(f1SetRspMsg->protocolIEs.list.array)
11288    {
11289       for(ieIdx=0; ieIdx<f1SetRspMsg->protocolIEs.list.count; ieIdx++)
11290       {
11291          if(f1SetRspMsg->protocolIEs.list.array[ieIdx])
11292          {
11293             switch(f1SetRspMsg->protocolIEs.list.array[ieIdx]->id)
11294             {
11295                case ProtocolIE_ID_id_Cells_to_be_Activated_List:
11296                   {
11297                      cellToActivate =
11298                         &f1SetRspMsg->protocolIEs.list.array[ieIdx]->value.choice.Cells_to_be_Activated_List;
11299                      if(cellToActivate->list.array)
11300                      {
11301                         for(arrIdx=0; arrIdx<cellToActivate->list.count ; arrIdx++)
11302                         {
11303                            if(cellToActivate->list.array[arrIdx])
11304                            {
11305
11306                               if(cellToActivate->list.array[0]->value.choice.Cells_to_be_Activated_List_Item.nRCGI.\
11307                               pLMN_Identity.buf)
11308                               {
11309                                  if(cellToActivate->list.array[0]->value.choice.\
11310                                        Cells_to_be_Activated_List_Item.nRCGI.nRCellIdentity.buf)
11311                                  {
11312                                     free(cellToActivate->list.array[0]->value.choice.\
11313                                           Cells_to_be_Activated_List_Item.nRCGI.nRCellIdentity.buf);
11314                                  }
11315
11316                                  free(cellToActivate->list.array[0]->value.choice.Cells_to_be_Activated_List_Item.\
11317                                        nRCGI.pLMN_Identity.buf);
11318                               }
11319                               free(cellToActivate->list.array[arrIdx]);
11320                            }
11321                         }
11322                         free(cellToActivate->list.array);
11323                      }
11324                      break;
11325                   }
11326                case ProtocolIE_ID_id_TransactionID:
11327                   {
11328                      break;
11329                   }
11330                case ProtocolIE_ID_id_gNB_CU_Name:
11331                   {
11332                      free(f1SetRspMsg->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_Name.buf);
11333                      break;
11334                   }
11335                case ProtocolIE_ID_id_GNB_CU_RRC_Version:
11336                   {
11337                      rrcVer = &f1SetRspMsg->protocolIEs.list.array[ieIdx]->value.choice.RRC_Version;
11338                      if(rrcVer->latest_RRC_Version.buf)
11339                      {
11340                         if(rrcVer->iE_Extensions)
11341                         {
11342                            if(rrcVer->iE_Extensions->list.array)
11343                            {
11344                               if(rrcVer->iE_Extensions->list.array[0])
11345                               {
11346                                  if(rrcVer->iE_Extensions->list.\
11347                                        array[0]->extensionValue.choice.Latest_RRC_Version_Enhanced.buf)
11348                                  {
11349                                     free(rrcVer->iE_Extensions->list.\
11350                                           array[0]->extensionValue.choice.Latest_RRC_Version_Enhanced.buf);
11351                                  }
11352                                  free(rrcVer->iE_Extensions->list.array[0]);
11353                               }
11354                               free(rrcVer->iE_Extensions->list.array);
11355                            }
11356                            free(rrcVer->iE_Extensions);
11357                         }
11358                         free(rrcVer->latest_RRC_Version.buf);
11359                      }
11360                      break;
11361
11362                   }
11363                default:
11364                   {
11365                      DU_LOG("\nERROR  -->  DU_APP : Invalid IE received in F1SetupRsp:%ld",
11366                            f1SetRspMsg->protocolIEs.list.array[ieIdx]->id);
11367                   }
11368             }
11369             free(f1SetRspMsg->protocolIEs.list.array[ieIdx]);
11370          }
11371       }
11372       free(f1SetRspMsg->protocolIEs.list.array);
11373    }
11374 }
11375 /******************************************************************
11376  *
11377  * @brief Processes F1 Setup Response sent by CU
11378  *
11379  * @details
11380  *
11381  *    Function : procF1SetupRsp
11382  *
11383  *    Functionality: Processes F1 Setup Response sent by CU
11384  *
11385  * @params[in] F1AP_PDU_t ASN decoded F1AP message
11386  * @return ROK     - success
11387  *         RFAILED - failure
11388  *
11389  * ****************************************************************/
11390 uint8_t procF1SetupRsp(F1AP_PDU_t *f1apMsg)
11391 {
11392    uint8_t ret = ROK;
11393    uint16_t idx =0;
11394    F1SetupResponse_t *f1SetRspMsg = NULLP;
11395    GNB_CU_Name_t     *cuName = NULLP;
11396    F1SetupRsp  f1SetRspDb;
11397    RRC_Version_t      *rrcVer =NULLP;
11398
11399    memset(&f1SetRspDb, 0, sizeof(F1SetupRsp));
11400
11401    DU_LOG("\nINFO   -->  F1AP : F1 Setup Response received");
11402    f1SetRspMsg = &f1apMsg->choice.successfulOutcome->value.choice.F1SetupResponse;
11403
11404    for(idx=0; idx<f1SetRspMsg->protocolIEs.list.count; idx++)
11405    {
11406       switch(f1SetRspMsg->protocolIEs.list.array[idx]->id)
11407       {
11408          case ProtocolIE_ID_id_Cells_to_be_Activated_List:
11409             {
11410                extractCellsToBeActivated(f1SetRspMsg->protocolIEs.list.array[idx]->\
11411                      value.choice.Cells_to_be_Activated_List);
11412                break;
11413             }
11414          case ProtocolIE_ID_id_TransactionID:
11415             {
11416                f1SetRspDb.transId = f1SetRspMsg->protocolIEs.list.array[idx]->\
11417                                     value.choice.TransactionID;
11418                break;
11419             }
11420          case ProtocolIE_ID_id_gNB_CU_Name:
11421             {
11422                cuName = &f1SetRspMsg->protocolIEs.list.array[idx]->\
11423                         value.choice.GNB_CU_Name;
11424                strcpy(f1SetRspDb.cuName, (const char*)cuName->buf);
11425                break;
11426             }
11427          case ProtocolIE_ID_id_GNB_CU_RRC_Version:
11428             {
11429                rrcVer = &f1SetRspMsg->protocolIEs.list.array[idx]->value.choice.RRC_Version;
11430                strcpy(f1SetRspDb.rrcVersion.rrcVer,
11431                      (const char*)rrcVer->latest_RRC_Version.buf);
11432                break;
11433             }
11434          default:
11435             DU_LOG("\nERROR  -->  DU_APP : Invalid IE received in F1SetupRsp:%ld",
11436                   f1SetRspMsg->protocolIEs.list.array[idx]->id);
11437       }
11438       duProcF1SetupRsp();
11439    }
11440
11441    freeAperDecodeF1SetupRsp(f1SetRspMsg);
11442    return ret;
11443 }
11444 /*******************************************************************
11445 *
11446 * @brief free GNB DU config update ack
11447 *
11448 * @details
11449 *
11450 *    Function : freeAperDecodeGnbDuAck
11451 *
11452 *    Functionality: Processes GNB DU config update ack And
11453 *                     added free part for the memory allocated by aper_decoder
11454 *
11455 * @params[in] F1AP_PDU_t ASN decoded F1AP message
11456 * @return ROK     - success
11457 *         RFAILED - failure
11458 *
11459 * ****************************************************************/
11460
11461 void freeAperDecodeGnbDuAck(GNBDUConfigurationUpdateAcknowledge_t *gnbDuAck)
11462 {
11463    uint8_t ieIdx = 0;
11464
11465    if(gnbDuAck->protocolIEs.list.array)
11466    {
11467       for(ieIdx=0; ieIdx < gnbDuAck->protocolIEs.list.count; ieIdx++)
11468       {
11469          if(gnbDuAck->protocolIEs.list.array[ieIdx])
11470          {
11471             free(gnbDuAck->protocolIEs.list.array[ieIdx]);
11472          }
11473       }
11474       free(gnbDuAck->protocolIEs.list.array);
11475    }
11476 }
11477 /*******************************************************************
11478 *
11479 * @brief Processes GNB DU config update ack
11480 *
11481 * @details
11482 *
11483 *    Function : procF1GNBDUCfgUpdAck
11484 *
11485 *    Functionality: added free part for the memory allocated by aper_decoder
11486 *
11487 * @params[in] F1AP_PDU_t *f1apMsg
11488 * @return void
11489 *
11490 * ****************************************************************/
11491 uint8_t procF1GNBDUCfgUpdAck(F1AP_PDU_t *f1apMsg)
11492 {
11493    uint8_t ieIdx;
11494    GNBDUConfigurationUpdateAcknowledge_t *gnbDuAck = NULLP;
11495
11496    DU_LOG("\nINFO   -->  F1AP : GNB-DU config update acknowledgment");
11497    gnbDuAck = &f1apMsg->choice.successfulOutcome->value.choice.GNBDUConfigurationUpdateAcknowledge;
11498
11499    for(ieIdx=0; ieIdx < gnbDuAck->protocolIEs.list.count; ieIdx++)
11500    {
11501       switch(gnbDuAck->protocolIEs.list.array[ieIdx]->id)
11502       {
11503          case ProtocolIE_ID_id_TransactionID:
11504             break;
11505          case ProtocolIE_ID_id_Cells_to_be_Activated_List:
11506             break;
11507          default :
11508             DU_LOG("\nERROR  -->  F1AP: Invalid IE Received: %ld, at procF1GNBDUCfgUpdAck()", \
11509             gnbDuAck->protocolIEs.list.array[ieIdx]->id);
11510             break;
11511       }
11512    }
11513    duProcGnbDuCfgUpdAckMsg();
11514 #if 0
11515    if(BuildAndSendF1ResetReq() != ROK)
11516    {
11517       return RFAILED;
11518    }
11519 #endif
11520
11521    freeAperDecodeGnbDuAck(gnbDuAck);
11522    return ROK;
11523 }
11524 /******************************************************************
11525 *
11526 * @brief free DL RRC Message Transfer allocated by aper_decoder
11527 *
11528 * @details
11529 *
11530 *    Function : freeAperDecodef1DlRrcMsg
11531 *
11532 *    Functionality: free DL RRC Message Transfer allocated by aper_decoder
11533 *
11534 * @params[in] DLRRCMessageTransfer_t *f1DlRrcMsg
11535 * @return ROK     - success
11536 *         RFAILED - failure
11537 *
11538 * ****************************************************************/
11539
11540 void freeAperDecodef1DlRrcMsg(DLRRCMessageTransfer_t *f1DlRrcMsg)
11541 {
11542    uint8_t ieIdx =0;
11543    RRCContainer_t *rrcContainer = NULLP;
11544
11545    if(f1DlRrcMsg->protocolIEs.list.array)
11546    {
11547       for(ieIdx=0; ieIdx<f1DlRrcMsg->protocolIEs.list.count; ieIdx++)
11548       {
11549          if(f1DlRrcMsg->protocolIEs.list.array[ieIdx])
11550          {
11551             switch(f1DlRrcMsg->protocolIEs.list.array[ieIdx]->id)
11552             {
11553                case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
11554                   break;
11555                case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
11556                   break;
11557                case ProtocolIE_ID_id_SRBID:
11558                   break;
11559                case ProtocolIE_ID_id_RRCContainer:
11560                   {
11561                      rrcContainer =&f1DlRrcMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer;
11562                      free(rrcContainer->buf);
11563                   }
11564                case ProtocolIE_ID_id_ExecuteDuplication:
11565                   break;
11566                case ProtocolIE_ID_id_RRCDeliveryStatusRequest:
11567                   break;
11568                   break;
11569             }
11570             free(f1DlRrcMsg->protocolIEs.list.array[ieIdx]);
11571          }
11572       }
11573       free(f1DlRrcMsg->protocolIEs.list.array);
11574    }
11575 }
11576 /******************************************************************
11577  *
11578  * @brief Processes DL RRC Message Transfer  sent by CU
11579  *
11580  * @details
11581  *
11582  *    Function : procF1DlRrcMsgTrans
11583  *
11584  *    Functionality: Processes DL RRC Message Transfer sent by CU
11585  *
11586  * @params[in] F1AP_PDU_t ASN decoded F1AP message
11587  * @return ROK     - success
11588  *         RFAILED - failure
11589  *
11590  * ****************************************************************/
11591 uint8_t procF1DlRrcMsgTrans(F1AP_PDU_t *f1apMsg)
11592 {
11593    uint8_t  idx, ret;
11594    DLRRCMessageTransfer_t *f1DlRrcMsg = NULLP;
11595    F1DlRrcMsg dlMsg;
11596    memset(&dlMsg, 0, sizeof(F1DlRrcMsg));
11597
11598    DU_LOG("\nINFO   -->  DU_APP : DL RRC message transfer Recevied");
11599    f1DlRrcMsg = &f1apMsg->choice.initiatingMessage->value.choice.DLRRCMessageTransfer;
11600
11601    ret = ROK;
11602
11603    for(idx=0; idx<f1DlRrcMsg->protocolIEs.list.count; idx++)
11604    {
11605       switch(f1DlRrcMsg->protocolIEs.list.array[idx]->id)
11606       {
11607          case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
11608             {
11609                dlMsg.gnbCuUeF1apId = f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.GNB_CU_UE_F1AP_ID;
11610                break;
11611             }
11612          case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
11613             {
11614                dlMsg.gnbDuUeF1apId = f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID;
11615                break;
11616             }
11617          case ProtocolIE_ID_id_SRBID:
11618             {
11619                dlMsg.srbId = f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.SRBID;
11620                break;
11621             }
11622          case ProtocolIE_ID_id_ExecuteDuplication:
11623             dlMsg.execDup = true;
11624             break;
11625
11626          case ProtocolIE_ID_id_RRCContainer:
11627             {
11628                if(f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.size > 0)
11629                {
11630                   dlMsg.rrcMsgSize = f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.size;
11631                   DU_ALLOC(dlMsg.rrcMsgPdu, dlMsg.rrcMsgSize);
11632                   if(dlMsg.rrcMsgPdu)
11633                   {
11634                      memcpy(dlMsg.rrcMsgPdu, f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.buf,\
11635                         dlMsg.rrcMsgSize);
11636                   }
11637                   else
11638                   {
11639                      DU_LOG("\nERROR  -->  DU APP : Memory alloc Failed at RRC Container at procF1DlRrcMsgTrans()");
11640                      return RFAILED;
11641                   }
11642                }
11643                else
11644                {
11645                   DU_LOG("\nERROR  -->  DU_APP : RRC Container Size is invalid:%ld",\
11646                   f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.size);
11647                   return RFAILED;
11648                }
11649                break;
11650             }
11651          case ProtocolIE_ID_id_RRCDeliveryStatusRequest:
11652             {
11653                dlMsg.deliveryStatRpt = true;
11654                break;
11655             }
11656          default:
11657             DU_LOG("\nERROR  -->  DU_APP : Invalid IE received in DL RRC Msg Transfer:%ld",
11658                   f1DlRrcMsg->protocolIEs.list.array[idx]->id);
11659       }
11660    }
11661
11662    ret = duProcDlRrcMsg(&dlMsg);
11663
11664    freeAperDecodef1DlRrcMsg(f1DlRrcMsg);
11665    return ret;
11666 }
11667 /*******************************************************************
11668  *
11669 * @brief Builds the DRB to be Setup Mod list
11670 *
11671 * @details
11672 *
11673 *    Function :
11674 *
11675 *    Functionality: Constructs the DRB to be Setup Mod list
11676 *
11677 * @params[in] DRBs_SetupMod_List_t *drbSet
11678 *
11679 * @return ROK     - success
11680 *         RFAILED - failure
11681 *
11682 * ****************************************************************/
11683
11684 uint8_t BuildDrbSetupModList(DRBs_SetupMod_List_t *drbSet , DuUeCfg *ueCfg)
11685 {
11686    uint8_t arrIdx =0;
11687    uint8_t drbCnt =0;
11688    struct DRBs_SetupMod_ItemIEs *drbItemIe;
11689
11690    drbCnt = 1;
11691    drbSet->list.count = drbCnt;
11692    drbSet->list.size = drbCnt * sizeof(DRBs_SetupMod_ItemIEs_t *);
11693    DU_ALLOC(drbSet->list.array, drbSet->list.size);
11694    if(drbSet->list.array == NULLP)
11695    {
11696       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDrbToBeSetupModList");
11697       return  RFAILED;
11698    }
11699    for(arrIdx=0; arrIdx<drbCnt; arrIdx++)
11700    {
11701       DU_ALLOC(drbSet->list.array[arrIdx], sizeof(DRBs_SetupMod_ItemIEs_t));
11702       if(drbSet->list.array[arrIdx] == NULLP)
11703       {
11704               DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDrbToBeSetupModList");
11705               return  RFAILED;
11706       }
11707
11708       drbItemIe = (struct DRBs_SetupMod_ItemIEs *)drbSet->list.array[arrIdx];
11709       drbItemIe->id = ProtocolIE_ID_id_DRBs_SetupMod_Item;
11710       drbItemIe->criticality = Criticality_reject;
11711       drbItemIe->value.present = DRBs_SetupMod_ItemIEs__value_PR_DRBs_SetupMod_Item;
11712       drbItemIe->value.choice.DRBs_SetupMod_Item.dRBID = ueCfg->upTnlInfo[arrIdx].drbId;
11713       if(fillDlTnlSetupList(&drbItemIe->value.choice.DRBs_SetupMod_Item.dLUPTNLInformation_ToBeSetup_List,\
11714       &ueCfg->upTnlInfo[arrIdx])!= ROK)
11715       {
11716          DU_LOG("\nERROR  -->  F1AP : Failed to fill DlTnl SetupList in BuildDrbToBeSetupModList");
11717          return RFAILED;
11718       }
11719
11720    }
11721
11722    return ROK;
11723 }
11724 /*******************************************************************
11725 * @brief Free the memory allocated for DRB setup List
11726 *
11727 * @details
11728 *
11729 *    Function : FreeDrbSetupModList
11730 *
11731 *    Functionality:
11732 *       Free the memory allocated for DRB setup list
11733 *
11734 * @params[in] DRBs_Setup_List_t *
11735 * @return void
11736 *
11737 * ****************************************************************/
11738 void FreeDrbSetupModList(DRBs_SetupMod_List_t *drbSetupList)
11739 {
11740    uint8_t arrIdx = 0;
11741    DRBs_SetupMod_ItemIEs_t *drbItemIe = NULLP;
11742
11743    for(arrIdx = 0; arrIdx < drbSetupList->list.count; arrIdx++)
11744    {
11745       drbItemIe = ((DRBs_SetupMod_ItemIEs_t *)drbSetupList->list.array[arrIdx]);
11746       freeDlTnlInfo(&drbItemIe->value.choice.DRBs_SetupMod_Item.dLUPTNLInformation_ToBeSetup_List);
11747    }
11748 }
11749 /*******************************************************************
11750 * @brief Free the memory allocated for UE Context Mod Response
11751 *
11752 * @details
11753 *
11754 *    Function : FreeUeContextModResp
11755 *
11756 *    Functionality:
11757 *       Free the memory allocated for UE Context Mod Response
11758 *
11759 * @params[in] F1AP_PDU_t *f1apMsg
11760 * @return void
11761 *
11762 * ****************************************************************/
11763
11764 void FreeUeContextModResp(F1AP_PDU_t *f1apMsg)
11765 {
11766    uint8_t ieIdx;
11767    UEContextModificationResponse_t *ueContextModifyRes = NULLP;
11768    if(f1apMsg)
11769    {
11770       if(f1apMsg->choice.successfulOutcome)
11771       {
11772          ueContextModifyRes =&f1apMsg->choice.successfulOutcome->value.choice.UEContextModificationResponse;
11773          if(ueContextModifyRes->protocolIEs.list.array)
11774          {
11775             for(ieIdx=0 ; ieIdx<ueContextModifyRes->protocolIEs.list.count; ieIdx++)
11776             {
11777                if(ueContextModifyRes->protocolIEs.list.array[ieIdx])
11778                {
11779                   switch(ueContextModifyRes->protocolIEs.list.array[ieIdx]->id)
11780                   {
11781                      case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
11782                         break;
11783                      case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
11784                         break;
11785                      case ProtocolIE_ID_id_DRBs_SetupMod_List:
11786                         {
11787                             FreeDrbSetupModList(&(ueContextModifyRes->protocolIEs.list.array[ieIdx]->\
11788                             value.choice.DRBs_SetupMod_List));
11789                             break;
11790                         }
11791                   }
11792                   DU_FREE(ueContextModifyRes->protocolIEs.list.array[ieIdx], sizeof(UEContextModificationResponse_t));
11793                }
11794
11795             }
11796             DU_FREE(ueContextModifyRes->protocolIEs.list.array, ueContextModifyRes->protocolIEs.list.size);
11797          }
11798          DU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
11799       }
11800       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
11801    }
11802 }
11803
11804 /*****************************************************************i
11805 *
11806 * @brief Creating the ue context modifcation response and sending
11807 *
11808 * @details
11809 *
11810 *    Function : BuildAndSendUeContextModResp
11811 *
11812 *    Functionality:
11813 *         - Creating the ue context modifcation response
11814 *
11815 * @params[in]
11816 * @return ROK     - success
11817 *         RFAILED - failure
11818 *
11819 * ****************************************************************/
11820 uint8_t BuildAndSendUeContextModResp(uint8_t ueIdx, uint8_t cellId)
11821 {
11822    uint8_t   ieIdx = 0;
11823    uint8_t   cellIdx =0;
11824    uint8_t   elementCnt = 0;
11825    uint8_t   ret = RFAILED;
11826    uint32_t  gnbCuUeF1apId;   /* gNB-CU UE F1AP Id */
11827    uint32_t  gnbDuUeF1apId;   /* gNB-DU UE F1AP Id */
11828    F1AP_PDU_t *f1apMsg = NULLP;
11829    asn_enc_rval_t         encRetVal;
11830    UEContextModificationResponse_t *ueContextModifyRes = NULLP;
11831    DuUeCb                   *ueCb = NULLP;
11832
11833    DU_LOG("\nINFO  -->  F1AP : Building Ue context modification response\n");
11834
11835    while(1)
11836    {
11837       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
11838       if(f1apMsg == NULLP)
11839       {
11840          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed Ue context modification");
11841          break;
11842       }
11843
11844       f1apMsg->present =  F1AP_PDU_PR_successfulOutcome;
11845
11846       DU_ALLOC(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
11847       if(f1apMsg->choice.successfulOutcome == NULLP)
11848       {
11849          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed Ue context modification");
11850          break;
11851       }
11852       f1apMsg->choice.successfulOutcome->procedureCode = ProcedureCode_id_UEContextModification;
11853       f1apMsg->choice.successfulOutcome->criticality = Criticality_reject;
11854       f1apMsg->choice.successfulOutcome->value.present = SuccessfulOutcome__value_PR_UEContextModificationResponse;
11855
11856       ueContextModifyRes =&f1apMsg->choice.successfulOutcome->value.choice.UEContextModificationResponse;
11857
11858       elementCnt = 3;
11859       ueContextModifyRes->protocolIEs.list.count = elementCnt;
11860       ueContextModifyRes->protocolIEs.list.size = elementCnt*sizeof(UEContextModificationResponse_t*);
11861
11862       /* Initialize the UE context modification members */
11863       DU_ALLOC(ueContextModifyRes->protocolIEs.list.array, ueContextModifyRes->protocolIEs.list.size);
11864       if(ueContextModifyRes->protocolIEs.list.array == NULLP)
11865       {
11866          DU_LOG("\nERROR  -->  F1AP : Memory allocation for UE context modifcation Request failed");
11867          break;
11868       }
11869
11870       for(ieIdx=0 ; ieIdx<elementCnt; ieIdx++)
11871       {
11872          DU_ALLOC(ueContextModifyRes->protocolIEs.list.array[ieIdx], sizeof(UEContextModificationResponse_t));
11873          if(ueContextModifyRes->protocolIEs.list.array[ieIdx] == NULLP)
11874          {
11875             DU_LOG("\nERROR  -->  F1AP : Memory allocation for UE context modifcation Request failed");
11876             break;
11877          }
11878       }
11879
11880       /* Fetching Ue Cb Info*/
11881       GET_CELL_IDX(cellId, cellIdx);
11882       gnbDuUeF1apId = duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].gnbDuUeF1apId;
11883       gnbCuUeF1apId = duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].gnbCuUeF1apId;
11884       ueCb = &duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1];
11885
11886       ieIdx=0;
11887       ueContextModifyRes->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
11888       ueContextModifyRes->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
11889       ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.present =\
11890       UEContextModificationResponseIEs__value_PR_GNB_CU_UE_F1AP_ID;
11891       ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID = gnbCuUeF1apId;
11892
11893       ieIdx++;
11894       ueContextModifyRes->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
11895       ueContextModifyRes->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
11896       ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.present=\
11897       UEContextModificationResponseIEs__value_PR_GNB_DU_UE_F1AP_ID;
11898       ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID = gnbDuUeF1apId;
11899
11900       ieIdx++;
11901       ueContextModifyRes->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_DRBs_SetupMod_List;
11902       ueContextModifyRes->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
11903       ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.present =\
11904       UEContextModificationResponseIEs__value_PR_DRBs_SetupMod_List;
11905       if(ueCb->f1UeDb)
11906       {
11907          ret = BuildDrbSetupModList(&(ueContextModifyRes->protocolIEs.list.array[ieIdx]->\
11908                   value.choice.DRBs_SetupMod_List) , &ueCb->f1UeDb->duUeCfg);
11909          if(ret != ROK)
11910          {
11911             DU_LOG( "\nERROR  -->  F1AP : Failed to build drb setupmod List ");
11912             break;
11913          }
11914          freeF1UeDb(ueCb->f1UeDb);
11915          ueCb->f1UeDb = NULLP;
11916       }
11917       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
11918
11919       /* Encode the F1SetupRequest type as APER */
11920       memset(encBuf, 0, ENC_BUF_MAX_LEN);
11921       encBufSize = 0;
11922       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,encBuf);
11923
11924       /* Encode results */
11925       if(encRetVal.encoded == ENCODE_FAIL)
11926       {
11927          DU_LOG( "\nERROR  -->  F1AP : Could not encode UE Context Setup Request structure (at %s)\n",\
11928                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
11929          ret = RFAILED;
11930          break;
11931       }
11932       else
11933       {
11934          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for UE Context Modification Response\n");
11935          for(int i=0; i< encBufSize; i++)
11936          {
11937             printf("%x",encBuf[i]);
11938          }
11939       }
11940
11941       /* Sending  msg  */
11942       if(SendF1APMsg(DU_APP_MEM_REGION,DU_POOL) != ROK)
11943       {
11944          DU_LOG("\nERROR  -->  F1AP : Sending UE Context Setup Res Failed");
11945          ret = RFAILED;
11946          break;
11947       }
11948       break;
11949    }
11950    FreeUeContextModResp(f1apMsg);
11951    return ret;
11952
11953 }
11954 /*******************************************************************
11955  *
11956  * @brief Deallocating the memory allocated by the aper decoder
11957  *          for QOSInfo
11958  *
11959  * @details
11960  *
11961  *    Function : freeAperDecodeQosInfo
11962  *
11963  *    Functionality:  Deallocating the memory allocated for QOSInfo
11964  *
11965  * @params[in] QoSFlowLevelQoSParameters_t *drbQos
11966  *
11967  * @return void
11968  *
11969  * ****************************************************************/
11970
11971 void freeAperDecodeQosInfo(QoSFlowLevelQoSParameters_t *drbQos)
11972 {
11973    if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI != NULLP)
11974    {
11975       if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow!=NULLP)
11976       {
11977          if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume!=NULLP)
11978          {
11979             free(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume);
11980          }
11981          free(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow);
11982       }
11983       free(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI);
11984    }
11985 }
11986 /*******************************************************************
11987  *
11988  * @brief Deallocating the memory allocated by the aper decoder
11989  *          for UlTnlInfoforDrb
11990  *
11991  * @details
11992  *
11993  *    Function : freeAperDecodeUlTnlInfoforDrbSetupMod
11994  *
11995  *    Functionality:  Deallocating memory allocated for UlTnlInfoforDrb
11996  *
11997  * @params[in] ULUPTNLInformation_ToBeSetup_List_t *ulInfo
11998  *
11999  * @return void
12000  *
12001  * ****************************************************************/
12002 void freeAperDecodeUlTnlInfoforDrbSetupMod(ULUPTNLInformation_ToBeSetup_List_t *ulInfo)
12003 {
12004    uint8_t arrIdx =0;
12005
12006    if(ulInfo->list.array)
12007    {
12008       for(arrIdx=0; arrIdx<ulInfo->list.count ; arrIdx++)
12009       {
12010          if(ulInfo->list.array[arrIdx])
12011          {
12012             if(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel )
12013             {
12014                if(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf)
12015                {
12016                   if(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf)
12017                   {
12018                      free(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
12019                            gTP_TEID.buf);
12020                   }
12021                   free(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
12022                         transportLayerAddress.buf);
12023                }
12024                free(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel);
12025             }
12026             free(ulInfo->list.array[arrIdx]);
12027          }
12028       }
12029       free(ulInfo->list.array);
12030    }
12031 }
12032 /*******************************************************************
12033  *
12034  * @brief Deallocating the memory allocated by the aper decoder
12035  *          for DrbSetupModItem
12036  *
12037  * @details
12038  *
12039  *    Function : freeAperDecodeDrbSetupModItem
12040  *
12041  *    Functionality:  Deallocating memory allocated for DrbSetupModItem
12042  *
12043  * @params[in] DRBs_ToBeSetupMod_Item_t *drbItem
12044  *
12045  * @return void
12046  *
12047  * ****************************************************************/
12048
12049 void freeAperDecodeDrbSetupModItem(DRBs_ToBeSetupMod_Item_t *drbItem)
12050 {
12051    uint8_t arrIdx =0;
12052    SNSSAI_t *snssai =NULLP;
12053    Flows_Mapped_To_DRB_List_t *flowMap = NULLP;
12054
12055    drbItem->qoSInformation.present = QoSInformation_PR_choice_extension;
12056    switch(drbItem->qoSInformation.present)
12057    {
12058       case QoSInformation_PR_NOTHING:
12059          break;
12060       case QoSInformation_PR_eUTRANQoS:
12061          {
12062             if(drbItem->qoSInformation.choice.eUTRANQoS)
12063             {
12064                free(drbItem->qoSInformation.choice.eUTRANQoS);
12065             }
12066             break;
12067          }
12068       case QoSInformation_PR_choice_extension:
12069          {
12070             if(drbItem->qoSInformation.choice.choice_extension)
12071             {
12072                freeAperDecodeQosInfo(&drbItem->qoSInformation.choice.choice_extension->value.choice.\
12073                      DRB_Information.dRB_QoS);
12074                snssai = &drbItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI;
12075                if(snssai->sST.buf)
12076                {
12077                   free(snssai->sST.buf);
12078                }
12079                if(snssai->sD)
12080                {
12081                   if(snssai->sD->buf)
12082                   {
12083                      free(snssai->sD->buf);
12084                   }
12085                   free(snssai->sD);
12086                }
12087
12088                flowMap = &drbItem->qoSInformation.choice.choice_extension->value.choice.\
12089                          DRB_Information.flows_Mapped_To_DRB_List;
12090                if(flowMap->list.array)
12091                {
12092                   for(arrIdx=0; arrIdx<flowMap->list.count; arrIdx++)
12093                   {
12094                      if(flowMap->list.array[arrIdx] )
12095                      {
12096                         freeAperDecodeQosInfo(&flowMap->list.array[arrIdx]->qoSFlowLevelQoSParameters);
12097                         free(flowMap->list.array[arrIdx]);
12098                      }
12099                   }
12100                   free(flowMap->list.array);
12101                }
12102
12103                free(drbItem->qoSInformation.choice.choice_extension);
12104             }
12105             break;
12106          }
12107
12108    }
12109    freeAperDecodeUlTnlInfoforDrbSetupMod(&drbItem->uLUPTNLInformation_ToBeSetup_List);
12110    if(drbItem->uLConfiguration)
12111    {
12112       free(drbItem->uLConfiguration);
12113    }
12114 }
12115
12116 /*******************************************************************
12117  *
12118  * @brief Deallocating the memory allocated by the aper decoder
12119  *          for DrbToBeSetupModList
12120  *
12121  * @details
12122  *
12123  *    Function : freeAperDecodeDrbToBeSetupModList
12124  *
12125  *    Functionality:  Deallocating memory allocated for DrbToBeSetupModList
12126  *
12127  * @params[in] DRBs_ToBeSetupMod_List_t *drbSet
12128  *
12129  * @return void
12130  *
12131  * ****************************************************************/
12132
12133 void freeAperDecodeDrbToBeSetupModList(DRBs_ToBeSetupMod_List_t *drbSet)
12134 {
12135    uint8_t arrIdx =0;
12136    struct DRBs_ToBeSetupMod_ItemIEs *drbItemIe;
12137
12138    if(drbSet->list.array)
12139    {
12140       for(arrIdx=0; arrIdx<drbSet->list.count ; arrIdx++)
12141       {
12142          if(drbSet->list.array[arrIdx] != NULLP)
12143          {
12144             if(arrIdx == 0)
12145             {
12146                drbItemIe = (DRBs_ToBeSetupMod_ItemIEs_t *)drbSet->list.array[arrIdx];
12147                freeAperDecodeDrbSetupModItem(&(drbItemIe->value.choice.DRBs_ToBeSetupMod_Item));
12148             }
12149             free(drbSet->list.array[arrIdx]);
12150          }
12151       }
12152       free(drbSet->list.array);
12153    }
12154
12155 }
12156 /*******************************************************************
12157  *
12158  * @brief Deallocating the memory allocated by the aper decoder
12159  *          for UeContextModificationReqMsg
12160  *
12161  * @details
12162  *
12163  *    Function : freeAperDecodeUeContextModificationReqMsg
12164  *
12165  *    Functionality:  Deallocating memory allocated for
12166  *                  UeContextModificationReqMsg
12167  *
12168  * @params[in] UEContextModificationRequest_t *UeContextModifyReq
12169  *
12170  * @return void
12171  *
12172  * ****************************************************************/
12173 void freeAperDecodeUeContextModificationReqMsg(UEContextModificationRequest_t *UeContextModifyReq )
12174 {
12175    uint8_t arrIdx, ieId;
12176
12177    if(UeContextModifyReq->protocolIEs.list.array)
12178    {
12179       for( arrIdx = 0 ; arrIdx<UeContextModifyReq->protocolIEs.list.count ; arrIdx++)
12180       {
12181          if(UeContextModifyReq->protocolIEs.list.array[arrIdx])
12182          {
12183             ieId = UeContextModifyReq->protocolIEs.list.array[arrIdx]->id;
12184             switch(ieId)
12185             {
12186                case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
12187                   break;
12188                case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
12189                   break;
12190                case ProtocolIE_ID_id_DRBs_ToBeSetupMod_List:
12191                   {
12192                      freeAperDecodeDrbToBeSetupModList(&UeContextModifyReq->protocolIEs.list.array[arrIdx]->\
12193                            value.choice.DRBs_ToBeSetupMod_List);
12194                      break;
12195                   }
12196             }
12197             free(UeContextModifyReq->protocolIEs.list.array[arrIdx]);
12198          }
12199       }
12200       free(UeContextModifyReq->protocolIEs.list.array);
12201    }
12202 }
12203 /*******************************************************************
12204  *
12205  * @brief processing the F1 UeContextModificationReq
12206  *
12207  * @details
12208  *
12209  *    Function : procF1UeContextModificationReq
12210  *
12211  *    Functionality:  processing the F1 UeContextModificationReq
12212  *
12213  * @params[in] F1AP_PDU_t *f1apMsg
12214  *
12215  * @return
12216  * ****************************************************************/
12217 uint8_t procF1UeContextModificationReq(F1AP_PDU_t *f1apMsg)
12218 {
12219    UEContextModificationRequest_t *ueContextModifyReq = NULLP;
12220    uint8_t  ret = ROK, ieIdx = 0, lcId =0,cellIdx=0, ueIdx=0;
12221    DuUeCb   *duUeCb = NULLP;
12222    DRBs_ToBeSetupMod_List_t *drbSetupModCfg;
12223    uint32_t gnbCuUeF1apId, gnbDuUeF1apId;
12224
12225    ueContextModifyReq = &f1apMsg->choice.initiatingMessage->value.choice.UEContextModificationRequest;
12226    for(ieIdx=0; (ieIdx < ueContextModifyReq->protocolIEs.list.count && ret == ROK); ieIdx++)
12227    {
12228       switch(ueContextModifyReq->protocolIEs.list.array[ieIdx]->id)
12229       {
12230          case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
12231             {
12232                gnbCuUeF1apId = ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID;
12233                break;
12234             }
12235          case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
12236             {
12237                gnbDuUeF1apId = ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID;
12238                break;
12239             }
12240          case ProtocolIE_ID_id_DRBs_ToBeSetupMod_List:
12241             {
12242                for(cellIdx = 0; cellIdx < duCb.numActvCells; cellIdx++)
12243                {
12244                   for(ueIdx = 0; ueIdx < duCb.numUe; ueIdx++)
12245                   {
12246                      if((duCb.actvCellLst[cellIdx]->ueCb[ueIdx].gnbDuUeF1apId == gnbDuUeF1apId)&&\
12247                            (duCb.actvCellLst[cellIdx]->ueCb[ueIdx].gnbCuUeF1apId == gnbCuUeF1apId))
12248                      {
12249
12250                         duUeCb = &duCb.actvCellLst[cellIdx]->ueCb[ueIdx];
12251                         lcId = getDrbLcId(&duUeCb->drbBitMap);
12252                         if(lcId != RFAILED)
12253                         {
12254                            DU_ALLOC(duUeCb->f1UeDb, sizeof(F1UeContextSetupDb));
12255                            if(duUeCb->f1UeDb)
12256                            {
12257                               duUeCb->f1UeDb->actionType = UE_CTXT_MOD;
12258                               drbSetupModCfg = &ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.\
12259                               choice.DRBs_ToBeSetupMod_List;
12260                               if(extractDrbListToSetup(lcId, NULL, drbSetupModCfg ,drbSetupModCfg->list.count, \
12261                               &duUeCb->f1UeDb->duUeCfg))
12262                               {
12263                                  DU_LOG("\nERROR  -->  DU APP : Failed at extractDrbListToSetup()");
12264                                  ret = RFAILED;
12265                               }
12266                            }
12267                         }
12268                      }
12269                      else
12270                      {
12271                         DU_LOG("\nERROR  -->  DU APP : wrong values of gnbCuUeF1apId and gnbDuUeF1apId ");
12272                         ret = RFAILED;
12273                      }
12274                   }
12275                }
12276                break;
12277             }
12278       }
12279    }
12280    if(ret != RFAILED)
12281    {
12282       ret = duProcUeContextModReq(duUeCb);
12283    }
12284    freeAperDecodeUeContextModificationReqMsg(ueContextModifyReq);
12285    return ret;
12286 }
12287 /*****************************************************************i
12288  *
12289  * @brief Handles received F1AP message and sends back response
12290  *
12291  * @details
12292  *
12293  *    Function : F1APMsgHdlr
12294  *
12295  *    Functionality:
12296  *         - Decodes received F1AP control message
12297  *         - Prepares response message, encodes and sends to SCTP
12298  *
12299  * @params[in]
12300  * @return ROK     - success
12301  *         RFAILED - failure
12302  *
12303  * ****************************************************************/
12304 void F1APMsgHdlr(Buffer *mBuf)
12305 {
12306    int i =0;
12307    char *recvBuf =NULLP;
12308    MsgLen copyCnt =0;
12309    MsgLen recvBufLen =0;
12310    F1AP_PDU_t *f1apMsg =NULLP;
12311    asn_dec_rval_t rval; /* Decoder return value */
12312    F1AP_PDU_t f1apasnmsg ;
12313    DU_LOG("\nINFO  -->  F1AP : Received F1AP message buffer");
12314    ODU_PRINT_MSG(mBuf, 0,0);
12315
12316    /* Copy mBuf into char array to decode it */
12317    ODU_GET_MSG_LEN(mBuf, &recvBufLen);
12318    DU_ALLOC(recvBuf, (Size)recvBufLen);
12319
12320    if(recvBuf == NULLP)
12321    {
12322       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed");
12323       return;
12324    }
12325    if(ODU_COPY_MSG_TO_FIX_BUF(mBuf, 0, recvBufLen, (Data *)recvBuf, &copyCnt) != ROK)
12326    {
12327       DU_LOG("\nERROR   -->  F1AP : Failed while copying %d", copyCnt);
12328       return;
12329    }
12330
12331    printf("\nDEBUG   -->  F1AP : Received flat buffer to be decoded : ");
12332    for(i=0; i< recvBufLen; i++)
12333    {
12334       printf("%x",recvBuf[i]);
12335    }
12336
12337    /* Decoding flat buffer into F1AP messsage */
12338    f1apMsg = &f1apasnmsg;
12339    memset(f1apMsg, 0, sizeof(F1AP_PDU_t));
12340
12341    rval = aper_decode(0, &asn_DEF_F1AP_PDU, (void **)&f1apMsg, recvBuf, recvBufLen, 0, 0);
12342    DU_FREE(recvBuf, (Size)recvBufLen);
12343
12344    if(rval.code == RC_FAIL || rval.code == RC_WMORE)
12345    {
12346       DU_LOG("\nERROR  -->  F1AP : ASN decode failed");
12347       return;
12348    }
12349    printf("\n");
12350    xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
12351
12352    switch(f1apMsg->present)
12353    {
12354       case F1AP_PDU_PR_successfulOutcome:
12355          {
12356             switch(f1apMsg->choice.successfulOutcome->value.present)
12357             {
12358                case SuccessfulOutcome__value_PR_ResetAcknowledge:
12359                   {
12360                      DU_LOG("\nINFO   -->  F1AP : F1ResetAcknowledge is received successfully ");
12361                      break;
12362                   }
12363                case SuccessfulOutcome__value_PR_F1SetupResponse:
12364                   {
12365 #ifndef ODU_TEST_STUB
12366                      procF1SetupRsp(f1apMsg);
12367 #endif
12368                      break;
12369                   }
12370
12371                case SuccessfulOutcome__value_PR_GNBDUConfigurationUpdateAcknowledge:
12372                   {
12373                      procF1GNBDUCfgUpdAck(f1apMsg);
12374                      break;
12375                   }
12376
12377                default:
12378                   {
12379                      DU_LOG("\nERROR  -->  F1AP : Invalid type of SuccessfulOutcome__value_PR_ResetAcknowledge [%d]",\
12380                            f1apMsg->choice.successfulOutcome->value.present);
12381                      return;
12382                   }
12383             }/* End of switch(successfulOutcome) */
12384             free(f1apMsg->choice.successfulOutcome);
12385             break;
12386          }
12387       case F1AP_PDU_PR_initiatingMessage:
12388          {
12389             switch(f1apMsg->choice.initiatingMessage->value.present)
12390             {
12391                case InitiatingMessage__value_PR_Reset:
12392                   {
12393                      procF1ResetReq(f1apMsg);
12394                      break;
12395                   }
12396                case InitiatingMessage__value_PR_DLRRCMessageTransfer:
12397                   {
12398                      procF1DlRrcMsgTrans(f1apMsg);
12399                      break;
12400                   }
12401                case InitiatingMessage__value_PR_UEContextSetupRequest:
12402                   {
12403                      procF1UeContextSetupReq(f1apMsg);
12404                      break;
12405                   }
12406                case InitiatingMessage__value_PR_UEContextModificationRequest:
12407                   {
12408                      procF1UeContextModificationReq(f1apMsg);
12409                      break;
12410                   }
12411                default:
12412                   {
12413                      DU_LOG("\nERROR  -->  F1AP : Invalid type of F1AP_PDU_PR_initiatingMessage [%d]",
12414                            f1apMsg->choice.initiatingMessage->value.present);
12415                      return;
12416                   }
12417             }/* End of switch(initiatingMessage) */
12418             free(f1apMsg->choice.initiatingMessage);
12419             break;
12420          }
12421
12422       default:
12423          {
12424             DU_LOG("\nERROR  -->  F1AP : Invalid type of f1apMsg->present [%d]",f1apMsg->present);
12425             return;
12426          }
12427          free(f1apMsg);
12428
12429    }/* End of switch(f1apMsg->present) */
12430
12431 } /* End of F1APMsgHdlr */
12432
12433 /**********************************************************************
12434   End of file
12435  **********************************************************************/