src/cu_stub/cu_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 "OCTET_STRING.h"
  22 #include "BIT_STRING.h"
  23 #include "odu_common_codec.h"
  24 #include "cu_stub_sctp.h"
  25 #include "cu_f1ap_msg_hdl.h"
  26 #include "legtp.h"
  27 /*header files needed for Ue Context Setup */
  28 #include<ProtocolIE-Field.h>
  29 #include "ProtocolExtensionField.h"
  30 #include "ProtocolIE-SingleContainer.h"
  31 #include "F1AP-PDU.h"
  32 #include "ModulationOrder.h"
  33 #include "BandNR.h"
  34 #include "UE-CapabilityRAT-Container.h"
  35 #include "UE-CapabilityRAT-ContainerList.h"
  36 #include "UE-CapabilityRAT-ContainerListRRC.h"
  37 #include "SupportedBandwidth.h"
  38 #include "FeatureSetUplinkPerCC.h"
  39 #include "FeatureSetDownlinkPerCC.h"
  40 #include "FeatureSets.h"
  41 #include "RF-Parameters.h"
  42 #include "UE-NR-Capability.h"
  43 #include "ProtocolExtensionContainer.h"
  44 #include "CellGroupConfigRrc.h"
  45 #include "MAC-CellGroupConfig.h"
  46 #include "SchedulingRequestConfig.h"
  47 #include "SchedulingRequestToAddMod.h"
  48 #include "BSR-Config.h"
  49 #include "TAG-Config.h"
  50 #include "TAG.h"
  51 #include "PHR-Config.h"
  52 #include "RLC-Config.h"
  53 #include "UL-AM-RLC.h"
  54 #include "DL-AM-RLC.h"
  55 #include "LogicalChannelConfig.h"
  56 #include "RLC-BearerConfig.h"
  57 #include "PhysicalCellGroupConfig.h"
  58 #include "SpCellConfig.h"
  59 #include "ServingCellConfig.h"
  60 #include "ControlResourceSet.h"
  61 #include "SearchSpace.h"
  62 #include "PDCCH-Config.h"
  63 #include "PDSCH-TimeDomainResourceAllocation.h"
  64 #include "PDSCH-TimeDomainResourceAllocationList.h"
  65 #include "DMRS-DownlinkConfig.h"
  66 #include "PDSCH-Config.h"
  67 #include "BWP-DownlinkDedicated.h"
  68 #include "PUSCH-TimeDomainResourceAllocation.h"
  69 #include "PUSCH-TimeDomainResourceAllocationList.h"
  70 #include "DMRS-UplinkConfig.h"
  71 #include "PUSCH-Config.h"
  72 #include "SRS-ResourceId.h"
  73 #include "SRS-Resource.h"
  74 #include "SRS-ResourceSet.h"
  75 #include "SRS-Config.h"
  76 #include "PUCCH-Config.h"
  77 #include "BWP-UplinkDedicated.h"
  78 #include "PUSCH-ServingCellConfig.h"
  79 #include "UplinkConfig.h"
  80 #include "PDSCH-ServingCellConfig.h"
  81 #include "EUTRANQoS.h"
  82 #include "GBR-QosInformation.h"
  83 #include "DRBs-ToBeSetupMod-List.h"
  84 #include "DRBs-ToBeSetupMod-Item.h"
  85 #include "DRBs-Setup-Item.h"
  86 #include "DLUPTNLInformation-ToBeSetup-List.h"
  87 #include "DLUPTNLInformation-ToBeSetup-Item.h"
  88 #include "UPTransportLayerInformation.h"
  89 #include "GTPTunnel.h"
  90 #include "QoSInformation.h"
  91
  92 /* MACRO for CUtoDURRCInformation */
  93 #define CELL_GRP_ID 1
  94 #define FREQ_DOM_RSRC_SIZE 6
  95 #define CORESET0_END_PRB   48
  96 #define CORESET1_NUM_PRB   24
  97 #define PDCCH_CTRL_RSRC_SET_ONE_ID  1
  98 #define PDCCH_CTRL_RSRC_SET_ONE_DURATION 2  /* Duration for control resource set id i */
  99 #define PDCCH_CTRL_RSRC_SET_ONE_PRECOD_GRANULARITY 1   /* Precoded granularity */
 100 #define PDCCH_SRCH_SPC_TWO_ID 2
 101 #define NR_PCI 1
 102 #define SCRAMBLING_ID  NR_PCI
 103 #define DMRS_ADDITIONAL_POS  0          /* DMRS Additional poistion */
 104 #define PDCCH_SYMBOL_WITHIN_SLOT 128     /* Symbol within Slot Value */
 105 #define PDCCH_SRCH_SPC_TWO_AGG_LVL1_CANDIDATE 7   /* Num of candidate at aggregation level 1 */
 106 #define PDCCH_SRCH_SPC_TWO_AGG_LVL2_CANDIDATE 7   /* Num of candidate at aggregation level 2 */
 107 #define PDCCH_SRCH_SPC_TWO_AGG_LVL4_CANDIDATE 4   /* Num of candidate at aggregation level 4 */
 108 #define PDCCH_SRCH_SPC_TWO_AGG_LVL8_CANDIDATE 2   /* Num of candidate at aggregation level 8 */
 109 #define PDCCH_SRCH_SPC_TWO_AGG_LVL16_CANDIDATE 1  /* Num of candidate at aggregation level 16 */
 110 #define PDCCH_SRCH_SPC_TWO_UE_SPEC_DCI_FORMAT  0  /* format 0-0 and 1-0 */
 111 #define PDCCH_SERACH_SPACE_DCI_FORMAT 0
 112
 113 /* MACRO Ddefine for PDSCH Configuration */
 114 #define PDSCH_K0  0
 115 #define PDSCH_RES_ALLOC_TYPE       1          /* Resource allocation type */
 116 #define PDSCH_MAX_CODEWORD_SCH_BY_DCI 0       /* Max num of codewords scheduled by DCI */
 117 #define PDSCH_RBG_SIZE   0                    /* 0: config1 */
 118 #define PDSCH_NUM_HARQ_PROC 5
 119 #define PDSCH_MAPPING_TYPE_A 0
 120 #define PDSCH_MAPPING_TYPE_B 1
 121
 122 /* MACRO Define for PUSCH Configuration */
 123 #define PUSCH_K2_CFG1  1
 124 #define PUSCH_K2_CFG2  2
 125
 126 #define PUSCH_MSG3_DELTA_PREAMBLE 0
 127 #define PUSCH_P0_NOMINAL_WITH_GRANT -70
 128 #define PUSCH_TRANSFORM_PRECODER    1      /* 1: Disabled */
 129 #define PUSCH_MAX_MIMO_LAYERS       1
 130 #define PUSCH_PROCESS_TYPE2_ENABLED false
 131 #define PUSCH_MAPPING_TYPE_A        0
 132 #define PUSCH_MAPPING_TYPE_B        1
 133
 134 /* MACRO defines for SRC config */
 135 #define SRS_RSRC_ID  1
 136 #define SRS_RSET_ID  1
 137 #define SRS_COMB_OFFSET_N2   0
 138 #define SRS_CYCLIC_SHIFT_N2  0
 139 #define SRS_FREQ_DOM_POS     0
 140 #define SRS_FREQ_DOM_SHIFT   0
 141 #define C_SRS 0
 142 #define B_SRS 0
 143 #define B_HOP 0
 144 #define SRS_SEQ_ID 0
 145 #define APERIODIC_SRS_RESRC_TRIGGER 1
 146
 147 /* Macro definitions for DUtoCuRrcContainer */
 148 #define CELL_GRP_ID 1
 149 #define SCH_REQ_ID  0
 150 #define SR_PROHIBIT_TMR 5
 151 #define SR_TRANS_MAX 2
 152 #define PERIODIC_BSR_TMR 2
 153 #define RETX_BSR_TMR     5
 154 #define SR_DELAY_TMR     6
 155 #define TAG_ID 0
 156 #define TIME_ALIGNMENT_TMR 7
 157 #define PHR_PERIODIC_TMR 7
 158 #define PHR_PROHIBHIT_TMR 0
 159 #define PHR_PWR_FACTOR_CHANGE 3
 160 #define PHR_MODE_OTHER_CG 0
 161 #define RLC_LCID 1
 162 #define SRB_ID_1 1
 163 #define SN_FIELD_LEN 0
 164 #define T_POLL_RETRANSMIT 8
 165 #define POLL_PDU 0
 166 #define POLL_BYTE 43
 167 #define MAX_RETX_THRESHOLD 5
 168 #define T_REASSEMBLY 8
 169 #define T_STATUS_PROHIBHIT 7
 170 #define MAC_LC_PRIORITY 1
 171 #define PRIORTISIED_BIT_RATE 15
 172 #define BUCKET_SIZE_DURATION 5
 173 #define LC_GRP 0
 174 #define P_NR_FR1 0
 175 #define PDSCH_HARQ_ACK_CODEBOOK 1
 176 #define SERV_CELL_IDX 0
 177 #define RLM_SYNC_OUT_SYNC_THRESHOLD 0
 178 #define ACTIVE_DL_BWP_ID 0
 179 #define ACTIVE_UL_BWP_ID 0
 180 #define SCRAMBLING_ID  NR_PCI
 181 #define DMRS_ADDITIONAL_POS  0          /* DMRS Additional poistion */
 182 #define RES_ALLOC_TYPE       1          /* Resource allocation type */
 183 #define FIVE_QI_VALUE9 9  /*spec 23.501, Table 5.7.4-1*/
 184 #define FIVE_QI_VALUE8 8  /*spec 23.501, Table 5.7.4-1*/
 185 #define PDU_SESSION_ID_1 1
 186 #define PDU_SESSION_ID_2 2
 187 #define INVALID_PDU_SESSION_ID -1
 188
 189 /*******************************************************************
 190  *
 191  * @brief Sends F1 msg over SCTP
 192  *
 193  * @details
 194  *
 195  *    Function : SendF1APMsg
 196  *
 197  *    Functionality: Sends F1 msg over SCTP
 198  *
 199  * @params[in] Region region
 200  *             Pool pool
 201  * @return ROK     - success
 202  *         RFAILED - failure
 203  *
 204  * ****************************************************************/
 205 S16 SendF1APMsg(Region region, Pool pool)
 206 {
 207    Buffer *mBuf = NULLP;
 208
 209    if(ODU_GET_MSG_BUF(region, pool, &mBuf) == ROK)
 210    {
 211       if(ODU_ADD_POST_MSG_MULT((Data *)encBuf, encBufSize, mBuf) == ROK)
 212       {
 213          ODU_PRINT_MSG(mBuf, 0,0);
 214
 215          if(sctpSend(mBuf) != ROK)
 216          {
 217             DU_LOG("\nERROR  -->  F1AP : SCTP Send failed");
 218             ODU_PUT_MSG_BUF(mBuf);
 219             return RFAILED;
 220          }
 221       }
 222       else
 223       {
 224          DU_LOG("\nERROR  -->  F1AP : ODU_ADD_POST_MSG_MULT failed");
 225          ODU_PUT_MSG_BUF(mBuf);
 226          return RFAILED;
 227       }
 228       ODU_PUT_MSG_BUF(mBuf);
 229    }
 230    else
 231    {
 232       DU_LOG("\nERROR  -->  F1AP : Failed to allocate memory");
 233       return RFAILED;
 234    }
 235
 236    return ROK;
 237 } /* SendF1APMsg */
 238
 239 /*******************************************************************
 240  *
 241  * @brief Builds NRCell ID
 242  *
 243  * @details
 244  *
 245  *    Function : BuildNrCellId
 246  *
 247  *    Functionality: Building the NR Cell ID
 248  *
 249  * @params[in] BIT_STRING_t *nrcell
 250  * @return ROK     - success
 251  *         RFAILED - failure
 252  *
 253  * ****************************************************************/
 254
 255 S16 BuildNrCellId(BIT_STRING_t *nrcell)
 256 {
 257    memset(nrcell->buf, 0, nrcell->size);
 258    nrcell->buf[4]   = 16;
 259    nrcell->bits_unused = 4;
 260    nrcell->size = 5 * sizeof(uint8_t);
 261    return ROK;
 262 }
 263
 264 /********************************************************************
 265  *
 266  * @brief Builds and sends the F1SetupResponse
 267  *
 268  * @details
 269  *
 270  *    Function : BuildAndSendF1SetupRsp
 271  *
 272  *    Functionality: Constructs the F1SetupResponse message and sends
 273  *                   it back to the DU through SCTP.
 274  *
 275  * @params[in] void **buf,Buffer to which encoded pattern is written into
 276  * @params[in] int *size,size of buffer
 277  *
 278  * @return ROK     - success
 279  *         RFAILED - failure
 280  *
 281  * ****************************************************************/
 282 S16 BuildAndSendF1SetupRsp()
 283 {
 284    uint8_t    idx,ieIdx;
 285    uint8_t    elementCnt,cellCnt;
 286    F1AP_PDU_t         *f1apMsg = NULL;
 287    F1SetupResponse_t  *f1SetupRsp;
 288    GNB_CU_Name_t      *cuName;
 289    Cells_to_be_Activated_List_t *cellToActivate;
 290    RRC_Version_t      *rrcVer;
 291    asn_enc_rval_t     encRetVal;
 292    DU_LOG("\nINFO  -->  F1AP : Building F1 Setup Response\n");
 293
 294    /* Allocate the memory for F1SetupRequest_t */
 295    CU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
 296    if(f1apMsg == NULLP)
 297    {
 298       DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
 299       return RFAILED;
 300    }
 301    f1apMsg->present =  F1AP_PDU_PR_successfulOutcome;
 302
 303    CU_ALLOC(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 304    if(f1apMsg->choice.successfulOutcome == NULLP)
 305    {
 306       DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
 307       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 308       return RFAILED;
 309    }
 310
 311    f1apMsg->choice.successfulOutcome->procedureCode = ProcedureCode_id_F1Setup;
 312    f1apMsg->choice.successfulOutcome->criticality = Criticality_reject;
 313    f1apMsg->choice.successfulOutcome->value.present = \
 314                                                       SuccessfulOutcome__value_PR_F1SetupResponse;
 315    f1SetupRsp = &f1apMsg->choice.successfulOutcome->value.choice.F1SetupResponse;
 316
 317    elementCnt = 4;
 318    f1SetupRsp->protocolIEs.list.count = elementCnt;
 319    f1SetupRsp->protocolIEs.list.size = elementCnt*sizeof(F1SetupResponseIEs_t *);
 320
 321    CU_ALLOC(f1SetupRsp->protocolIEs.list.array, \
 322          elementCnt * sizeof(F1SetupResponseIEs_t *));
 323    if(f1SetupRsp->protocolIEs.list.array == NULLP)
 324    {
 325       DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1ResponseIEs failed");
 326       CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 327       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 328       return RFAILED;
 329    }
 330
 331    for(idx=0; idx<elementCnt; idx++)
 332    {
 333       CU_ALLOC(f1SetupRsp->protocolIEs.list.array[idx], \
 334             sizeof(F1SetupResponseIEs_t));
 335       if(f1SetupRsp->protocolIEs.list.array[idx] == NULLP)
 336       {
 337          CU_FREE(f1SetupRsp->protocolIEs.list.array,\
 338                elementCnt * sizeof(F1SetupResponseIEs_t *));
 339          CU_FREE(f1apMsg->choice.successfulOutcome, \
 340                sizeof(SuccessfulOutcome_t));
 341          CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 342          return RFAILED;
 343       }
 344    }
 345
 346    /*TransactionID*/
 347    idx = 0;
 348    f1SetupRsp->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_TransactionID;
 349    f1SetupRsp->protocolIEs.list.array[idx]->criticality = Criticality_reject;
 350    f1SetupRsp->protocolIEs.list.array[idx]->value.present = \
 351                                                             F1SetupResponseIEs__value_PR_TransactionID;
 352    f1SetupRsp->protocolIEs.list.array[idx]->value.choice.TransactionID =\
 353                                                                         TRANS_ID;
 354
 355    /*CU Name*/
 356    idx++;
 357    f1SetupRsp->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_gNB_CU_Name;
 358    f1SetupRsp->protocolIEs.list.array[idx]->criticality = Criticality_ignore;
 359    f1SetupRsp->protocolIEs.list.array[idx]->value.present = \
 360                                                             F1SetupResponseIEs__value_PR_GNB_CU_Name;
 361    cuName = &f1SetupRsp->protocolIEs.list.array[idx]->value.choice.GNB_CU_Name;
 362    cuName->size = sizeof(cuCfgParams.cuName);
 363
 364    CU_ALLOC(cuName->buf, sizeof(cuName->size));
 365    if(cuName->buf == NULLP)
 366    {
 367       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
 368       {
 369          CU_FREE(f1SetupRsp->protocolIEs.list.array[ieIdx],\
 370                sizeof(F1SetupResponseIEs_t));
 371       }
 372       CU_FREE(f1SetupRsp->protocolIEs.list.array,\
 373             elementCnt * sizeof(F1SetupResponseIEs_t *));
 374       CU_FREE(f1apMsg->choice.successfulOutcome,\
 375             sizeof(SuccessfulOutcome_t));
 376       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 377       return RFAILED;
 378    }
 379    strcpy((char*)cuName->buf, (char*)cuCfgParams.cuName);
 380
 381    /*Cells to be activated list*/
 382    idx++;
 383    f1SetupRsp->protocolIEs.list.array[idx]->id = \
 384                                                  ProtocolIE_ID_id_Cells_to_be_Activated_List ;
 385    f1SetupRsp->protocolIEs.list.array[idx]->criticality = Criticality_reject;
 386    f1SetupRsp->protocolIEs.list.array[idx]->value.present = \
 387                                                             F1SetupResponseIEs__value_PR_Cells_to_be_Activated_List;
 388    cellToActivate = &f1SetupRsp->protocolIEs.list.array[idx]->value.choice.\
 389                     Cells_to_be_Activated_List;
 390    cellCnt=1;
 391    cellToActivate->list.count = cellCnt;
 392    cellToActivate->list.size = \
 393                                cellCnt*sizeof(struct Cells_to_be_Activated_List_ItemIEs  *);
 394    CU_ALLOC(cellToActivate->list.array,\
 395          sizeof(struct Cells_to_be_Activated_List_ItemIEs  *));
 396    if(cellToActivate->list.array == NULLP)
 397    {
 398       CU_FREE(cuName->buf, sizeof(cuName->size));
 399       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
 400       {
 401          CU_FREE(f1SetupRsp->protocolIEs.list.array[ieIdx],\
 402                sizeof(F1SetupResponseIEs_t));
 403       }
 404       CU_FREE(f1SetupRsp->protocolIEs.list.array,\
 405             elementCnt * sizeof(F1SetupResponseIEs_t *));
 406       CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 407       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 408       return RFAILED;
 409    }
 410    for(ieIdx=0; ieIdx<cellCnt; ieIdx++)
 411    {
 412       CU_ALLOC(cellToActivate->list.array[ieIdx],sizeof(struct Cells_to_be_Activated_List_ItemIEs ));
 413       if(cellToActivate->list.array[ieIdx] == NULLP)
 414       {
 415          CU_FREE(cellToActivate->list.array,\
 416                sizeof(struct Cells_to_be_Activated_List_ItemIEs  *));
 417          CU_FREE(cuName->buf, sizeof(cuName->size));
 418          for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
 419          {
 420             CU_FREE(f1SetupRsp->protocolIEs.list.array[ieIdx], \
 421                   sizeof(F1SetupResponseIEs_t));
 422          }
 423          CU_FREE(f1SetupRsp->protocolIEs.list.array, \
 424                elementCnt * sizeof(F1SetupResponseIEs_t *));
 425          CU_FREE(f1apMsg->choice.successfulOutcome, \
 426                sizeof(SuccessfulOutcome_t));
 427          CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 428          return RFAILED;
 429       }
 430    }
 431    cellToActivate->list.array[0]->id = \
 432                                        ProtocolIE_ID_id_Cells_to_be_Activated_List_Item;
 433    cellToActivate->list.array[0]->criticality = Criticality_ignore;
 434    cellToActivate->list.array[0]->value.present = \
 435                                                   Cells_to_be_Activated_List_ItemIEs__value_PR_Cells_to_be_Activated_List_Item;
 436    cellToActivate->list.array[0]->value.choice.Cells_to_be_Activated_List_Item.\
 437       nRCGI.pLMN_Identity.size = 3*sizeof(uint8_t);
 438    CU_ALLOC(cellToActivate->list.array[0]->\
 439          value.choice.Cells_to_be_Activated_List_Item.nRCGI.pLMN_Identity.buf,\
 440          3*sizeof(uint8_t));
 441    if(cellToActivate->list.array[0]->value.choice.\
 442          Cells_to_be_Activated_List_Item.nRCGI.pLMN_Identity.buf == NULLP)
 443    {
 444
 445       for(ieIdx=0; ieIdx<cellCnt; ieIdx++)
 446       {
 447          CU_FREE(cellToActivate->list.array[ieIdx],\
 448                sizeof(struct Cells_to_be_Activated_List_ItemIEs ));
 449       }
 450
 451       CU_FREE(cellToActivate->list.array,\
 452             sizeof(struct Cells_to_be_Activated_List_ItemIEs  *));
 453       CU_FREE(cuName->buf, sizeof(cuName->size));
 454       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
 455       {
 456          CU_FREE(f1SetupRsp->protocolIEs.list.array[ieIdx], \
 457                sizeof(F1SetupResponseIEs_t));
 458       }
 459       CU_FREE(f1SetupRsp->protocolIEs.list.array, \
 460             elementCnt * sizeof(F1SetupResponseIEs_t *));
 461       CU_FREE(f1apMsg->choice.successfulOutcome, \
 462             sizeof(SuccessfulOutcome_t));
 463       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 464       return RFAILED;
 465    }
 466    buildPlmnId(cuCfgParams.plmn , cellToActivate->list.array[0]->value.choice.\
 467          Cells_to_be_Activated_List_Item.nRCGI.pLMN_Identity.buf);
 468    cellToActivate->list.array[0]->value.choice.Cells_to_be_Activated_List_Item.\
 469       nRCGI.nRCellIdentity.size = 5;
 470    CU_ALLOC(cellToActivate->list.array[0]->value.choice.\
 471          Cells_to_be_Activated_List_Item.nRCGI.nRCellIdentity.buf,\
 472          5*sizeof(uint8_t));
 473    if(cellToActivate->list.array[0]->value.choice.\
 474          Cells_to_be_Activated_List_Item.nRCGI.nRCellIdentity.buf == NULLP)
 475    {
 476       CU_FREE(cellToActivate->list.array[0]->\
 477             value.choice.Cells_to_be_Activated_List_Item.nRCGI.pLMN_Identity.buf,\
 478             3*sizeof(uint8_t));
 479       for(ieIdx=0; ieIdx<cellCnt; ieIdx++)
 480       {
 481          CU_FREE(cellToActivate->list.array[ieIdx],\
 482                sizeof(struct Cells_to_be_Activated_List_ItemIEs ));
 483       }
 484
 485       CU_FREE(cellToActivate->list.array,\
 486             sizeof(struct Cells_to_be_Activated_List_ItemIEs  *));
 487       CU_FREE(cuName->buf, sizeof(cuName->size));
 488       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
 489       {
 490          CU_FREE(f1SetupRsp->protocolIEs.list.array[ieIdx], \
 491                sizeof(F1SetupResponseIEs_t));
 492       }
 493       CU_FREE(f1SetupRsp->protocolIEs.list.array, \
 494             elementCnt * sizeof(F1SetupResponseIEs_t *));
 495       CU_FREE(f1apMsg->choice.successfulOutcome, \
 496             sizeof(SuccessfulOutcome_t));
 497       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 498       return RFAILED;
 499    }
 500    BuildNrCellId(&(cellToActivate->list.array[0]->value.choice.Cells_to_be_Activated_List_Item.nRCGI.nRCellIdentity));
 501    /* RRC Version */
 502    idx++;
 503    f1SetupRsp->protocolIEs.list.array[idx]->id = \
 504                                                  ProtocolIE_ID_id_GNB_CU_RRC_Version;
 505    f1SetupRsp->protocolIEs.list.array[idx]->criticality = Criticality_reject;
 506    f1SetupRsp->protocolIEs.list.array[idx]->value.present = \
 507                                                             F1SetupResponseIEs__value_PR_RRC_Version;
 508    rrcVer = &f1SetupRsp->protocolIEs.list.array[idx]->value.choice.RRC_Version;
 509    rrcVer->latest_RRC_Version.size = RRC_SIZE;
 510
 511    CU_ALLOC(rrcVer->latest_RRC_Version.buf, sizeof(uint8_t));
 512    if(rrcVer->latest_RRC_Version.buf == NULLP)
 513    {
 514       CU_FREE(cuName->buf, sizeof(cuName->size));
 515       for(ieIdx=0; ieIdx<elementCnt; idx++)
 516       {
 517          CU_FREE(f1SetupRsp->protocolIEs.list.array[ieIdx], \
 518                sizeof(F1SetupResponseIEs_t));
 519       }
 520       CU_FREE(f1SetupRsp->protocolIEs.list.array,\
 521             elementCnt * sizeof(F1SetupResponseIEs_t *));
 522       CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 523       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 524       return RFAILED;
 525    }
 526
 527    /* Need to check RRC Version */
 528    rrcVer->latest_RRC_Version.buf[0] = cuCfgParams.rrcVersion.rrcVer;
 529    rrcVer->latest_RRC_Version.bits_unused = 5; //TODO: pick from cuCfgParam. If not present, add it
 530    CU_ALLOC(rrcVer->iE_Extensions,sizeof(ProtocolExtensionContainer_4624P81_t));
 531    if(rrcVer->iE_Extensions == NULLP)
 532    {
 533       CU_FREE(rrcVer->latest_RRC_Version.buf, sizeof(uint8_t));
 534       CU_FREE(cuName->buf, sizeof(cuName->size));
 535       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
 536       {
 537          CU_FREE(f1SetupRsp->protocolIEs.list.array[ieIdx], \
 538                sizeof(F1SetupResponseIEs_t));
 539       }
 540       CU_FREE(f1SetupRsp->protocolIEs.list.array,\
 541             elementCnt * sizeof(F1SetupResponseIEs_t *));
 542       CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 543       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 544       return RFAILED;
 545    }
 546    rrcVer->iE_Extensions->list.count = 1;
 547    rrcVer->iE_Extensions->list.size = sizeof(struct RRC_Version_ExtIEs *);
 548    CU_ALLOC(rrcVer->iE_Extensions->list.array,\
 549          sizeof(struct RRC_Version_ExtIEs *));
 550    if(rrcVer->iE_Extensions->list.array == NULLP)
 551    {
 552       CU_FREE(rrcVer->iE_Extensions,\
 553             sizeof(ProtocolExtensionContainer_4624P81_t));
 554       CU_FREE(rrcVer->latest_RRC_Version.buf, sizeof(uint8_t));
 555       CU_FREE(cuName->buf, sizeof(cuName->size));
 556       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
 557       {
 558          CU_FREE(f1SetupRsp->protocolIEs.list.array[ieIdx], \
 559                sizeof(F1SetupResponseIEs_t));
 560       }
 561       CU_FREE(f1SetupRsp->protocolIEs.list.array,\
 562             elementCnt * sizeof(F1SetupResponseIEs_t *));
 563       CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 564       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 565       return RFAILED;
 566    }
 567    CU_ALLOC(rrcVer->iE_Extensions->list.array[0],\
 568          sizeof(struct RRC_Version_ExtIEs));
 569    if(rrcVer->iE_Extensions->list.array[0] == NULLP)
 570    {
 571       CU_FREE(rrcVer->iE_Extensions->list.array,\
 572             sizeof(struct RRC_Version_ExtIEs *));
 573       CU_FREE(rrcVer->iE_Extensions,\
 574             sizeof(ProtocolExtensionContainer_4624P81_t));
 575       CU_FREE(rrcVer->latest_RRC_Version.buf, sizeof(uint8_t));
 576       CU_FREE(cuName->buf, sizeof(cuName->size));
 577       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
 578       {
 579          CU_FREE(f1SetupRsp->protocolIEs.list.array[ieIdx], \
 580                sizeof(F1SetupResponseIEs_t));
 581       }
 582       CU_FREE(f1SetupRsp->protocolIEs.list.array,\
 583             elementCnt * sizeof(F1SetupResponseIEs_t *));
 584       CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 585       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 586       return RFAILED;
 587    }
 588    rrcVer->iE_Extensions->list.array[0]->id = \
 589                                               ProtocolIE_ID_id_latest_RRC_Version_Enhanced;
 590    rrcVer->iE_Extensions->list.array[0]->criticality = Criticality_reject;
 591    rrcVer->iE_Extensions->list.array[0]->extensionValue.present = \
 592                                                                   RRC_Version_ExtIEs__extensionValue_PR_Latest_RRC_Version_Enhanced;
 593    rrcVer->iE_Extensions->list.array[0]->extensionValue.choice.\
 594       Latest_RRC_Version_Enhanced.size = 3*sizeof(uint8_t);
 595    CU_ALLOC(rrcVer->iE_Extensions->list.\
 596          array[0]->extensionValue.choice.Latest_RRC_Version_Enhanced.buf,\
 597          3*sizeof(uint8_t));
 598    if(rrcVer->iE_Extensions->list.\
 599          array[0]->extensionValue.choice.Latest_RRC_Version_Enhanced.buf == NULLP)
 600    {
 601       CU_FREE(rrcVer->iE_Extensions->list.array[0],\
 602             sizeof(struct RRC_Version_ExtIEs));
 603       CU_FREE(rrcVer->iE_Extensions->list.array,\
 604             sizeof(struct RRC_Version_ExtIEs *));
 605       CU_FREE(rrcVer->iE_Extensions,\
 606             sizeof(ProtocolExtensionContainer_4624P81_t));
 607       CU_FREE(rrcVer->latest_RRC_Version.buf, sizeof(uint8_t));
 608       CU_FREE(cuName->buf, sizeof(cuName->size));
 609       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
 610       {
 611          CU_FREE(f1SetupRsp->protocolIEs.list.array[ieIdx], \
 612                sizeof(F1SetupResponseIEs_t));
 613       }
 614       CU_FREE(f1SetupRsp->protocolIEs.list.array,\
 615             elementCnt * sizeof(F1SetupResponseIEs_t *));
 616       CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 617       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 618       return RFAILED;
 619    }
 620    rrcVer->iE_Extensions->list.array[0]->extensionValue.choice.\
 621       Latest_RRC_Version_Enhanced.buf[0] = 0;
 622    rrcVer->iE_Extensions->list.array[0]->extensionValue.choice.\
 623       Latest_RRC_Version_Enhanced.buf[1] = 5;
 624    rrcVer->iE_Extensions->list.array[0]->extensionValue.choice.\
 625       Latest_RRC_Version_Enhanced.buf[2] = 15;
 626
 627    xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
 628
 629    /* Encode the F1SetupRequest type as UPER */
 630    memset(encBuf, 0, ENC_BUF_MAX_LEN);
 631    encBufSize = 0;
 632    encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
 633
 634    /* Clean up */
 635    CU_FREE(rrcVer->latest_RRC_Version.buf, sizeof(uint8_t));
 636    CU_FREE(cuName->buf, sizeof(cuName->size));
 637    for(idx=0; idx<elementCnt; idx++)
 638    {
 639       CU_FREE(f1SetupRsp->protocolIEs.list.array[idx], sizeof(F1SetupResponseIEs_t));
 640    }
 641    CU_FREE(f1SetupRsp->protocolIEs.list.array, elementCnt * sizeof(F1SetupResponseIEs_t *));
 642    CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 643    CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 644
 645    /* Check encode results */
 646    if(encRetVal.encoded == ENCODE_FAIL)
 647    {
 648       DU_LOG("\nERROR  -->  F1AP : Could not encode F1SetupResponse structure (at %s)\n",\
 649             encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
 650       return RFAILED;
 651    }
 652    else
 653    {
 654       DU_LOG("\nDEBUG  -->  F1AP : Created APER encoded buffer for F1SetupResponse\n");
 655       for(int i=0; i< encBufSize; i++)
 656       {
 657          DU_LOG("%x",encBuf[i]);
 658       }
 659    }
 660
 661    /* Sending msg */
 662    if(SendF1APMsg(CU_APP_MEM_REG, CU_POOL) != ROK)
 663    {
 664       DU_LOG("\nERROR  -->  F1AP : Sending F1 Setup Response failed");
 665       return RFAILED;
 666    }
 667
 668    return ROK;
 669 }/* End of BuildAndSendF1SetupRsp */
 670
 671 /*******************************************************************
 672  *
 673  * @brief Builds and sends the DUUpdateAcknowledge
 674  *
 675  * @details
 676  *
 677  *    Function : BuildAndSendDUUpdateAck
 678  *
 679  *    Functionality: Constructs the DU Update Acknowledge message and sends
 680  *                   it to the DU through SCTP.
 681  *
 682  * @params[in]
 683  *
 684  * @return ROK     - success
 685  *         RFAILED - failure
 686  *
 687  * ****************************************************************/
 688
 689 S16 BuildAndSendDUUpdateAck()
 690 {
 691    uint8_t   idx;
 692    uint8_t   elementCnt;
 693    F1AP_PDU_t *f1apMsg = NULL;
 694    GNBDUConfigurationUpdateAcknowledge_t *gNBDuCfgAck;
 695    asn_enc_rval_t enRetVal; /* Encoder return value */
 696
 697    DU_LOG("\nINFO  -->  F1AP : Building GNB-DU Config Update Ack\n");
 698
 699    /* Allocate the memory for F1SetupRequest_t */
 700    CU_ALLOC(f1apMsg, (Size)sizeof(F1AP_PDU_t));
 701    if(f1apMsg == NULLP)
 702    {
 703       DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
 704       return RFAILED;
 705    }
 706
 707    f1apMsg->present =  F1AP_PDU_PR_successfulOutcome;
 708
 709    CU_ALLOC(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 710    if(f1apMsg->choice.successfulOutcome == NULLP)
 711    {
 712       DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
 713       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 714       return RFAILED;
 715    }
 716
 717    f1apMsg->choice.successfulOutcome->procedureCode = ProcedureCode_id_gNBDUConfigurationUpdate;
 718    f1apMsg->choice.successfulOutcome->criticality = Criticality_reject;
 719    f1apMsg->choice.successfulOutcome->value.present = SuccessfulOutcome__value_PR_GNBDUConfigurationUpdateAcknowledge;
 720    gNBDuCfgAck = &f1apMsg->choice.successfulOutcome->value.choice.GNBDUConfigurationUpdateAcknowledge;
 721
 722    elementCnt = 1;
 723    gNBDuCfgAck->protocolIEs.list.count = elementCnt;
 724    gNBDuCfgAck->protocolIEs.list.size = elementCnt*sizeof(GNBDUConfigurationUpdateAcknowledgeIEs_t);
 725
 726    /* Initialize the F1Setup members */
 727    CU_ALLOC(gNBDuCfgAck->protocolIEs.list.array, elementCnt * sizeof(GNBDUConfigurationUpdateAcknowledgeIEs_t *));
 728    if(gNBDuCfgAck->protocolIEs.list.array == NULLP)
 729    {
 730       DU_LOG("\nERROR  -->  F1AP : Memory allocation for DuUpdateAcknowledgeIEs failed");
 731       CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 732       CU_FREE(f1apMsg,(Size)sizeof(F1AP_PDU_t));
 733       return RFAILED;
 734    }
 735
 736    for(idx=0; idx<elementCnt; idx++)
 737    {
 738       CU_ALLOC(gNBDuCfgAck->protocolIEs.list.array[idx], sizeof(GNBDUConfigurationUpdateAcknowledgeIEs_t));
 739       if(gNBDuCfgAck->protocolIEs.list.array[idx] == NULLP)
 740       {
 741          CU_FREE(gNBDuCfgAck->protocolIEs.list.array, elementCnt * sizeof(GNBDUConfigurationUpdateAcknowledgeIEs_t *));
 742          CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 743          CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 744          return RFAILED;
 745       }
 746    }
 747
 748    /*TransactionID*/
 749    idx = 0;
 750    gNBDuCfgAck->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_TransactionID ;
 751    gNBDuCfgAck->protocolIEs.list.array[idx]->criticality = Criticality_reject;
 752    gNBDuCfgAck->protocolIEs.list.array[idx]->value.present =\
 753    GNBDUConfigurationUpdateAcknowledgeIEs__value_PR_TransactionID;
 754    gNBDuCfgAck->protocolIEs.list.array[idx]->value.choice.TransactionID = TRANS_ID;
 755
 756    xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
 757
 758    /* Encode the F1SetupRequest type as UPER */
 759    memset(encBuf, 0, ENC_BUF_MAX_LEN);
 760    encBufSize = 0;
 761    enRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
 762
 763    /* Clean up */
 764    for(idx=0; idx<elementCnt; idx++)
 765    {
 766       CU_FREE(gNBDuCfgAck->protocolIEs.list.array[idx], sizeof(GNBDUConfigurationUpdateAcknowledgeIEs_t));
 767    }
 768    CU_FREE(gNBDuCfgAck->protocolIEs.list.array, elementCnt * sizeof(GNBDUConfigurationUpdateAcknowledgeIEs_t *));
 769    CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 770    CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 771
 772    /* Checking encode results */
 773    if(enRetVal.encoded == ENCODE_FAIL)
 774    {
 775       DU_LOG("\nERROR  -->  F1AP : Could not encode DUConfigUpdateAcknowledge structure (at %s)",\
 776       enRetVal.failed_type ? enRetVal.failed_type->name : "unknown");
 777       return RFAILED;
 778    }
 779    else
 780    {
 781       DU_LOG("\nDEBUG  -->  F1AP : Created APER encoded buffer for DuConfigUpdateAcknowledge\n");
 782       for(int i=0; i< encBufSize; i++)
 783       {
 784          DU_LOG("%x",encBuf[i]);
 785       }
 786    }
 787
 788    /* Sending msg */
 789    if(SendF1APMsg(CU_APP_MEM_REG, CU_POOL) != ROK)
 790    {
 791       DU_LOG("\nERROR  -->  F1AP : Sending GNB-DU Config Update Ack failed");
 792       return RFAILED;
 793    }
 794
 795    return ROK;
 796
 797 }/* End of BuildAndSendDUUpdateAck*/
 798 /*******************************************************************
 799 *
 800 * @brief deallocating the memory of  F1reset msg
 801 *
 802 * @details
 803 *
 804 *    Function : FreeF1ResetReq
 805 *
 806 *    Functionality :
 807 *         - freeing memory of F1reset request msg
 808 *
 809 * @params[in]
 810 * @return void
 811 *
 812 *
 813 * ****************************************************************/
 814 void FreeF1ResetReq(F1AP_PDU_t *f1apMsg)
 815 {
 816    uint8_t idx = 0;
 817    Reset_t *f1ResetMsg = NULLP;
 818
 819    if(f1apMsg)
 820    {
 821       if(f1apMsg->choice.initiatingMessage)
 822       {
 823          f1ResetMsg = &f1apMsg->choice.initiatingMessage->value.choice.Reset;
 824          if(f1ResetMsg->protocolIEs.list.array)
 825          {
 826             for(idx=0 ;idx < f1ResetMsg->protocolIEs.list.count ; idx++)
 827             {
 828                if(f1ResetMsg->protocolIEs.list.array[idx])
 829                {
 830                   CU_FREE(f1ResetMsg->protocolIEs.list.array[idx],sizeof(ResetIEs_t));
 831                }
 832             }
 833             CU_FREE(f1ResetMsg->protocolIEs.list.array,f1ResetMsg->protocolIEs.list.size);
 834          }
 835          CU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
 836       }
 837       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 838    }
 839 }
 840 /*******************************************************************
 841  *
 842  * @brief build ansld ans send f1reset msg
 843  *
 844  * @details
 845  *
 846  *    Function : BuildAndSendF1ResetReq
 847  *
 848  *    Functionality: build and send f1reset msg
 849  *
 850  * @return ROK     - success
 851  *         RFAILED - failure
 852  *
 853  * ****************************************************************/
 854 uint8_t BuildAndSendF1ResetReq()
 855 {
 856    uint8_t          elementCnt=0;
 857    uint8_t          idx=0;
 858    uint8_t          ret= RFAILED;
 859    Reset_t          *f1ResetMsg = NULLP;
 860    F1AP_PDU_t       *f1apMsg = NULLP;
 861    asn_enc_rval_t   encRetVal;
 862    DU_LOG("\nINFO  -->  F1AP : Building F1 Reset request \n");
 863    do
 864    {
 865       CU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
 866       if(f1apMsg == NULLP)
 867       {
 868          DU_LOG("\nERROR  -->  F1AP : Memory allocation for the BuildAndSendF1ResetReq's F1AP-PDU failed");
 869          break;
 870       }
 871       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
 872       CU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
 873       if(f1apMsg->choice.initiatingMessage == NULLP)
 874       {
 875          DU_LOG("\nERROR  -->  F1AP : Memory allocation for BuildAndSendF1ResetReq failed");
 876          break;
 877       }
 878       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_Reset;
 879       f1apMsg->choice.initiatingMessage->criticality = Criticality_reject;
 880       f1apMsg->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_Reset;
 881
 882       f1ResetMsg = &f1apMsg->choice.initiatingMessage->value.choice.Reset;
 883
 884       elementCnt = 3;
 885       f1ResetMsg->protocolIEs.list.count = elementCnt;
 886       f1ResetMsg->protocolIEs.list.size = elementCnt * sizeof(ResetIEs_t *);
 887
 888       /* Initialize the F1Reset members */
 889       CU_ALLOC(f1ResetMsg->protocolIEs.list.array,f1ResetMsg->protocolIEs.list.size);
 890       if(f1ResetMsg->protocolIEs.list.array == NULLP)
 891       {
 892          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed for BuildAndSendF1ResetReq");
 893          break;
 894       }
 895       for(idx=0; idx<elementCnt; idx++)
 896       {
 897          CU_ALLOC(f1ResetMsg->protocolIEs.list.array[idx],sizeof(ResetIEs_t));
 898          if(f1ResetMsg->protocolIEs.list.array[idx] == NULLP)
 899          {
 900             DU_LOG("\nERROR  -->  F1AP : Memory allocation failed for BuildAndSendF1ResetReq msg array");
 901             break;
 902          }
 903       }
 904
 905       /*TransactionID*/
 906       idx=0;
 907       f1ResetMsg->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_TransactionID;
 908       f1ResetMsg->protocolIEs.list.array[idx]->criticality = Criticality_reject;
 909       f1ResetMsg->protocolIEs.list.array[idx]->value.present = ResetIEs__value_PR_TransactionID;
 910       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.TransactionID = 1;
 911
 912       /*Cause*/
 913       idx++;
 914       f1ResetMsg->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_Cause;
 915       f1ResetMsg->protocolIEs.list.array[idx]->criticality = Criticality_ignore;
 916       f1ResetMsg->protocolIEs.list.array[idx]->value.present = ResetIEs__value_PR_Cause;
 917       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.Cause.present = Cause_PR_radioNetwork;
 918       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.Cause.choice.radioNetwork = CauseRadioNetwork_action_desirable_for_radio_reasons;
 919
 920       /*Reset Type*/
 921       idx++;
 922       f1ResetMsg->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_ResetType;
 923       f1ResetMsg->protocolIEs.list.array[idx]->criticality = Criticality_reject;
 924       f1ResetMsg->protocolIEs.list.array[idx]->value.present = ResetIEs__value_PR_ResetType;
 925       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.ResetType.present = ResetType_PR_f1_Interface;
 926       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.ResetType.choice.f1_Interface = ResetAll_reset_all;
 927
 928       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
 929
 930       /* Encode the F1SetupRequest type as APER */
 931       memset(encBuf, 0, ENC_BUF_MAX_LEN);
 932       encBufSize = 0;
 933       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
 934             encBuf);
 935
 936       /* Encode results */
 937       if(encRetVal.encoded == ENCODE_FAIL)
 938       {
 939          DU_LOG("\nERROR  -->  F1AP : Could not encode F1Reset structure (at %s)\n",\
 940                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
 941          break;
 942       }
 943       else
 944       {
 945          DU_LOG("\nDEBUG  -->  F1AP : Created APER encoded buffer for F1Reset\n");
 946          for(idx=0; idx< encBufSize; idx++)
 947          {
 948             DU_LOG("%x",encBuf[idx]);
 949          }
 950       }
 951
 952       if(SendF1APMsg(CU_APP_MEM_REG, CU_POOL) != ROK)
 953       {
 954          DU_LOG("\nERROR  -->  F1AP : Sending F1 Reset request failed");
 955          break;
 956       }
 957
 958       ret = ROK;
 959       break;
 960    }while(true);
 961
 962    FreeF1ResetReq(f1apMsg);
 963    return ret;
 964 }
 965
 966 /*******************************************************************
 967  *
 968  * @brief Fills Radio Bearer Config
 969  *
 970  * @details
 971  *
 972  *    Function : fillSrbCfg
 973  *
 974  *    Functionality: Fills Radio Bearer Config
 975  *
 976  * @params[in] SRB_ToAddModList *
 977  *
 978  * @return ROK     - success
 979  *         RFAILED - failure
 980  *
 981  * ****************************************************************/
 982 uint8_t fillSrbCfg(uint8_t srbId, SRB_ToAddModList_t *bearerCfg)
 983 {
 984    uint8_t elementCnt;
 985    uint8_t idx, ieId;
 986    if(bearerCfg != NULLP)
 987    {
 988       elementCnt = 1;
 989       bearerCfg->list.count = elementCnt;
 990       bearerCfg->list.size =\
 991                             elementCnt * sizeof(SRB_ToAddMod_t *);
 992       CU_ALLOC(bearerCfg->list.array, bearerCfg->list.size);
 993       if(bearerCfg->list.array != NULLP)
 994       {
 995          for(idx = 0; idx < elementCnt; idx++)
 996          {
 997             CU_ALLOC(bearerCfg->list.array[idx], sizeof(SRB_ToAddMod_t));
 998             if(bearerCfg->list.array[idx] == NULLP)
 999             {
1000                for(ieId = 0; ieId < idx; ieId++)
1001                {
1002                   CU_FREE(bearerCfg->list.array[ieId], sizeof(SRB_ToAddMod_t));
1003                }
1004                CU_FREE(bearerCfg->list.array, bearerCfg->list.size);
1005                return RFAILED;
1006             }
1007          }
1008       }
1009       else
1010       {
1011          return RFAILED;
1012       }
1013       idx = 0;
1014       bearerCfg->list.array[idx]->srb_Identity = srbId;
1015    }
1016    return ROK;
1017 }
1018
1019 /*******************************************************************
1020  *
1021  * @brief Fills Master CellGroup Info
1022  *
1023  * @details
1024  *
1025  *    Function : fillMasterCellGroup
1026  *
1027  *    Functionality: Fills Master Cell Group IE
1028  *
1029  * @params[in] RRCSetup_IEs_t *
1030  *
1031  * @return ROK     - success
1032  *         RFAILED - failure
1033  *
1034  * ****************************************************************/
1035
1036 uint8_t fillMasterCellGroup(uint8_t ueId, OCTET_STRING_t *masterCellGroup)
1037 {
1038    uint8_t ret = ROK;
1039    masterCellGroup->buf = NULLP;
1040    if(ueCb[ueId-1].f1apMsgDb.duToCuContainer.buf)
1041    {
1042       masterCellGroup->size = ueCb[ueId-1].f1apMsgDb.duToCuContainer.size;
1043       CU_ALLOC(masterCellGroup->buf, masterCellGroup->size);
1044       if(masterCellGroup->buf != NULLP)
1045       {
1046          memcpy(masterCellGroup->buf, ueCb[ueId-1].f1apMsgDb.duToCuContainer.buf,\
1047                masterCellGroup->size);
1048       }
1049       else
1050       {
1051          ret = RFAILED;
1052       }
1053    }
1054    else
1055    {
1056       ret =  RFAILED;
1057    }
1058    return ret;
1059 }
1060
1061 /*******************************************************************
1062  *
1063  * @brief Fills RRC setup IE
1064  *
1065  * @details
1066  *
1067  *    Function : fillRRCSetupIE
1068  *
1069  *    Functionality: Fills RRC Setup IE
1070  *
1071  * @params[in] RRCSetup_IEs_t *
1072  *
1073  * @return ROK     - success
1074  *         RFAILED - failure
1075  *
1076  * ****************************************************************/
1077
1078 uint8_t fillRRCSetupIE(uint8_t ueId, RRCSetup_IEs_t *rrcSetupIE)
1079 {
1080    uint8_t ret = ROK;
1081    if(rrcSetupIE)
1082    {
1083       CU_ALLOC(rrcSetupIE->radioBearerConfig.srb_ToAddModList, sizeof(SRB_ToAddModList_t));
1084       if(rrcSetupIE->radioBearerConfig.srb_ToAddModList != NULLP)
1085       {
1086          ret = fillSrbCfg(SRB1, rrcSetupIE->radioBearerConfig.srb_ToAddModList);
1087       }
1088       if(ret == ROK)
1089       {
1090          ret = fillMasterCellGroup(ueId, &rrcSetupIE->masterCellGroup);
1091       }
1092       else
1093       {
1094          CU_FREE(rrcSetupIE->radioBearerConfig.srb_ToAddModList, sizeof(SRB_ToAddModList_t));
1095          ret = RFAILED;
1096       }
1097    }
1098    return ret;
1099 }
1100 /*******************************************************************
1101  *
1102  * @brief Fills DL DCCCH Message required for DLRRCMessageTransfer
1103  *
1104  * @details
1105  *
1106  *    Function : fillDlCcchRrcMsg
1107  *
1108  *    Functionality: Fills DL DCCCH Message required for
1109  *                   DLRRCMessageTransfer
1110  *
1111  * @params[in] RRCContainer_t *rrcContainer
1112  *
1113  * @return ROK     - success
1114  *         RFAILED - failure
1115  *
1116  * ****************************************************************/
1117
1118 uint8_t fillDlCcchRrcMsg(uint8_t ueId, RRCContainer_t *rrcContainer)
1119 {
1120    uint8_t ret = ROK;
1121    uint16_t idx2;
1122    DL_CCCH_Message_t dl_CCCH_Msg;
1123    asn_enc_rval_t        encRetVal;
1124
1125    if(rrcContainer != NULLP)
1126    {
1127       dl_CCCH_Msg.message.present = DL_CCCH_MessageType_PR_c1;
1128
1129       CU_ALLOC(dl_CCCH_Msg.message.choice.c1 , sizeof(DL_CCCH_MessageType_t));
1130       if(dl_CCCH_Msg.message.choice.c1 != NULLP)
1131       {
1132          dl_CCCH_Msg.message.choice.c1->present = DL_CCCH_MessageType__c1_PR_rrcSetup;
1133          CU_ALLOC(dl_CCCH_Msg.message.choice.c1->choice.rrcSetup, sizeof(RRCSetup_t));
1134          if(dl_CCCH_Msg.message.choice.c1->choice.rrcSetup != NULLP)
1135          {
1136             dl_CCCH_Msg.message.choice.c1->choice.rrcSetup->rrc_TransactionIdentifier = 0;
1137             dl_CCCH_Msg.message.choice.c1->choice.rrcSetup->criticalExtensions.\
1138                present = RRCSetup__criticalExtensions_PR_rrcSetup;
1139             /* Fill RRC Setup IE */
1140             CU_ALLOC(dl_CCCH_Msg.message.choice.c1->choice.rrcSetup->\
1141                   criticalExtensions.choice.rrcSetup, sizeof(RRCSetup_IEs_t));
1142             if(dl_CCCH_Msg.message.choice.c1->choice.rrcSetup->\
1143                   criticalExtensions.choice.rrcSetup != NULLP)
1144             {
1145                ret = fillRRCSetupIE(ueId, dl_CCCH_Msg.message.choice.c1->choice.rrcSetup->\
1146                      criticalExtensions.choice.rrcSetup);
1147
1148                if(ret == ROK)
1149                {
1150                   /* encode DL-CCCH message into RRC Container */
1151                   xer_fprint(stdout, &asn_DEF_DL_CCCH_MessageType, &dl_CCCH_Msg);
1152                   memset(encBuf, 0, ENC_BUF_MAX_LEN);
1153                   encBufSize = 0;
1154                   encRetVal = aper_encode(&asn_DEF_DL_CCCH_MessageType, 0, &dl_CCCH_Msg, PrepFinalEncBuf, encBuf);
1155                   /* Encode results */
1156                   if(encRetVal.encoded == ENCODE_FAIL)
1157                   {
1158                      DU_LOG( "\nERROR  -->  F1AP : Could not encode RRCContainer for DL-CCCH Msg(at %s)\n",\
1159                            encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
1160                      return RFAILED;
1161                   }
1162                   else
1163                   {
1164                      DU_LOG("\nDEBUG  -->  F1AP : Created APER encoded buffer for RRCContainer for DL-CCCH Msg\n");
1165                      for(int i = 0; i< encBufSize; i++)
1166                      {
1167                         DU_LOG("%x",encBuf[i]);
1168                      }
1169                      rrcContainer->size = encBufSize;
1170                      CU_ALLOC(rrcContainer->buf, rrcContainer->size);
1171                      if(rrcContainer->buf != NULLP)
1172                      {
1173                         memset(rrcContainer->buf, 0, encBufSize);
1174                         for(idx2 = 0; idx2 < encBufSize; idx2++)
1175                         {
1176                            rrcContainer->buf[idx2] =    encBuf[idx2];
1177                         }
1178                      }
1179                   }
1180                }
1181                else
1182                {
1183                   ret = RFAILED;
1184                }
1185             }
1186             else
1187             {
1188                DU_LOG("\nERROR  -->  F1AP: Memory Alloc failed for RRC Setup Msg at fillDlCcchRrcMsg()");
1189                ret = RFAILED;
1190             }
1191          }
1192          else
1193          {
1194             DU_LOG("\nERROR  -->  F1AP: Memory Alloc failed for RRC Msg at fillDlCcchRrcMsg()");
1195             ret = RFAILED;
1196          }
1197       }
1198       else
1199       {
1200          DU_LOG("\nF1AP: Memory Alloc failed for DL Ccch Msg choice at fillDlCcchRrcMsg()");
1201          ret = RFAILED;
1202       }
1203    }
1204    else
1205    {
1206       DU_LOG("\nERROR  -->  F1AP: RRC Container is NULLP at fillDlCcchRrcMsg()");
1207       ret = RFAILED;
1208    }
1209 }
1210
1211 uint8_t fillQosFlowsToAdd(struct SDAP_Config__mappedQoS_FlowsToAdd *qosFlow)
1212 {
1213    uint8_t idx, ied, elementCnt;
1214
1215    elementCnt = 1;
1216    qosFlow->list.count = elementCnt;
1217    qosFlow->list.size  = elementCnt * sizeof(QFI_t *);
1218    CU_ALLOC(qosFlow->list.array, qosFlow->list.size);
1219    if(qosFlow->list.array != NULLP)
1220    {
1221       for(idx = 0; idx < elementCnt; idx++)
1222       {
1223          CU_ALLOC(qosFlow->list.array[idx], sizeof(QFI_t));
1224          if(qosFlow->list.array[idx] == NULLP)
1225          {
1226             for(ied = 0; ied < idx; ied++)
1227             {
1228                CU_FREE(qosFlow->list.array[idx], sizeof(QFI_t));
1229             }
1230             CU_FREE(qosFlow->list.array, qosFlow->list.size);
1231             return RFAILED;
1232          }
1233       }
1234    }
1235    idx = 0;
1236    *qosFlow->list.array[idx] = 9;
1237    return ROK;
1238 }
1239
1240 /*******************************************************************
1241  *
1242  * @brief Fills CN Assoc for Drb to Add/Mod List
1243  *
1244  * @details
1245  *
1246  *    Function : fillCnAssoc
1247  *
1248  *    Functionality: Fills CN Assoc for Drb to Add/Mod List
1249  *
1250  * @params[in] struct DRB_ToAddMod__cnAssociation *
1251  *
1252  * @return ROK     - success
1253  *         RFAILED - failure
1254  *
1255  * ****************************************************************/
1256
1257 uint8_t fillCnAssoc(struct DRB_ToAddMod__cnAssociation *cnAssoc)
1258 {
1259    uint8_t ret = ROK;
1260
1261    cnAssoc->present = DRB_ToAddMod__cnAssociation_PR_sdap_Config;
1262    if(cnAssoc->present == DRB_ToAddMod__cnAssociation_PR_eps_BearerIdentity)
1263    {
1264       cnAssoc->choice.eps_BearerIdentity = 5;
1265    }
1266    if(cnAssoc->present == DRB_ToAddMod__cnAssociation_PR_sdap_Config)
1267    {
1268       CU_ALLOC(cnAssoc->choice.sdap_Config, sizeof(SDAP_Config_t));
1269       if(cnAssoc->choice.sdap_Config)
1270       {
1271          cnAssoc->choice.sdap_Config->pdu_Session = 5;
1272          cnAssoc->choice.sdap_Config->sdap_HeaderDL = 0;
1273          cnAssoc->choice.sdap_Config->sdap_HeaderUL = 0;
1274          cnAssoc->choice.sdap_Config->defaultDRB = true;
1275          cnAssoc->choice.sdap_Config->mappedQoS_FlowsToAdd = NULLP;
1276          cnAssoc->choice.sdap_Config->mappedQoS_FlowsToRelease = NULLP;
1277          CU_ALLOC(cnAssoc->choice.sdap_Config->mappedQoS_FlowsToAdd, \
1278                sizeof(struct SDAP_Config__mappedQoS_FlowsToAdd));
1279          if(cnAssoc->choice.sdap_Config->mappedQoS_FlowsToAdd)
1280          {
1281             ret = fillQosFlowsToAdd(cnAssoc->choice.sdap_Config->mappedQoS_FlowsToAdd);
1282          }
1283          else
1284          {
1285             DU_LOG("\nERROR  -->  F1AP: Memory alloc failed at mappedQoS_FlowsToAdd in fillCnAssoc()");
1286             CU_FREE(cnAssoc->choice.sdap_Config, sizeof(SDAP_Config_t));
1287             ret = RFAILED;
1288          }
1289       }
1290       else
1291       {
1292          DU_LOG("\nERROR  -->  F1AP: Mem alloc failed at fillCnAssoc()");
1293          ret = RFAILED;
1294       }
1295    }
1296    return ret;
1297 }
1298
1299 /*******************************************************************
1300  *
1301  * @brief Fills Radio Bearer Config for Drb
1302  *
1303  * @details
1304  *
1305  *    Function : fillDrbCfg
1306  *
1307  *    Functionality: Fills Radio Bearer Config for Drb
1308  *
1309  * @params[in] drbId, DRB_ToAddModList *
1310  *
1311  * @return ROK     - success
1312  *         RFAILED - failure
1313  *
1314  * ****************************************************************/
1315 uint8_t fillDrbCfg(uint8_t drbId, DRB_ToAddModList_t *drbCfg)
1316 {
1317    uint8_t idx, ied, ret, elementCnt;
1318
1319    ret = ROK;
1320    if(drbCfg != NULLP)
1321    {
1322       elementCnt = 1;
1323       drbCfg->list.count = elementCnt;
1324       drbCfg->list.size =\
1325                          elementCnt * sizeof(DRB_ToAddMod_t *);
1326       CU_ALLOC(drbCfg->list.array, drbCfg->list.size);
1327       if(drbCfg->list.array != NULLP)
1328       {
1329          for(idx = 0; idx < elementCnt; idx++)
1330          {
1331             CU_ALLOC(drbCfg->list.array[idx], sizeof(DRB_ToAddMod_t));
1332             if(drbCfg->list.array[idx] == NULLP)
1333             {
1334                for(ied = 0; ied < idx; ied++)
1335                {
1336                   CU_FREE(drbCfg->list.array[idx], sizeof(DRB_ToAddMod_t));
1337                }
1338                CU_FREE(drbCfg->list.array, drbCfg->list.size);
1339                return RFAILED;
1340             }
1341          }
1342       }
1343       else
1344       {
1345          return RFAILED;
1346       }
1347       idx = 0;
1348       /* CN ASSOCIATION */
1349       CU_ALLOC(drbCfg->list.array[idx]->cnAssociation, sizeof(struct DRB_ToAddMod__cnAssociation));
1350       if(drbCfg->list.array[idx]->cnAssociation)
1351       {
1352          ret = fillCnAssoc(drbCfg->list.array[idx]->cnAssociation);
1353       }
1354       /* DRB */
1355       drbCfg->list.array[idx]->drb_Identity = drbId;
1356    }
1357    return ret;
1358 }
1359
1360 /*******************************************************************
1361  *
1362  * @brief Fills RRC Reconfig Message required for DLRRCMessageTransfer
1363  *
1364  * @details
1365  *
1366  *    Function : fillRrcReconfigIE
1367  *
1368  *    Functionality: Fills RRC Reconfig Message required for
1369  *                   DLRRCMessageTransfer
1370  *
1371  * @params[in] RRCReconfiguration_IEs_t* rrcReconfig
1372  *
1373  * @return ROK     - success
1374  *         RFAILED - failure
1375  *
1376  * ****************************************************************/
1377
1378 uint8_t fillRrcReconfigIE(RRCReconfiguration_IEs_t *rrcReconfigMsg)
1379 {
1380    uint8_t ret = ROK;
1381    CU_ALLOC(rrcReconfigMsg->radioBearerConfig, sizeof(RadioBearerConfig_t));
1382    if(rrcReconfigMsg->radioBearerConfig)
1383    {
1384       CU_ALLOC(rrcReconfigMsg->radioBearerConfig->srb_ToAddModList, sizeof(SRB_ToAddModList_t));
1385       if(rrcReconfigMsg->radioBearerConfig->srb_ToAddModList != NULLP)
1386       {
1387          ret = fillSrbCfg(SRB2, rrcReconfigMsg->radioBearerConfig->srb_ToAddModList);
1388
1389       }
1390       if(ret == ROK)
1391       {
1392          CU_ALLOC(rrcReconfigMsg->radioBearerConfig->drb_ToAddModList, sizeof(DRB_ToAddModList_t));
1393          if(rrcReconfigMsg->radioBearerConfig->drb_ToAddModList != NULLP)
1394          {
1395             ret = fillDrbCfg(DRB1, rrcReconfigMsg->radioBearerConfig->drb_ToAddModList);
1396             if(ret == RFAILED)
1397             {
1398                DU_LOG("\nERROR  -->  F1AP : Failed to fill DrbCfg at fillRrcReconfigIE()");
1399                CU_FREE(rrcReconfigMsg->radioBearerConfig->srb_ToAddModList, sizeof(SRB_ToAddModList_t));
1400                CU_FREE(rrcReconfigMsg->radioBearerConfig->drb_ToAddModList, sizeof(DRB_ToAddModList_t));
1401             }
1402          }
1403       }
1404       else
1405       {
1406          DU_LOG("\nERROR  -->  F1AP : memory Alloc failed at fillRrcReconfigIE()");
1407          CU_FREE(rrcReconfigMsg->radioBearerConfig->srb_ToAddModList, sizeof(SRB_ToAddModList_t));
1408       }
1409    }
1410
1411    return ret;
1412 }
1413 /*******************************************************************
1414  *
1415  * @brief Fills DL DCCH Message required for DLRRCMessageTransfer
1416  *
1417  * @details
1418  *
1419  *    Function : fillDlDcchRrcMsg
1420  *
1421  *    Functionality: Fills DL DCCH Message required for
1422  *                   DLRRCMessageTransfer
1423  *
1424  * @params[in] RRCContainer_t *rrcContainer
1425  *
1426  * @return ROK     - success
1427  *         RFAILED - failure
1428  *
1429  * ****************************************************************/
1430
1431 uint8_t fillDlDcchRrcMsg(RRCContainer_t *rrcContainer)
1432 {
1433    uint8_t ret = ROK;
1434    uint16_t idx2;
1435    DL_DCCH_Message_t dl_DCCH_Msg;
1436    memset(&dl_DCCH_Msg, 0, sizeof(DL_DCCH_Message_t));
1437    asn_enc_rval_t        encRetVal;
1438
1439    if(rrcContainer != NULLP)
1440    {
1441       dl_DCCH_Msg.message.present = DL_DCCH_MessageType_PR_c1;
1442
1443       CU_ALLOC(dl_DCCH_Msg.message.choice.c1 , sizeof(DL_DCCH_MessageType_t));
1444       if(dl_DCCH_Msg.message.choice.c1 != NULLP)
1445       {
1446          dl_DCCH_Msg.message.choice.c1->present = DL_DCCH_MessageType__c1_PR_rrcReconfiguration;
1447          CU_ALLOC(dl_DCCH_Msg.message.choice.c1->choice.rrcReconfiguration, sizeof(RRCReconfiguration_t));
1448          if(dl_DCCH_Msg.message.choice.c1->choice.rrcReconfiguration != NULLP)
1449          {
1450             dl_DCCH_Msg.message.choice.c1->choice.rrcReconfiguration->rrc_TransactionIdentifier = 0;
1451             dl_DCCH_Msg.message.choice.c1->choice.rrcReconfiguration->criticalExtensions.\
1452                present = RRCReconfiguration__criticalExtensions_PR_rrcReconfiguration;
1453             /* Fill RRC Reconfig IE */
1454             CU_ALLOC(dl_DCCH_Msg.message.choice.c1->choice.rrcReconfiguration->\
1455                   criticalExtensions.choice.rrcReconfiguration, sizeof(RRCReconfiguration_IEs_t));
1456             if(dl_DCCH_Msg.message.choice.c1->choice.rrcReconfiguration->\
1457                   criticalExtensions.choice.rrcReconfiguration != NULLP)
1458             {
1459                ret = fillRrcReconfigIE(dl_DCCH_Msg.message.choice.c1->choice.rrcReconfiguration->\
1460                      criticalExtensions.choice.rrcReconfiguration);
1461
1462                if(ret == ROK)
1463                {
1464                   /* encode DL-DCCH message into RRC Container */
1465                   xer_fprint(stdout, &asn_DEF_DL_DCCH_MessageType, &dl_DCCH_Msg);
1466                   memset(encBuf, 0, ENC_BUF_MAX_LEN);
1467                   encBufSize = 0;
1468                   encRetVal = aper_encode(&asn_DEF_DL_DCCH_MessageType, 0, &dl_DCCH_Msg, PrepFinalEncBuf, encBuf);
1469                   /* Encode results */
1470                   if(encRetVal.encoded == ENCODE_FAIL)
1471                   {
1472                      DU_LOG( "\nERROR  -->  F1AP : Could not encode RRCContainer for DL-DCCH Msg (at %s)\n",\
1473                            encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
1474                      return RFAILED;
1475                   }
1476                   else
1477                   {
1478                      DU_LOG("\nDEBUG  -->  F1AP : Created APER encoded buffer for RRCContainer for DL-DCCH Msg\n");
1479                      for(int i = 0; i< encBufSize; i++)
1480                      {
1481                         DU_LOG("%x",encBuf[i]);
1482                      }
1483                      rrcContainer->size = encBufSize;
1484                      CU_ALLOC(rrcContainer->buf, rrcContainer->size);
1485                      if(rrcContainer->buf != NULLP)
1486                      {
1487                         memset(rrcContainer->buf, 0, encBufSize);
1488                         for(idx2 = 0; idx2 < encBufSize; idx2++)
1489                         {
1490                            rrcContainer->buf[idx2] =    encBuf[idx2];
1491                         }
1492                      }
1493                   }
1494                }
1495                else
1496                {
1497                   DU_LOG("\nERROR  -->  F1AP: Failed to fill RrcReconfig IE at fillDlDcchRrcMsg()");
1498                }
1499             }
1500             else
1501             {
1502                DU_LOG("\nERROR  -->  F1AP: Memory Alloc failed for RRC Reconfig at fillDlDcchRrcMsg()");
1503                ret = RFAILED;
1504             }
1505          }
1506          else
1507          {
1508             DU_LOG("\nERROR  -->  F1AP: Memory Alloc failed for RRC Msg at fillDlDcchRrcMsg()");
1509             ret = RFAILED;
1510          }
1511       }
1512       else
1513       {
1514          DU_LOG("\nERROR  -->  F1AP: Memory Alloc failed for DL Dcch Msg choice at fillDlDcchRrcMsg()");
1515          ret = RFAILED;
1516       }
1517    }
1518    else
1519    {
1520       DU_LOG("\nERROR  -->  F1AP: RRC Container is NULLP at fillDlDcchRrcMsg()");
1521       ret = RFAILED;
1522    }
1523    return ret;
1524 }
1525
1526 /*******************************************************************
1527  *
1528  * @brief Builds RRC Container IE required for DLRRCMessageTransfer
1529  *
1530  * @details
1531  *
1532  *    Function : BuildDLRRCContainer
1533  *
1534  *    Functionality: Builds RRC Container IE required for
1535  *                   DLRRCMessageTransfer
1536  *
1537  * @params[in]
1538  *
1539  * @return ROK     - success
1540  *         RFAILED - failure
1541  *
1542  * ****************************************************************/
1543
1544 uint8_t BuildDLRRCContainer(uint8_t ueId, uint8_t rrcMsgType, RRCContainer_t *rrcContainer)
1545 {
1546    uint8_t ret, bufLen;
1547
1548    ret =ROK;
1549    if(rrcMsgType == RRC_SETUP)
1550    {
1551       ret = fillDlCcchRrcMsg(ueId, rrcContainer);
1552       if(ret == RFAILED)
1553          DU_LOG("\nERROR  -->  F1AP: Failed to fill DL-CCCH Msg at RRC SETUP");
1554    }
1555    else if(rrcMsgType == REGISTRATION_ACCEPT)
1556    {
1557       /*Hardcoded RRC Container from reference logs*/
1558       char buf[14] ={0x00, 0x03, 0x2a, 0x80, 0xaf, 0xc0, 0x08, 0x40, 0x20, 0x20, 0x00, 0x00, 0x00, 0x00};
1559       bufLen =14;
1560       rrcContainer->size = bufLen;
1561       CU_ALLOC(rrcContainer->buf, rrcContainer->size);
1562       if(rrcContainer->buf != NULLP)
1563       {
1564          memset(rrcContainer->buf, 0, bufLen);
1565          memcpy(rrcContainer->buf, buf, bufLen);
1566       }
1567    }
1568    else if(rrcMsgType == RRC_RECONFIG)
1569    {
1570       /*Hardcoded RRC Container from reference logs*/
1571       char buf[196]= {
1572          0x00, 0x04, 0x00, 0xaa, 0x80, 0x40, 0x9a, 0x05, 0x20, 0x00, 0x05, 0xeb, 0xc0, 0x51, 0x50, 0x00,
1573          0x03, 0x00, 0x03, 0xf7, 0x56, 0xec, 0x7f, 0x08, 0x42, 0x10, 0x80, 0x00, 0x10, 0x21, 0x47, 0x84,
1574          0xd1, 0x00, 0x00, 0x00, 0x02, 0x81, 0x5d, 0x10, 0x0a, 0xc2, 0x44, 0x40, 0x2b, 0xb2, 0x07, 0x41,
1575          0x87, 0xa8, 0x02, 0xc7, 0x00, 0x88, 0x05, 0x76, 0x40, 0xe8, 0x30, 0xf5, 0x40, 0x4c, 0x00, 0x10,
1576          0x02, 0x00, 0xa5, 0x83, 0xe0, 0x60, 0x02, 0x10, 0x72, 0x01, 0x0c, 0xa0, 0xa0, 0xd8, 0x00, 0x00,
1577          0x00, 0x01, 0x0f, 0x02, 0x3c, 0x01, 0x80, 0x10, 0x82, 0xb0, 0x40, 0x00, 0x00, 0x02, 0x1e, 0x04,
1578          0x78, 0x07, 0x00, 0x21, 0x05, 0x61, 0x00, 0x00, 0x00, 0x04, 0x3c, 0x08, 0xf0, 0x16, 0x00, 0x42,
1579          0x0a, 0xc3, 0x00, 0x00, 0x00, 0x08, 0x78, 0x11, 0xe0, 0x3c, 0x00, 0x84, 0x14, 0x00, 0x07, 0xe5,
1580          0xc0, 0xa0, 0xd8, 0x42, 0x20, 0x02, 0x80, 0xa0, 0x02, 0x24, 0x47, 0xa0, 0x20, 0x27, 0xa1, 0x22,
1581          0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x24, 0x41, 0x20, 0xc0, 0x80, 0x00, 0x20, 0x80,
1582          0x00, 0x25, 0x20, 0xa0, 0x38, 0x00, 0x00, 0x00, 0x44, 0xa2, 0x82, 0x69, 0xee, 0x0c, 0xad, 0xca,
1583          0x4c, 0x2c, 0x8d, 0x2e, 0x6f, 0x2e, 0x69, 0x2d, 0xce, 0x8c, 0xae, 0x4d, 0xcc, 0xae, 0x80, 0x00,
1584          0x00, 0x00, 0x00, 0x00};
1585       bufLen =196;
1586       rrcContainer->size = bufLen;
1587       CU_ALLOC(rrcContainer->buf, rrcContainer->size);
1588       if(rrcContainer->buf != NULLP)
1589       {
1590          memset(rrcContainer->buf, 0, bufLen);
1591          memcpy(rrcContainer->buf, buf, bufLen);
1592       }
1593    }
1594
1595    return ret;
1596 }
1597
1598 /*******************************************************************
1599  *
1600  * @brief Builds and sends the DLRRCMessageTransfer
1601  *
1602  * @details
1603  *
1604  *    Function : BuildAndSendDLRRCMessageTransfer
1605  *
1606  *    Functionality: Constructs the DL RRC Message Transfer and sends
1607  *                   it to the CU through SCTP.
1608  *
1609  * @params[in]
1610  *
1611  * @return ROK     - success
1612  *         RFAILED - failure
1613  *
1614  * ****************************************************************/
1615 uint8_t BuildAndSendDLRRCMessageTransfer(uint8_t ueId, uint8_t srbId, uint8_t rrcMsgType)
1616 {
1617    uint8_t   elementCnt = 0;
1618    uint8_t  ieId;
1619    uint8_t  idx;
1620    F1AP_PDU_t  *f1apMsg = NULLP;
1621    DLRRCMessageTransfer_t  *dlRRCMsg = NULLP;
1622    asn_enc_rval_t   encRetVal;        /* Encoder return value */
1623
1624    DU_LOG("\nINFO  -->  F1AP : Building DL RRC Message Transfer Message\n");
1625
1626    CU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
1627    if(f1apMsg == NULLP)
1628    {
1629       DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
1630       return RFAILED;
1631    }
1632
1633    f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
1634    CU_ALLOC(f1apMsg->choice.initiatingMessage,
1635          sizeof(InitiatingMessage_t));
1636    if(f1apMsg->choice.initiatingMessage == NULLP)
1637    {
1638       DU_LOG("\nERROR  -->  F1AP : Memory allocation for  F1AP-PDU failed");
1639       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
1640       return RFAILED;
1641    }
1642
1643    f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_DLRRCMessageTransfer;
1644    f1apMsg->choice.initiatingMessage->criticality = Criticality_ignore;
1645    f1apMsg->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_DLRRCMessageTransfer;
1646    dlRRCMsg = &f1apMsg->choice.initiatingMessage->value.choice.DLRRCMessageTransfer;
1647
1648    elementCnt = 4;
1649    dlRRCMsg->protocolIEs.list.count = elementCnt;
1650    dlRRCMsg->protocolIEs.list.size = elementCnt * sizeof(DLRRCMessageTransferIEs_t *);
1651
1652    /* Initialize the F1Setup members */
1653    CU_ALLOC(dlRRCMsg->protocolIEs.list.array, dlRRCMsg->protocolIEs.list.size);
1654    if(dlRRCMsg->protocolIEs.list.array == NULLP)
1655    {
1656       DU_LOG("\nERROR  -->  F1AP : Memory allocation for DL RRC MessageTransferIEs failed");
1657       CU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
1658       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
1659       return RFAILED;
1660    }
1661
1662    for(idx=0; idx<elementCnt; idx++)
1663    {
1664       CU_ALLOC(dlRRCMsg->protocolIEs.list.array[idx], sizeof(DLRRCMessageTransferIEs_t));
1665       if(dlRRCMsg->protocolIEs.list.array[idx] == NULLP)
1666       {
1667          for(ieId=0; ieId<idx; ieId++)
1668          {
1669             CU_FREE(dlRRCMsg->protocolIEs.list.array[ieId],\
1670                   sizeof(DLRRCMessageTransferIEs_t));
1671          }
1672          CU_FREE(dlRRCMsg->protocolIEs.list.array,\
1673                dlRRCMsg->protocolIEs.list.size);
1674          CU_FREE(f1apMsg->choice.initiatingMessage,\
1675                sizeof(InitiatingMessage_t));
1676          CU_FREE(f1apMsg,sizeof(F1AP_PDU_t));
1677          return RFAILED;
1678       }
1679    }
1680
1681    /* GNB CU UE F1AP ID */
1682    idx = 0;
1683    dlRRCMsg->protocolIEs.list.array[idx]->id  = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
1684    dlRRCMsg->protocolIEs.list.array[idx]->criticality  =   Criticality_reject;
1685    dlRRCMsg->protocolIEs.list.array[idx]->value.present = \
1686                                                           DLRRCMessageTransferIEs__value_PR_GNB_CU_UE_F1AP_ID;
1687    dlRRCMsg->protocolIEs.list.array[idx]->value.choice.GNB_CU_UE_F1AP_ID = ueId;
1688
1689    /* GNB DU UE F1AP ID */
1690    idx++;
1691    dlRRCMsg->protocolIEs.list.array[idx]->id  = \
1692                                                 ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
1693    dlRRCMsg->protocolIEs.list.array[idx]->criticality  =   Criticality_reject;
1694    dlRRCMsg->protocolIEs.list.array[idx]->value.present = \
1695                                                           DLRRCMessageTransferIEs__value_PR_GNB_DU_UE_F1AP_ID;
1696    dlRRCMsg->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID = ueId;
1697
1698    /* SRBID */
1699    idx++;
1700    dlRRCMsg->protocolIEs.list.array[idx]->id  = ProtocolIE_ID_id_SRBID;
1701    dlRRCMsg->protocolIEs.list.array[idx]->criticality  =   Criticality_reject;
1702    dlRRCMsg->protocolIEs.list.array[idx]->value.present = \
1703                                                           DLRRCMessageTransferIEs__value_PR_SRBID;
1704    dlRRCMsg->protocolIEs.list.array[idx]->value.choice.SRBID = srbId;
1705
1706    /* RRCContainer */
1707    idx++;
1708    dlRRCMsg->protocolIEs.list.array[idx]->id  = ProtocolIE_ID_id_RRCContainer;
1709    dlRRCMsg->protocolIEs.list.array[idx]->criticality   = Criticality_reject;
1710    dlRRCMsg->protocolIEs.list.array[idx]->value.present = \
1711                                                           DLRRCMessageTransferIEs__value_PR_RRCContainer;
1712    BuildDLRRCContainer(ueId, rrcMsgType, &dlRRCMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer);
1713
1714    xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
1715
1716    /* Encode the F1SetupRequest type as APER */
1717    memset(encBuf, 0, ENC_BUF_MAX_LEN);
1718    encBufSize = 0;
1719    encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
1720          encBuf);
1721    /* Encode results */
1722    if(encRetVal.encoded == ENCODE_FAIL)
1723    {
1724       DU_LOG( "\nERROR  -->  F1AP : Could not encode DL RRC Message Transfer structure (at %s)\n",\
1725             encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
1726       return RFAILED;
1727    }
1728    else
1729    {
1730       DU_LOG("\nDEBUG  -->  F1AP : Created APER encoded buffer for DL RRC Message transfer\n");
1731       for(int i=0; i< encBufSize; i++)
1732       {
1733          DU_LOG("%x",encBuf[i]);
1734       }
1735    }
1736
1737    /* Sending  msg  */
1738    if(SendF1APMsg(CU_APP_MEM_REG,CU_POOL)  !=  ROK)
1739    {
1740       DU_LOG("\nERROR  -->  F1AP : Sending  DL RRC Message Transfer Failed");
1741       return RFAILED;
1742    }
1743
1744    return ROK;
1745 }/* End of BuildAndSendDLRRCMessageTransfer */
1746
1747 /*******************************************************************
1748  *
1749  * @brief Function to set the Dl RRC Msg Type
1750  *
1751  * @details
1752  *
1753  *    Function : setDlRRCMsgType
1754  *
1755  *    Functionality: Constructs the UE Setup Response and sends
1756  *                   it to the DU through SCTP.
1757  *
1758  * @params[in]
1759  *
1760  * @return ROK     - success
1761  *         RFAILED - failure
1762  *
1763  * ****************************************************************/
1764
1765 uint8_t setDlRRCMsgType(uint8_t ueId)
1766 {
1767    uint8_t rrcMsgType = 0;
1768    switch(ueCb[ueId -1].f1apMsgDb.dlRrcMsgCount)
1769    {
1770       case RRC_SETUP:
1771          rrcMsgType = RRC_SETUP;
1772          break;
1773       case REGISTRATION_ACCEPT:
1774          rrcMsgType = REGISTRATION_ACCEPT;
1775          break;
1776       case UE_CONTEXT_SETUP_REQ:
1777          rrcMsgType = UE_CONTEXT_SETUP_REQ;
1778          break;
1779       case SECURITY_MODE_COMPLETE:
1780          rrcMsgType = SECURITY_MODE_COMPLETE;
1781          break;
1782       case RRC_RECONFIG:
1783          rrcMsgType = RRC_RECONFIG;
1784          break;
1785       case UE_CONTEXT_MOD_REQ:
1786          rrcMsgType = UE_CONTEXT_MOD_REQ;
1787          break;
1788       default:
1789          break;
1790    }
1791    return rrcMsgType;
1792 }
1793
1794 /*******************************************************************
1795  *
1796  * @brief Function to build Initial UL RRC Message
1797  *
1798  * @details
1799  *
1800  *    Function : procInitULRRCMsg
1801  *
1802  *    Functionality: Function to build Initial UL RRC Message
1803  *
1804  * @params[in]
1805  *
1806  * @return ROK     - success
1807  *         RFAILED - failure
1808  *
1809  * ****************************************************************/
1810
1811 uint8_t procInitULRRCMsg(F1AP_PDU_t *f1apMsg)
1812 {
1813    uint8_t idx, rrcMsgType, gnbDuUeF1apId;
1814    uint8_t ret =ROK;
1815    InitialULRRCMessageTransfer_t *initULRRCMsg = NULLP;
1816    DU_LOG("\nINFO   -->  F1AP : filling the required values in DB in procInitULRRCMsg");
1817
1818    initULRRCMsg = &f1apMsg->choice.initiatingMessage->value.choice.InitialULRRCMessageTransfer;
1819
1820    for(idx=0; idx < initULRRCMsg->protocolIEs.list.count; idx++)
1821    {
1822       switch(initULRRCMsg->protocolIEs.list.array[idx]->id)
1823       {
1824          case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
1825             gnbDuUeF1apId = initULRRCMsg->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID;
1826             break;
1827          case ProtocolIE_ID_id_NRCGI:
1828             break;
1829          case ProtocolIE_ID_id_C_RNTI:
1830             break;
1831          case ProtocolIE_ID_id_RRCContainer:
1832             break;
1833          case ProtocolIE_ID_id_DUtoCURRCContainer:
1834             {
1835                if((initULRRCMsg->protocolIEs.list.array[idx]->value.choice\
1836                         .DUtoCURRCContainer.size > 0) && (initULRRCMsg->protocolIEs\
1837                            .list.array[idx]->value.choice.DUtoCURRCContainer.buf != NULLP))
1838                {
1839                   DU_LOG("\nINFO  -->  Received Du to Cu RRC Container ");
1840                   ueCb[gnbDuUeF1apId-1].ueId = gnbDuUeF1apId;
1841                   ueCb[gnbDuUeF1apId-1].f1apMsgDb.duToCuContainer.size = initULRRCMsg->protocolIEs\
1842                          .list.array[idx]->value.choice.DUtoCURRCContainer.size;
1843                   CU_ALLOC(ueCb[gnbDuUeF1apId-1].f1apMsgDb.duToCuContainer.buf, \
1844                         ueCb[gnbDuUeF1apId-1].f1apMsgDb.duToCuContainer.size);
1845                   if(ueCb[gnbDuUeF1apId-1].f1apMsgDb.duToCuContainer.buf != NULLP)
1846                   {
1847                      memcpy(ueCb[gnbDuUeF1apId-1].f1apMsgDb.duToCuContainer.buf, initULRRCMsg->protocolIEs\
1848                            .list.array[idx]->value.choice.DUtoCURRCContainer.buf, ueCb[gnbDuUeF1apId-1].f1apMsgDb\
1849                            .duToCuContainer.size);
1850                   }
1851                }
1852                else
1853                {
1854                   DU_LOG("\nERROR  -->  Failed to receive Du to Cu RRC Container ");
1855                   ret = RFAILED;
1856                }
1857                break;
1858             }
1859          default:
1860             DU_LOG("\nERROR  -->  Invalid Event %ld", initULRRCMsg->protocolIEs.list.array[idx]->id);
1861             break;
1862       }
1863    }
1864    if(ret == ROK)
1865    {
1866       ueCb[gnbDuUeF1apId-1].f1apMsgDb.dlRrcMsgCount++;
1867       rrcMsgType = setDlRRCMsgType(gnbDuUeF1apId);
1868       ret = BuildAndSendDLRRCMessageTransfer(gnbDuUeF1apId, SRB0, rrcMsgType);
1869    }
1870    return ret;
1871 }
1872
1873 /*******************************************************************
1874  *
1875  * @brief Builds Nrcgi
1876  *
1877  * @details
1878  *
1879  *    Function : BuildNrcgi
1880  *
1881  *    Functionality: Building the PLMN ID and NR Cell id
1882  *
1883  * @params[in] NRCGI_t *nrcgi
1884  * @return ROK     - success
1885  *         RFAILED - failure
1886  *
1887  * ****************************************************************/
1888 uint8_t BuildNrcgi(NRCGI_t *nrcgi)
1889 {
1890    uint8_t ret;
1891    uint8_t unused_bits = 4;
1892    uint8_t byteSize = 5;
1893    uint8_t val = 1;
1894    /* Allocate Buffer Memory */
1895    nrcgi->pLMN_Identity.size = 3 * sizeof(uint8_t);
1896    CU_ALLOC(nrcgi->pLMN_Identity.buf, nrcgi->pLMN_Identity.size);
1897    if(nrcgi->pLMN_Identity.buf == NULLP)
1898    {
1899       return RFAILED;
1900    }
1901    ret = buildPlmnId(cuCfgParams.plmn , nrcgi->pLMN_Identity.buf);
1902
1903    if(ret != ROK)
1904    {
1905       return RFAILED;
1906    }
1907    nrcgi->nRCellIdentity.size = byteSize * sizeof(uint8_t);
1908    CU_ALLOC(nrcgi->nRCellIdentity.buf, nrcgi->nRCellIdentity.size);
1909    if(nrcgi->nRCellIdentity.buf == NULLP)
1910    {
1911       return RFAILED;
1912    }
1913 #if 0
1914    ret = fillBitString(&nrcgi->nRCellIdentity, unused, byteSize, val);
1915    if(ret != ROK)
1916    {
1917       return RFAILED;
1918    }
1919 #endif
1920    memset(nrcgi->nRCellIdentity.buf, 0, nrcgi->nRCellIdentity.size);
1921    nrcgi->nRCellIdentity.buf[0] |= val;
1922    nrcgi->nRCellIdentity.bits_unused = unused_bits;
1923
1924    return ROK;
1925 }
1926 /*******************************************************************
1927  *
1928  * @brief Builds Special cell list for UE Setup Request
1929  *
1930  * @details
1931  *
1932  *    Function : BuildSplCellList
1933  *
1934  *    Functionality: Constructs the Special Cell list for UESetReq
1935  *
1936  * @params[in] SCell_ToBeSetup_List_t *spCellLst
1937  *
1938  * @return ROK     - success
1939  *         RFAILED - failure
1940  *
1941  * ****************************************************************/
1942 uint8_t BuildSplCellList(SCell_ToBeSetup_List_t *spCellLst)
1943 {
1944    uint8_t  cellCnt;
1945    uint8_t  idx;
1946    uint8_t  ret;
1947    cellCnt = 1;
1948    spCellLst->list.count = cellCnt;
1949    spCellLst->list.size = cellCnt * sizeof(SCell_ToBeSetup_ItemIEs_t *);
1950    CU_ALLOC(spCellLst->list.array,spCellLst->list.size);
1951    if(spCellLst->list.array == NULLP)
1952    {
1953       return RFAILED;
1954    }
1955    for(idx=0; idx<cellCnt; idx++)
1956    {
1957       CU_ALLOC(spCellLst->list.array[idx],sizeof(SCell_ToBeSetup_ItemIEs_t));
1958       if(spCellLst->list.array[idx] == NULLP)
1959       {
1960          return RFAILED;
1961       }
1962    }
1963    idx = 0;
1964    spCellLst->list.array[idx]->id = ProtocolIE_ID_id_SCell_ToBeSetup_Item;
1965    spCellLst->list.array[idx]->criticality = Criticality_ignore;
1966    spCellLst->list.array[idx]->value.present =\
1967                                               SCell_ToBeSetup_ItemIEs__value_PR_SCell_ToBeSetup_Item;
1968    /* Special Cell ID -NRCGI */
1969    ret = BuildNrcgi(&spCellLst->list.array[idx]->value.choice.SCell_ToBeSetup_Item.sCell_ID);
1970    if(ret != ROK)
1971    {
1972       return RFAILED;
1973    }
1974    /*Special Cell Index*/
1975    spCellLst->list.array[idx]->value.choice.SCell_ToBeSetup_Item.sCellIndex = 1;
1976    return ROK;
1977 }/* End of BuildSplCellList*/
1978
1979 /*******************************************************************
1980  *
1981  * @brief Builds SRBS to be setup
1982  *
1983  * @details
1984  *
1985  *    Function : BuildSRBSetup
1986  *
1987  *    Functionality: Constructs the SRB's for UESetReq
1988  *
1989  * @params[in] SRBs_ToBeSetup_List_t *srbSet
1990  *
1991  * @return ROK     - success
1992  *         RFAILED - failure
1993  *
1994  * ****************************************************************/
1995 uint8_t BuildSRBSetup(SRBs_ToBeSetup_List_t *srbSet)
1996 {
1997    uint8_t idx;
1998    uint8_t srbCnt;
1999    srbCnt = 1;
2000    srbSet->list.count = srbCnt;
2001    srbSet->list.size = srbCnt*sizeof(SRBs_ToBeSetup_ItemIEs_t *);
2002    CU_ALLOC(srbSet->list.array,srbSet->list.size);
2003    if(srbSet->list.array == NULLP)
2004    {
2005       return RFAILED;
2006    }
2007    for(idx=0; idx<srbCnt; idx++)
2008    {
2009       CU_ALLOC(srbSet->list.array[idx],sizeof(SRBs_ToBeSetup_ItemIEs_t));
2010       if(srbSet->list.array[idx] == NULLP)
2011       {
2012          return RFAILED;
2013       }
2014    }
2015    idx = 0;
2016    srbSet->list.array[idx]->id = ProtocolIE_ID_id_SRBs_ToBeSetup_Item;
2017    srbSet->list.array[idx]->criticality = Criticality_ignore;
2018    srbSet->list.array[idx]->value.present = \
2019                                             SRBs_ToBeSetup_ItemIEs__value_PR_SRBs_ToBeSetup_Item;
2020    srbSet->list.array[idx]->value.choice.SRBs_ToBeSetup_Item.sRBID = 2;
2021    return ROK;
2022 }/* End of BuildSRBSetup*/
2023
2024 /*******************************************************************
2025  *
2026  * @brief Builds QOS Info for DRB Setum Item
2027  *
2028  * @details
2029  *
2030  *    Function : BuildQOSInfo
2031  *
2032  *    Functionality: Constructs the QOS Info for DRB Setup Item
2033  *
2034  * @params[in] QoSInformation_t *qosinfo
2035  *             int16_t pduSessionID
2036  *
2037  * @return ROK     - success
2038  *         RFAILED - failure
2039  *
2040  * ****************************************************************/
2041 uint8_t BuildQOSInfo(QoSFlowLevelQoSParameters_t *drbQos, uint8_t actionType, \
2042                         int16_t pduSessionID)
2043 {
2044    uint8_t elementCnt = 0, qosCntIdx = 0;
2045    ProtocolExtensionContainer_4624P74_t *qosIeExt = NULLP;
2046
2047    /* NonDynamic5QIDescriptor */
2048    drbQos->qoS_Characteristics.present = QoS_Characteristics_PR_non_Dynamic_5QI;
2049    CU_ALLOC(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI,sizeof(NonDynamic5QIDescriptor_t));
2050    if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI == NULLP)
2051    {
2052       return RFAILED;
2053    }
2054    /*FiveQI*/
2055    if(actionType == ProtocolIE_ID_id_DRBs_ToBeModified_Item)
2056       drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->fiveQI = FIVE_QI_VALUE8;
2057    else
2058       drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->fiveQI = FIVE_QI_VALUE9;
2059
2060    /*AveragingWindow*/
2061    CU_ALLOC(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow,\
2062          sizeof(AveragingWindow_t));
2063    if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow == \
2064          NULLP)
2065    {
2066       return RFAILED;
2067    }
2068    *(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow) = 0;
2069    /*MaxDataBurstVolume*/
2070    CU_ALLOC(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume,\
2071          sizeof(MaxDataBurstVolume_t));
2072    if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume == \
2073          NULLP)
2074    {
2075       return RFAILED;
2076    }
2077    *(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume) = 0;
2078
2079    /*nRGRAN Allocation Retention Priority*/
2080    drbQos->nGRANallocationRetentionPriority.priorityLevel = PriorityLevel_lowest;
2081    drbQos->nGRANallocationRetentionPriority.pre_emptionCapability = Pre_emptionCapability_may_trigger_pre_emption;
2082    drbQos->nGRANallocationRetentionPriority.pre_emptionVulnerability = Pre_emptionVulnerability_not_pre_emptable;
2083
2084    /*If PDU Session ID is INVALID thus not to be included in Qos IE, skip the PDU Session IE */
2085    if(pduSessionID <= INVALID_PDU_SESSION_ID)
2086    {
2087       DU_LOG("\nINFO  --> F1AP : Invalid PDU_SESSION_ID");
2088       return ROK;
2089    }
2090
2091    CU_ALLOC(drbQos->iE_Extensions, sizeof(ProtocolExtensionContainer_4624P74_t));
2092    qosIeExt = (ProtocolExtensionContainer_4624P74_t *)drbQos->iE_Extensions;
2093
2094    if(qosIeExt)
2095    {
2096       elementCnt = NUM_QOS_EXT;
2097       qosIeExt->list.count = elementCnt;
2098       qosIeExt->list.size = elementCnt * sizeof(QoSFlowLevelQoSParameters_ExtIEs_t *);
2099
2100       /*Initialize QoSFlowLevelQoSParameters_ExtIEs_t*/
2101       CU_ALLOC(qosIeExt->list.array, qosIeExt->list.size);
2102
2103       if(qosIeExt->list.array == NULLP)
2104       {
2105          DU_LOG("\nERROR  -->   F1AP : Memory allocation for QoSFlowLevelQoSParameters_ExtIEs_t failed");
2106          return  RFAILED;
2107       }
2108
2109       for(qosCntIdx=0; qosCntIdx < elementCnt; qosCntIdx++)
2110       {
2111          CU_ALLOC(qosIeExt->list.array[qosCntIdx], sizeof(QoSFlowLevelQoSParameters_ExtIEs_t));
2112          if(qosIeExt->list.array[qosCntIdx] == NULLP)
2113          {
2114             DU_LOG("\nERROR  -->        F1AP : Memory allocation for QoSFlowLevelQoSParameters_ExtIEs_t array failed");
2115             return  RFAILED;
2116          }
2117          /*Filling QoSFlowLevelQoSParameters_ExtIEs_t*/
2118          qosIeExt->list.array[qosCntIdx]->id = ProtocolIE_ID_id_PDUSessionID;
2119          /*Below Criticality mentioned in Spec38.473, 15.4.1 and later*/
2120          qosIeExt->list.array[qosCntIdx]->criticality = Criticality_ignore;
2121          qosIeExt->list.array[qosCntIdx]->extensionValue.present = \
2122                                                                    QoSFlowLevelQoSParameters_ExtIEs__extensionValue_PR_PDUSessionID;
2123          qosIeExt->list.array[qosCntIdx]->extensionValue.choice.PDUSessionID = (PDUSessionID_t)pduSessionID;
2124       }
2125    }
2126    else
2127    {
2128       DU_LOG("\nERROR  -->      F1AP : Memory allocation for QosIE_extension failed");
2129       return RFAILED;
2130    }
2131
2132    return ROK;
2133 }/*End of BuildQOSInfo*/
2134
2135 /*******************************************************************
2136  *
2137  * @brief Builds SNSSAI
2138  *
2139  * @details
2140  *
2141  *    Function : BuildSNSSAI
2142  *
2143  *    Functionality: Constructs the SNSSAI For DRB list
2144  *
2145  * @params[in] SNSSAI_t *snssai
2146  *             Snssai  *snssaiToCopy S-NSSAI from CuCfgParam to be copied
2147  *
2148  * @return ROK     - success
2149  *         RFAILED - failure
2150  *
2151  * ****************************************************************/
2152 uint8_t BuildSNSSAI(SNSSAI_t *snssai, Snssai *snssaiToCopy)
2153 {
2154    /*SNSSAI*/
2155    /*ssT*/
2156    snssai->sST.size = sizeof(uint8_t);
2157    CU_ALLOC(snssai->sST.buf,snssai->sST.size);
2158    if(snssai->sST.buf == NULLP)
2159    {
2160       return RFAILED;
2161    }
2162    memcpy(snssai->sST.buf, &snssaiToCopy->sst, snssai->sST.size);
2163    /*sD*/
2164    CU_ALLOC(snssai->sD,sizeof(OCTET_STRING_t));
2165    if(snssai->sD == NULLP)
2166    {
2167       return RFAILED;
2168    }
2169    snssai->sD->size = 3*sizeof(uint8_t);
2170    CU_ALLOC(snssai->sD->buf,snssai->sD->size);
2171    if(snssai->sD->buf == NULLP)
2172    {
2173       return RFAILED;
2174    }
2175    memcpy(snssai->sD->buf, snssaiToCopy->sd, snssai->sD->size);
2176    return ROK;
2177 }/*End of BuildSNSSAI*/
2178
2179 /*******************************************************************
2180  *
2181  * @brief Builds the flow map.
2182  *
2183  * @details
2184  *
2185  *    Function : BuildFlowsMap
2186  *
2187  *    Functionality: Constructs the flowmap For DRB list
2188  *
2189  * @params[in] Flows_Mapped_To_DRB_List_t *flowMap
2190  *
2191  * @return ROK     - success
2192  *         RFAILED - failure
2193  *
2194  * ****************************************************************/
2195 uint8_t BuildFlowsMap(Flows_Mapped_To_DRB_List_t *flowMap , uint8_t actionType)
2196 {
2197    uint8_t  ret = ROK, idx = 0, flowCnt = 0;
2198
2199    flowCnt = 1;
2200    flowMap->list.count = flowCnt;
2201    flowMap->list.size = flowCnt * sizeof(Flows_Mapped_To_DRB_Item_t *);
2202    CU_ALLOC(flowMap->list.array,flowMap->list.size);
2203    if(flowMap->list.array == NULLP)
2204    {
2205       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed for array in BuildFlowsMap()");
2206       return RFAILED;
2207    }
2208    for(idx=0; idx<flowCnt; idx++)
2209    {
2210       CU_ALLOC(flowMap->list.array[idx],sizeof(Flows_Mapped_To_DRB_Item_t));
2211       if(flowMap->list.array[idx] == NULLP)
2212       {
2213          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed for arrayIdx[%d] in BuildFlowsMap()", idx);
2214          return RFAILED;
2215       }
2216    }
2217    idx = 0;
2218    flowMap->list.array[idx]->qoSFlowIdentifier = 0;
2219    ret = BuildQOSInfo(&flowMap->list.array[idx]->qoSFlowLevelQoSParameters,\
2220          actionType, INVALID_PDU_SESSION_ID);
2221    if(ret != ROK)
2222    {
2223       DU_LOG("\nERROR  -->  F1AP : Failed to Build QOS Info in BuildFlowsMap()");
2224       return RFAILED;
2225    }
2226    return ROK;
2227 }/*End of BuildFlowsMap*/
2228
2229 /*******************************************************************
2230  *
2231  * @brief Builds the Uplink Tunnel Info
2232  *
2233  * @details
2234  *
2235  *    Function : BuildULTnlInfo
2236  *
2237  *    Functionality: Constructs the UL TnlInfo For DRB list
2238  *
2239  * @params[in]  UPTNLInformation_ToBeSetup_List_t *ulInfo
2240  *
2241  * @return ROK     - success
2242  *         RFAILED - failure
2243  *
2244  * ****************************************************************/
2245 uint8_t BuildULTnlInfo(ULUPTNLInformation_ToBeSetup_List_t *ulInfo)
2246 {
2247    uint8_t idx;
2248    uint8_t ulCnt;
2249    ulCnt = 1;
2250    ulInfo->list.count = ulCnt;
2251    ulInfo->list.size = ulCnt * sizeof(ULUPTNLInformation_ToBeSetup_Item_t *);
2252    CU_ALLOC(ulInfo->list.array,ulInfo->list.size);
2253    if(ulInfo->list.array == NULLP)
2254    {
2255       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed for array in BuildULTnlInfo()");
2256       return RFAILED;
2257    }
2258    for(idx=0; idx<ulCnt; idx++)
2259    {
2260       CU_ALLOC(ulInfo->list.array[idx],sizeof(ULUPTNLInformation_ToBeSetup_Item_t));
2261       if(ulInfo->list.array[idx] == NULLP)
2262       {
2263          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed for arrayIdx [%d] in BuildULTnlInfo()", idx);
2264               return RFAILED;
2265       }
2266    }
2267    idx = 0;
2268    ulInfo->list.array[idx]->uLUPTNLInformation.present = \
2269                                                          UPTransportLayerInformation_PR_gTPTunnel;
2270    /*GTP TUNNEL*/
2271    CU_ALLOC(ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel,\
2272          sizeof(GTPTunnel_t));
2273    if(ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel == NULLP)
2274    {
2275       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed for gTPTunnel in BuildULTnlInfo()");
2276       return RFAILED;
2277    }
2278    ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->\
2279       transportLayerAddress.size        = 4*sizeof(uint8_t);
2280    CU_ALLOC(ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->\
2281          transportLayerAddress.buf,ulInfo->list.array[idx]->\
2282          uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.size);
2283    if(ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->\
2284          transportLayerAddress.buf == NULLP)
2285    {
2286       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed for gtp tunnel arrayIdx[%d] in BuildULTnlInfo()", idx);
2287       return RFAILED;
2288    }
2289    /* NOTE: Below IP address must be changed if running on different IP configuration */
2290    ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->\
2291       transportLayerAddress.buf[0] = 192;
2292    ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->\
2293       transportLayerAddress.buf[1] = 168;
2294    ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->\
2295       transportLayerAddress.buf[2] = 130;
2296    ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->\
2297       transportLayerAddress.buf[3] = 82;
2298    ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->\
2299       transportLayerAddress.bits_unused = 0;
2300    /*GTP TEID*/
2301    ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.size\
2302       = 4 * sizeof(uint8_t);
2303    CU_ALLOC(ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->\
2304          gTP_TEID.buf,ulInfo->list.array[idx]->uLUPTNLInformation.choice.\
2305          gTPTunnel->gTP_TEID.size);
2306    if(ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf\
2307          == NULLP)
2308    {
2309       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed for gtp tunnel buffer in BuildULTnlInfo()");
2310       return RFAILED;
2311    }
2312    ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->\
2313      gTP_TEID.buf[0] = 0;
2314    ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->\
2315       gTP_TEID.buf[1] = 0;
2316    ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->\
2317       gTP_TEID.buf[2] = 0;
2318    ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->\
2319       gTP_TEID.buf[3] = cuCfgParams.egtpParams.currTunnelId++;
2320
2321    return ROK;
2322 }/*End of BuildULTnlInfo*/
2323
2324 /*******************************************************************
2325  *
2326  * @brief Builds DRBS to be setup
2327  *
2328  * @details
2329  *
2330  *    Function : BuildDRBSetup
2331  *
2332  *    Functionality: Constructs the DRB's for UESetReq
2333  *
2334  * @params[in] DRBs_ToBeSetup_List_t *drbSet
2335  *
2336  * @return ROK     - success
2337  *         RFAILED - failure
2338  *
2339  * ****************************************************************/
2340 uint8_t BuildDRBSetup(DRBs_ToBeSetup_List_t *drbSet)
2341 {
2342    uint8_t BuildQOSInforet = 0,BuildSNSSAIret = 0, idx = 0;
2343    uint8_t BuildFlowsMapret =0, BuildULTnlInforet =0, drbCnt = 0;
2344    DRBs_ToBeSetup_Item_t *drbSetItem;
2345
2346    drbCnt = MAX_DRB_SET_UE_CONTEXT_SETUP_REQ;
2347    drbSet->list.count = drbCnt;
2348    drbSet->list.size = drbCnt*sizeof(DRBs_ToBeSetup_ItemIEs_t *);
2349    CU_ALLOC(drbSet->list.array,drbSet->list.size);
2350    if(drbSet->list.array == NULLP)
2351    {
2352       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDRBSetup");
2353       return RFAILED;
2354    }
2355    for(idx=0; idx<drbCnt; idx++)
2356    {
2357       CU_ALLOC(drbSet->list.array[idx],sizeof(DRBs_ToBeSetup_ItemIEs_t));
2358       if(drbSet->list.array[idx] == NULLP)
2359       {
2360          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDRBSetup for arry idx [%d]", idx);
2361               return RFAILED;
2362       }
2363
2364       drbSet->list.array[idx]->id = ProtocolIE_ID_id_DRBs_ToBeSetup_Item;
2365       drbSet->list.array[idx]->criticality = Criticality_ignore;
2366       drbSet->list.array[idx]->value.present = \
2367                                             DRBs_ToBeSetup_ItemIEs__value_PR_DRBs_ToBeSetup_Item;
2368       drbSetItem = &drbSet->list.array[idx]->value.choice.DRBs_ToBeSetup_Item;
2369       /*dRBID*/
2370       drbSetItem->dRBID = idx + 1;
2371       /*qoSInformation*/
2372       drbSetItem->qoSInformation.present = QoSInformation_PR_choice_extension;
2373       CU_ALLOC(drbSetItem->qoSInformation.choice.choice_extension,sizeof(QoSInformation_ExtIEs_t));
2374       if(drbSetItem->qoSInformation.choice.choice_extension == NULLP)
2375       {
2376          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed for QOS choice extension in BuildDRBSetup");
2377          return RFAILED;
2378       }
2379       drbSetItem->qoSInformation.choice.choice_extension->id = \
2380                                                             ProtocolIE_ID_id_DRB_Information;
2381       drbSetItem->qoSInformation.choice.choice_extension->criticality = \
2382                                                                      Criticality_ignore;
2383       drbSetItem->qoSInformation.choice.choice_extension->value.present = \
2384                                                                        QoSInformation_ExtIEs__value_PR_DRB_Information;
2385       BuildQOSInforet =  BuildQOSInfo(&drbSetItem->qoSInformation.choice.\
2386                               choice_extension->value.choice.DRB_Information.dRB_QoS,\
2387                          ProtocolIE_ID_id_DRBs_ToBeSetup_Item, PDU_SESSION_ID_1);
2388       if(BuildQOSInforet != ROK)
2389       {
2390          DU_LOG("\nERROR  -->  F1AP : Failed to build QOS Info in BuildDRBSetup");
2391          return RFAILED;
2392       }
2393       /*SNSSAI*/
2394       BuildSNSSAIret = BuildSNSSAI(&drbSetItem->qoSInformation.choice.\
2395                                choice_extension->value.choice.DRB_Information.sNSSAI, cuCfgParams.snssaiList[0]);
2396       if(BuildSNSSAIret != ROK)
2397       {
2398          DU_LOG("\nERROR  -->  F1AP : Failed to build SNSSAI Info in BuildDRBSetup");
2399          return RFAILED;
2400       }
2401       /*Flows mapped to DRB List*/
2402       BuildFlowsMapret = BuildFlowsMap(&drbSetItem->qoSInformation.choice.\
2403                    choice_extension->value.choice.DRB_Information.flows_Mapped_To_DRB_List,\
2404               ProtocolIE_ID_id_DRBs_ToBeSetup_Item);
2405       if(BuildFlowsMapret != ROK)
2406       {
2407          DU_LOG("\nERROR  -->  F1AP : Failed to build Flow Map Info in BuildDRBSetup");
2408          return RFAILED;
2409       }
2410       /*ULUPTNLInformation To Be Setup List*/
2411       BuildULTnlInforet = BuildULTnlInfo(&drbSetItem->uLUPTNLInformation_ToBeSetup_List);
2412       if(BuildULTnlInforet != ROK)
2413       {
2414          DU_LOG("\nERROR  -->  F1AP : Failed to build tunnel Info in BuildDRBSetup");
2415          return RFAILED;
2416       }
2417       /*RLCMode*/
2418       drbSetItem->rLCMode = RLCMode_rlc_um_bidirectional;
2419   }
2420    return ROK;
2421 }/* End of BuildDRBSetup*/
2422
2423 /*******************************************************************
2424  *
2425  * @brief Deallocating memory of function BuildAndSendUESetReq
2426  *
2427  * @details
2428  *
2429  *    Function : FreeNrcgi
2430  *
2431  *    Functionality: Deallocating memory for function BuildNrcgi
2432  *
2433  * @params[in] NRCGI_t *nrcgi
2434  *
2435  * @return void
2436  *
2437  *******************************************************************/
2438 void FreeNrcgi(NRCGI_t *nrcgi)
2439 {
2440    if(nrcgi->pLMN_Identity.buf != NULLP)
2441    {
2442       if(nrcgi->nRCellIdentity.buf != NULLP)
2443       {
2444          CU_FREE(nrcgi->nRCellIdentity.buf, nrcgi->nRCellIdentity.size);
2445       }
2446       CU_FREE(nrcgi->pLMN_Identity.buf, nrcgi->pLMN_Identity.size);
2447    }
2448 }
2449 /*******************************************************************
2450  *
2451  * @brief  Deallocating memory of function BuildAndSendUESetReq
2452  *
2453  * @details
2454  *
2455  *    Function : FreeSplCellList
2456  *
2457  *    Functionality: Deallocating memory for function BuildSplCellList
2458  *
2459  * @params[in] SCell_ToBeSetup_List_t *spCellLst
2460  *
2461  * @return void
2462  *
2463  *
2464  * *****************************************************************/
2465 void FreeSplCellList(SCell_ToBeSetup_List_t *spCellLst)
2466 {
2467    uint8_t  cellidx;
2468    if(spCellLst->list.array != NULLP)
2469    {
2470       for(cellidx=0; cellidx<spCellLst->list.count; cellidx++)
2471       {
2472          if(cellidx==0&&spCellLst->list.array[cellidx]!=NULLP)
2473          {
2474             FreeNrcgi(&spCellLst->list.array[cellidx]->value.choice.SCell_ToBeSetup_Item.sCell_ID);
2475          }
2476          if(spCellLst->list.array[cellidx]!=NULLP)
2477          {
2478             CU_FREE(spCellLst->list.array[cellidx],sizeof(SCell_ToBeSetup_ItemIEs_t));
2479          }
2480       }
2481       CU_FREE(spCellLst->list.array,spCellLst->list.size);
2482    }
2483 }
2484 /*******************************************************************
2485  *
2486  * @brief Deallocating memory of function BuildAndSendUESetReq
2487  *
2488  * @details
2489  *
2490  *    Function : FreeSRBSetup
2491  *
2492  *    Functionality: Deallocating memory for function BuildSRBSetup
2493  *
2494  * @params[in] SRBs_ToBeSetup_List_t *srbSet
2495  *
2496  * @return void
2497  *
2498  *
2499  * ******************************************************************/
2500 void FreeSRBSetup(SRBs_ToBeSetup_List_t *srbSet)
2501 {
2502    uint8_t srbidx;
2503    if(srbSet->list.array != NULLP)
2504    {
2505       for(srbidx=0; srbidx<srbSet->list.count; srbidx++)
2506       {
2507          if(srbSet->list.array[srbidx]!=NULLP)
2508          {
2509             CU_FREE(srbSet->list.array[srbidx],sizeof(SRBs_ToBeSetup_ItemIEs_t));
2510          }
2511       }
2512       CU_FREE(srbSet->list.array,srbSet->list.size);
2513    }
2514 }
2515 /*******************************************************************
2516  *
2517  * @brief Deallocating memory of function BuildAndSendUESetReq
2518  *
2519  * @details
2520  *
2521  *    Function : FreeQOSInfo
2522  *
2523  *    Functionality:  Deallocating memory for function BuildQOSInfo
2524  *
2525  * @params[in] QoSFlowLevelQoSParameters_t *drbQos
2526  *
2527  * @return void
2528  *
2529  * ****************************************************************/
2530 void FreeQOSInfo(QoSFlowLevelQoSParameters_t *drbQos)
2531 {
2532    ProtocolExtensionContainer_4624P74_t *qosIeExt = NULLP;
2533    uint8_t qosCntIdx = 0;
2534
2535    if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI != NULLP)
2536    {
2537       if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow!=NULLP)
2538       {
2539          if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume!=NULLP)
2540          {
2541             CU_FREE(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume,\
2542                   sizeof(MaxDataBurstVolume_t));
2543          }
2544          CU_FREE(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow,\
2545                sizeof(AveragingWindow_t));
2546       }
2547       CU_FREE(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI,\
2548             sizeof(NonDynamic5QIDescriptor_t));
2549    }
2550    if(drbQos->iE_Extensions)
2551    {
2552       qosIeExt = (ProtocolExtensionContainer_4624P74_t *)drbQos->iE_Extensions;
2553       if(qosIeExt->list.array != NULLP)
2554       {
2555          for(qosCntIdx=0; qosCntIdx <  qosIeExt->list.count; qosCntIdx++)
2556          {
2557             if(qosIeExt->list.array[qosCntIdx])
2558             {
2559                CU_FREE(qosIeExt->list.array[qosCntIdx], sizeof(QoSFlowLevelQoSParameters_ExtIEs_t));
2560             }
2561          }
2562          CU_FREE(qosIeExt->list.array, qosIeExt->list.size);
2563       }
2564
2565       CU_FREE(drbQos->iE_Extensions, sizeof(ProtocolExtensionContainer_4624P74_t));
2566    }
2567 }
2568 /*******************************************************************
2569  *
2570  * @brief Deallocating memory of function BuildAndSendUESetReq
2571  *
2572  * @details
2573  *
2574  *    Function : FreeULTnlInfo
2575  *
2576  *    Functionality:  Deallocating memory for function BuildULTnlInfo
2577  *
2578  * @params[in] ULUPTNLInformation_ToBeSetup_List_t *ulInfo
2579  *
2580  * @return void
2581  *
2582
2583  * ****************************************************************/
2584 void FreeULTnlInfo(ULUPTNLInformation_ToBeSetup_List_t *ulInfo)
2585 {
2586    uint8_t ulidx=0;
2587    if(ulInfo->list.array != NULLP)
2588    {
2589       for(ulidx=0; ulidx<ulInfo->list.count; ulidx++)
2590       {
2591          if(ulidx==0&&ulInfo->list.array[ulidx]!=NULLP)
2592          {
2593             if(ulInfo->list.array[ulidx]->uLUPTNLInformation.choice.gTPTunnel!=NULLP)
2594             {
2595                if(ulInfo->list.array[ulidx]->uLUPTNLInformation.choice.gTPTunnel->\
2596                      transportLayerAddress.buf != NULLP)
2597                {
2598                   if(ulInfo->list.array[ulidx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf\
2599                         !=NULLP)
2600                   {
2601                      CU_FREE(ulInfo->list.array[ulidx]->uLUPTNLInformation.choice.gTPTunnel->\
2602                            gTP_TEID.buf,ulInfo->list.array[ulidx]->uLUPTNLInformation.choice.\
2603                            gTPTunnel->gTP_TEID.size);
2604                   }
2605                   CU_FREE(ulInfo->list.array[ulidx]->uLUPTNLInformation.choice.gTPTunnel->\
2606                         transportLayerAddress.buf,ulInfo->list.array[ulidx]->\
2607                         uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.size);
2608                }
2609                CU_FREE(ulInfo->list.array[ulidx]->uLUPTNLInformation.choice.gTPTunnel,\
2610                      sizeof(GTPTunnel_t));
2611             }
2612          }
2613          if(ulInfo->list.array[ulidx]!=NULLP)
2614          {
2615             CU_FREE(ulInfo->list.array[ulidx],sizeof(ULUPTNLInformation_ToBeSetup_Item_t));
2616          }
2617       }
2618       CU_FREE(ulInfo->list.array,ulInfo->list.size);
2619    }
2620 }
2621 /*******************************************************************
2622  *
2623  * @brief Deallocating memory for BuildAndSendUESetReq
2624  *
2625  * @details
2626  *
2627  *    Function : FreeDRBSetup
2628  *
2629  *    Functionality:  Deallocating memory for BuildDRBSetup
2630  *
2631  * @params[in] DRBs_ToBeSetup_List_t *drbSet
2632  *
2633  * @return void
2634  *
2635  * ****************************************************************/
2636 void FreeDRBSetup(DRBs_ToBeSetup_List_t *drbSet)
2637 {
2638    DRBs_ToBeSetup_Item_t *drbSetItem;
2639    ProtocolExtensionContainer_4624P74_t *qosIeExt = NULLP;
2640
2641    uint8_t  flowidx = 0, drbidx = 0, qosCntIdx = 0;
2642
2643    /*BUG: Need to check drbSet->list.array is not Empty to procced with Deletion*/
2644    if(drbSet->list.array != NULLP)
2645    {
2646       for(drbidx=0; drbidx<drbSet->list.count; drbidx++)
2647       {
2648               if(drbSet->list.array[drbidx] != NULLP)
2649               {
2650                  drbSetItem =&drbSet->list.array[drbidx]->value.choice.DRBs_ToBeSetup_Item;
2651                  if(drbSetItem->qoSInformation.choice.choice_extension != NULLP)
2652                  {
2653                     if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
2654                                   qoS_Characteristics.choice.non_Dynamic_5QI !=NULLP)
2655                {
2656                    if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
2657                                           qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow!=NULLP)
2658                             {
2659                                if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
2660                                           qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume!=NULLP)
2661                                {
2662                                        if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sST.buf!=NULLP)
2663                                        {
2664                                           if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD!=NULLP)
2665                                           {
2666                                              if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD->buf!=NULLP)
2667                                              {
2668                                                      if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.\
2669                                                             flows_Mapped_To_DRB_List.list.array != NULLP)
2670                                                      {
2671                                                          for(flowidx=0;flowidx<drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.\
2672                                                                       flows_Mapped_To_DRB_List.list.count; flowidx++)
2673                                                          {
2674                                                              if(flowidx==0&&drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
2675                                                                            DRB_Information.flows_Mapped_To_DRB_List.list.array[flowidx]!=NULLP)
2676                                                              {
2677                                                                      if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
2678                                                                                 DRB_Information.flows_Mapped_To_DRB_List.list.array[flowidx]->qoSFlowLevelQoSParameters.\
2679                                                                                 qoS_Characteristics.choice.non_Dynamic_5QI!=NULLP)
2680                                                                      {
2681                                                                          if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
2682                                                                                    DRB_Information.flows_Mapped_To_DRB_List.list.array[flowidx]->qoSFlowLevelQoSParameters.\
2683                                                                                    qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow!=NULLP)
2684                                                                          {
2685                                                                                  if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
2686                                                                                  DRB_Information.flows_Mapped_To_DRB_List.list.array[flowidx]->qoSFlowLevelQoSParameters.\
2687                                                                                   qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume!=NULLP)
2688                                                                                   {
2689                                                                                       FreeULTnlInfo(&drbSetItem->uLUPTNLInformation_ToBeSetup_List);
2690                                                                                       CU_FREE(drbSetItem->uLConfiguration,sizeof(ULConfiguration_t));
2691
2692                                                                                       CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
2693                                                                                                    DRB_Information.flows_Mapped_To_DRB_List.list.array[flowidx]->qoSFlowLevelQoSParameters.\
2694                                                                                                    qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume,\
2695                                                                                                    sizeof(MaxDataBurstVolume_t));
2696                                                                                   }
2697                                                          CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
2698                                                                                            DRB_Information.flows_Mapped_To_DRB_List.list.array[flowidx]->qoSFlowLevelQoSParameters.\
2699                                                                                            qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow,sizeof(AveragingWindow_t));
2700                                                                          }
2701                                                                          CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
2702                                                                                        DRB_Information.flows_Mapped_To_DRB_List.list.array[flowidx]->qoSFlowLevelQoSParameters.\
2703                                                                                        qoS_Characteristics.choice.non_Dynamic_5QI,sizeof(NonDynamic5QIDescriptor_t));
2704                                                                      }
2705                                                             }
2706                                                             if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
2707                                                                      DRB_Information.flows_Mapped_To_DRB_List.list.array[flowidx]!=NULLP)
2708                                                             {
2709                                                                     CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
2710                                                                                   DRB_Information.flows_Mapped_To_DRB_List.list.array[flowidx],sizeof(Flows_Mapped_To_DRB_Item_t));
2711                                                             }
2712                                                         }
2713                                                         CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.\
2714                                                                       flows_Mapped_To_DRB_List.list.array,drbSetItem->qoSInformation.choice.choice_extension->value.\
2715                                                                       choice.DRB_Information.flows_Mapped_To_DRB_List.list.size);
2716                                                      }
2717                                                      CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD->buf,\
2718                                                              drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD->size);
2719                                             }
2720                                             CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD,\
2721                                                               sizeof(OCTET_STRING_t));
2722                                        }
2723                                        CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sST.buf,\
2724                                                     drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sST.size);
2725                                     }
2726                                     CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
2727                                             qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume,sizeof(MaxDataBurstVolume_t));
2728                             }
2729                        CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
2730                                          qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow,sizeof(AveragingWindow_t));
2731                          }
2732                          CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
2733                                        qoS_Characteristics.choice.non_Dynamic_5QI, sizeof(NonDynamic5QIDescriptor_t));
2734              }
2735              if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
2736                         iE_Extensions != NULLP)
2737              {
2738                 qosIeExt = (ProtocolExtensionContainer_4624P74_t *)drbSetItem->qoSInformation.choice.\
2739                                     choice_extension->value.choice.DRB_Information.dRB_QoS.iE_Extensions;
2740                  if(qosIeExt->list.array != NULLP)
2741                  {
2742                    for(qosCntIdx=0; qosCntIdx < qosIeExt->list.count; qosCntIdx++)
2743                    {
2744                       if(qosIeExt->list.array[qosCntIdx] != NULLP)
2745                       {
2746                          CU_FREE(qosIeExt->list.array[qosCntIdx], sizeof(QoSFlowLevelQoSParameters_ExtIEs_t));
2747                       }
2748                     }
2749                     CU_FREE(qosIeExt->list.array, qosIeExt->list.size);
2750                   }
2751                   CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
2752                                    iE_Extensions, sizeof(ProtocolExtensionContainer_4624P74_t));
2753               }
2754
2755                   CU_FREE(drbSetItem->qoSInformation.choice.choice_extension,sizeof(QoSInformation_ExtIEs_t));
2756                 }
2757                 CU_FREE(drbSet->list.array[drbidx],sizeof(DRBs_ToBeSetup_ItemIEs_t));
2758               }
2759       }
2760       CU_FREE(drbSet->list.array,drbSet->list.size);
2761    }
2762 }
2763
2764
2765 /*******************************************************************
2766  *
2767  * @brief Free the UE Setup Request
2768  *
2769  * @details
2770  *
2771  *    Function : FreeUeContextSetupReq
2772  *
2773  *    Functionality: Deallocate the memory of BuildUESetReq
2774  *
2775  * @params[in]  F1AP_PDU_t  *f1apMsg
2776  *
2777  * @return void
2778  *
2779  *
2780  * ****************************************************************/
2781 void FreeUeContextSetupReq(F1AP_PDU_t  *f1apMsg)
2782 {
2783    uint8_t idx, ieId;
2784    UEContextSetupRequest_t  *ueSetReq = NULLP;
2785
2786    if(f1apMsg != NULLP)
2787    {
2788       if(f1apMsg->choice.initiatingMessage != NULLP)
2789       {
2790          ueSetReq = &f1apMsg->choice.initiatingMessage->value.choice.UEContextSetupRequest;
2791          if(ueSetReq->protocolIEs.list.array != NULLP)
2792          {
2793             for(idx = 0; idx < ueSetReq->protocolIEs.list.count; idx++)
2794             {
2795                if(ueSetReq->protocolIEs.list.array[idx])
2796                {
2797                   switch(ueSetReq->protocolIEs.list.array[idx]->id)
2798                   {
2799                      case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
2800                         break;
2801                      case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
2802                         break;
2803                      case ProtocolIE_ID_id_SpCell_ID:
2804                         FreeNrcgi(&ueSetReq->protocolIEs.list.array[idx]->value.choice.NRCGI);
2805                         break;
2806                      case ProtocolIE_ID_id_ServCellIndex:
2807                         break;
2808                      case ProtocolIE_ID_id_SpCellULConfigured:
2809                         break;
2810                      case ProtocolIE_ID_id_CUtoDURRCInformation:
2811                         FreeCuToDuInfo(&ueSetReq->protocolIEs.list.array[idx]->value.choice.CUtoDURRCInformation);
2812                         break;
2813                      case ProtocolIE_ID_id_SCell_ToBeSetup_List:
2814                         FreeSplCellList(&ueSetReq->protocolIEs.list.array[idx]->value.choice.SCell_ToBeSetup_List);
2815                         break;
2816                      case ProtocolIE_ID_id_SRBs_ToBeSetup_List:
2817                         FreeSRBSetup(&ueSetReq->protocolIEs.list.array[idx]->value.choice.SRBs_ToBeSetup_List);
2818                         break;
2819                      case ProtocolIE_ID_id_DRBs_ToBeSetup_List:
2820                         FreeDRBSetup(&ueSetReq->protocolIEs.list.array[idx]->value.choice.DRBs_ToBeSetup_List);
2821                         break;
2822                      case ProtocolIE_ID_id_RRCContainer:
2823                         if(ueSetReq->protocolIEs.list.array[idx]->value.choice.RRCContainer.buf != NULLP)
2824                         {
2825                            CU_FREE(ueSetReq->protocolIEs.list.array[idx]->value.choice.RRCContainer.buf, \
2826                                  ueSetReq->protocolIEs.list.array[idx]->value.choice.RRCContainer.size);
2827                         }
2828                         break;
2829                      default:
2830                         DU_LOG("\nERROR  -->  F1AP: Invalid event type %ld", ueSetReq->protocolIEs.list.array[idx]->id);
2831                         break;
2832                   }
2833                }
2834                /*BUG: Break is causing to exit the for Loop before complete traversing and freeing of each IE*/
2835             }
2836             for(ieId=0; ieId<idx; ieId++)
2837             {
2838                if(ueSetReq->protocolIEs.list.array[ieId] != NULLP)
2839                {
2840                   CU_FREE(ueSetReq->protocolIEs.list.array[ieId],sizeof(UEContextSetupRequestIEs_t));
2841                }
2842             }
2843             CU_FREE(ueSetReq->protocolIEs.list.array,ueSetReq->protocolIEs.list.size);
2844          }
2845          CU_FREE(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
2846       }
2847       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
2848    }
2849 }
2850
2851 /**Filling cell group info **/
2852 /*******************************************************************
2853  *
2854  * @brief Build Control resource set to add/modify list
2855  *
2856  * @details
2857  *
2858  *    Function : BuildControlRSetToAddModList
2859  *
2860  *    Functionality: Build Control resource set to add/modify list
2861  *
2862  * @params[in]
2863  * struct PDCCH_Config__controlResourceSetToAddModList *controlRSetList
2864  *
2865  * @return ROK     - success
2866  *         RFAILED - failure
2867  *
2868  * ****************************************************************/
2869    uint8_t BuildControlRSetToAddModList
2870 (
2871  struct PDCCH_Config__controlResourceSetToAddModList *controlRSetList
2872  )
2873 {
2874    uint8_t idx;
2875    uint8_t elementCnt;
2876    uint8_t numBytes, bitsUnused;
2877    struct ControlResourceSet *controlRSet;
2878    uint8_t freqDomainResource[FREQ_DOM_RSRC_SIZE] = {0};
2879    uint8_t coreset0EndPrb, coreset1StartPrb, coreset1NumPrb;
2880
2881    elementCnt = 1;
2882    controlRSetList->list.count = elementCnt;
2883    controlRSetList->list.size = \
2884                                 elementCnt * sizeof(struct ControlResourceSet *);
2885
2886    controlRSetList->list.array = NULLP;
2887    CU_ALLOC(controlRSetList->list.array, controlRSetList->list.size);
2888    if(!controlRSetList->list.array)
2889    {
2890       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
2891       return RFAILED;
2892    }
2893
2894    for(idx = 0; idx < elementCnt; idx++)
2895    {
2896       controlRSetList->list.array[idx] = NULLP;
2897       CU_ALLOC(controlRSetList->list.array[idx], sizeof(struct ControlResourceSet));
2898       if(!controlRSetList->list.array[idx])
2899       {
2900          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
2901          return RFAILED;
2902       }
2903    }
2904
2905    idx=0;
2906    controlRSet = controlRSetList->list.array[idx];
2907    controlRSet->controlResourceSetId = PDCCH_CTRL_RSRC_SET_ONE_ID;
2908
2909    /* Values harcoded according to our design:
2910     * size 6 bytes
2911     * 3 LSBs unsued
2912     * Bit string stored ff0000000000
2913     */
2914    numBytes = 6;
2915    bitsUnused = 3;
2916    controlRSet->frequencyDomainResources.size = numBytes * sizeof(uint8_t);
2917    controlRSet->frequencyDomainResources.buf = NULLP;
2918    CU_ALLOC(controlRSet->frequencyDomainResources.buf, \
2919          controlRSet->frequencyDomainResources.size);
2920    if(!controlRSet->frequencyDomainResources.buf)
2921    {
2922       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
2923       return RFAILED;
2924    }
2925
2926    memset(controlRSet->frequencyDomainResources.buf, 0, FREQ_DOM_RSRC_SIZE);
2927    coreset0EndPrb = CORESET0_END_PRB;
2928    coreset1StartPrb = coreset0EndPrb + 6;
2929    coreset1NumPrb = CORESET1_NUM_PRB;
2930    /* calculate the PRBs */
2931    fillCoresetFeqDomAllocMap(((coreset1StartPrb)/6), (coreset1NumPrb/6), freqDomainResource);
2932    memcpy(controlRSet->frequencyDomainResources.buf, freqDomainResource, FREQ_DOM_RSRC_SIZE);
2933    controlRSet->frequencyDomainResources.bits_unused = bitsUnused;
2934
2935    controlRSet->duration = PDCCH_CTRL_RSRC_SET_ONE_DURATION;
2936    controlRSet->cce_REG_MappingType.present = \
2937                                               ControlResourceSet__cce_REG_MappingType_PR_nonInterleaved;
2938
2939    controlRSet->precoderGranularity = PDCCH_CTRL_RSRC_SET_ONE_PRECOD_GRANULARITY;
2940    controlRSet->tci_StatesPDCCH_ToAddList = NULLP;
2941    controlRSet->tci_StatesPDCCH_ToReleaseList = NULLP;
2942    controlRSet->tci_PresentInDCI = NULLP;
2943 #if 0
2944    uint8_t tciStateIdx;
2945
2946    CU_ALLOC(controlRset->tci_StatesPDCCH_ToAddList, \
2947          sizeof(struct ControlResourceSet__tci_StatesPDCCH_ToAddList));
2948    if(!controlRset->tci_StatesPDCCH_ToAddList)
2949    {
2950       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
2951       return RFAILED;
2952    }
2953
2954    elementCnt = 1;
2955    controlRset->tci_StatesPDCCH_ToAddList->list.count = elementCnt;
2956    controlRset->tci_StatesPDCCH_ToAddList->list.size = elementCnt * sizeof(TCI_StateId_t *);
2957    CU_ALLOC(controlRset->tci_StatesPDCCH_ToAddList->list.array, \
2958          controlRset->tci_StatesPDCCH_ToAddList->list.size)
2959       if(!controlRset->tci_StatesPDCCH_ToAddList->list.array)
2960       {
2961          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
2962          return RFAILED;
2963       }
2964
2965    for(tciStateIdx = 0; tciStateIdx <elementCntl; tciStateIdx++)
2966    {
2967       CU_ALLOC(controlRset->tci_StatesPDCCH_ToAddList->list.array[tciStateIdx], sizeof(TCI_StateId_t));
2968       if(!controlRset->tci_StatesPDCCH_ToAddList->list.array[tciStateIdx])
2969       {
2970          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
2971          return RFAILED;
2972       }
2973    }
2974
2975    tciStateIdx = 0;
2976    /* TODO */
2977    *(controlRset->tci_StatesPDCCH_ToAddList->list.array[tciStateIdx]);
2978
2979    CU_ALLOC(controlRset->tci_PresentInDCI, sizeof(long));
2980    if(!controlRset->tci_PresentInDCI)
2981    {
2982       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
2983       return RFAILED;
2984    }
2985    /* TODO */
2986    *(controlRset->tci_PresentInDCI);
2987 #endif
2988
2989    controlRSet->pdcch_DMRS_ScramblingID = NULLP;
2990    CU_ALLOC(controlRSet->pdcch_DMRS_ScramblingID, sizeof(long));
2991    if(!controlRSet->pdcch_DMRS_ScramblingID)
2992    {
2993       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
2994       return RFAILED;
2995    }
2996    *(controlRSet->pdcch_DMRS_ScramblingID) = SCRAMBLING_ID;
2997
2998    return ROK;
2999 } /* End BuildControlRSetToAddModList */
3000
3001 /*******************************************************************
3002  *
3003  * @brief Build search space to add/modify list
3004  *
3005  * @details
3006  *
3007  *    Function : BuildSearchSpcToAddModList
3008  *
3009  *    Functionality: Build search space to add/modify list
3010  *
3011  * @params[in]
3012  * @return ROK     - success
3013  *         RFAILED - failure
3014  *
3015  * ****************************************************************/
3016    uint8_t BuildSearchSpcToAddModList
3017 (
3018  struct PDCCH_Config__searchSpacesToAddModList *searchSpcList
3019  )
3020 {
3021    uint8_t idx;
3022    uint8_t numBytes;
3023    uint8_t byteIdx;
3024    uint8_t bitsUnused;
3025    uint8_t elementCnt;
3026    struct SearchSpace *searchSpc;
3027
3028    elementCnt = 1;
3029    searchSpcList->list.count = elementCnt;
3030    searchSpcList->list.size = elementCnt * sizeof(struct SearchSpace *);
3031
3032    searchSpcList->list.array = NULLP;
3033    CU_ALLOC(searchSpcList->list.array, searchSpcList->list.size);
3034    if(!searchSpcList->list.array)
3035    {
3036       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3037       return RFAILED;
3038    }
3039
3040    for(idx = 0; idx < elementCnt; idx++)
3041    {
3042       searchSpcList->list.array[idx] = NULLP;
3043       CU_ALLOC(searchSpcList->list.array[idx], sizeof(struct SearchSpace));
3044       if(!searchSpcList->list.array[idx])
3045       {
3046          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3047          return RFAILED;
3048       }
3049    }
3050
3051    idx = 0;
3052    searchSpc = searchSpcList->list.array[idx];
3053
3054    searchSpc->searchSpaceId = PDCCH_SRCH_SPC_TWO_ID;
3055
3056    searchSpc->controlResourceSetId = NULLP;
3057    CU_ALLOC(searchSpc->controlResourceSetId, sizeof(ControlResourceSetId_t));
3058    if(!searchSpc->controlResourceSetId)
3059    {
3060       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3061       return RFAILED;
3062    }
3063    *(searchSpc->controlResourceSetId) = PDCCH_CTRL_RSRC_SET_ONE_ID;
3064
3065    searchSpc->monitoringSlotPeriodicityAndOffset = NULLP;
3066    CU_ALLOC(searchSpc->monitoringSlotPeriodicityAndOffset, \
3067          sizeof(struct SearchSpace__monitoringSlotPeriodicityAndOffset));
3068    if(!searchSpc->monitoringSlotPeriodicityAndOffset)
3069    {
3070       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3071       return RFAILED;
3072    }
3073    searchSpc->monitoringSlotPeriodicityAndOffset->present = \
3074                                                             SearchSpace__monitoringSlotPeriodicityAndOffset_PR_sl1;
3075
3076    searchSpc->duration = NULLP;
3077    searchSpc->monitoringSymbolsWithinSlot = NULLP;
3078    CU_ALLOC(searchSpc->monitoringSymbolsWithinSlot, sizeof(BIT_STRING_t));
3079    if(!searchSpc->monitoringSymbolsWithinSlot)
3080    {
3081       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3082       return RFAILED;
3083    }
3084
3085    /* Values taken from reference logs :
3086     * size 2 bytes
3087     * 2 LSBs unsued
3088     * Bit string stores 8000
3089     */
3090    numBytes = 2;
3091    bitsUnused = 2;
3092
3093    searchSpc->monitoringSymbolsWithinSlot->size = numBytes * sizeof(uint8_t);
3094    searchSpc->monitoringSymbolsWithinSlot->buf = NULLP;
3095    CU_ALLOC(searchSpc->monitoringSymbolsWithinSlot->buf, \
3096          searchSpc->monitoringSymbolsWithinSlot->size);
3097    if(!searchSpc->monitoringSymbolsWithinSlot->buf)
3098    {
3099       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3100       return RFAILED;
3101    }
3102
3103    byteIdx = 0;
3104    searchSpc->monitoringSymbolsWithinSlot->buf[byteIdx++] = \
3105                                                             PDCCH_SYMBOL_WITHIN_SLOT /* setting MSB to 128 i.e. 0x80 */;
3106    searchSpc->monitoringSymbolsWithinSlot->buf[byteIdx++] = 0;
3107    searchSpc->monitoringSymbolsWithinSlot->bits_unused = bitsUnused;
3108
3109    searchSpc->nrofCandidates = NULLP;
3110    CU_ALLOC(searchSpc->nrofCandidates, sizeof(struct SearchSpace__nrofCandidates));
3111    if(!searchSpc->nrofCandidates)
3112    {
3113       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3114       return RFAILED;
3115    }
3116
3117    searchSpc->nrofCandidates->aggregationLevel1 = \
3118                                                   PDCCH_SRCH_SPC_TWO_AGG_LVL1_CANDIDATE;
3119    searchSpc->nrofCandidates->aggregationLevel2 = \
3120                                                   PDCCH_SRCH_SPC_TWO_AGG_LVL2_CANDIDATE;
3121    searchSpc->nrofCandidates->aggregationLevel4 = \
3122                                                   PDCCH_SRCH_SPC_TWO_AGG_LVL4_CANDIDATE;
3123    searchSpc->nrofCandidates->aggregationLevel8 = \
3124                                                   PDCCH_SRCH_SPC_TWO_AGG_LVL8_CANDIDATE;
3125    searchSpc->nrofCandidates->aggregationLevel16 = \
3126                                                    PDCCH_SRCH_SPC_TWO_AGG_LVL16_CANDIDATE;
3127
3128    searchSpc->searchSpaceType = NULLP;
3129    CU_ALLOC(searchSpc->searchSpaceType, sizeof(struct SearchSpace__searchSpaceType));
3130    if(!searchSpc->searchSpaceType)
3131    {
3132       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3133       return RFAILED;
3134    }
3135
3136    searchSpc->searchSpaceType->present = SearchSpace__searchSpaceType_PR_ue_Specific;
3137
3138    searchSpc->searchSpaceType->choice.ue_Specific = NULLP;
3139    CU_ALLOC(searchSpc->searchSpaceType->choice.ue_Specific, \
3140          sizeof(struct SearchSpace__searchSpaceType__ue_Specific));
3141    if(!searchSpc->searchSpaceType->choice.ue_Specific)
3142    {
3143       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3144       return RFAILED;
3145    }
3146    searchSpc->searchSpaceType->choice.ue_Specific->dci_Formats = \
3147                                                                  PDCCH_SRCH_SPC_TWO_UE_SPEC_DCI_FORMAT;
3148
3149    return ROK;
3150 }/* End BuildSearchSpcToAddModList */
3151
3152 /*******************************************************************
3153  *
3154  * @brief Builds BWP DL dedicated PDCCH config
3155  *
3156  * @details
3157  *
3158  *    Function : BuildBWPDlDedPdcchCfg
3159  *
3160  *    Functionality: Builds BWP DL dedicated PDCCH config
3161  *
3162  * @params[in] struct PDCCH_Config *pdcchCfg
3163  *
3164  * @return ROK     - success
3165  *         RFAILED - failure
3166  *
3167  * ****************************************************************/
3168 uint8_t BuildBWPDlDedPdcchCfg(struct PDCCH_Config *pdcchCfg)
3169 {
3170    pdcchCfg->controlResourceSetToAddModList = NULLP;
3171    CU_ALLOC(pdcchCfg->controlResourceSetToAddModList, \
3172          sizeof(struct PDCCH_Config__controlResourceSetToAddModList));
3173    if(!pdcchCfg->controlResourceSetToAddModList)
3174    {
3175       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdcchCfg");
3176       return RFAILED;
3177    }
3178
3179    if(BuildControlRSetToAddModList(pdcchCfg->controlResourceSetToAddModList) != ROK)
3180    {
3181       return RFAILED;
3182    }
3183
3184    pdcchCfg->controlResourceSetToReleaseList = NULLP;
3185
3186    pdcchCfg->searchSpacesToAddModList = NULLP;
3187    CU_ALLOC(pdcchCfg->searchSpacesToAddModList, \
3188          sizeof(struct PDCCH_Config__searchSpacesToAddModList));
3189    if(!pdcchCfg->searchSpacesToAddModList)
3190    {
3191       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdcchCfg");
3192       return RFAILED;
3193    }
3194
3195    if(BuildSearchSpcToAddModList(pdcchCfg->searchSpacesToAddModList) != ROK)
3196    {
3197       return RFAILED;
3198    }
3199
3200    pdcchCfg->searchSpacesToReleaseList = NULLP;
3201    pdcchCfg->downlinkPreemption = NULLP;
3202    pdcchCfg->tpc_PUSCH = NULLP;
3203    pdcchCfg->tpc_PUCCH = NULLP;
3204    pdcchCfg->tpc_SRS = NULLP;
3205
3206    return ROK;
3207 }
3208
3209 /*******************************************************************
3210  *
3211  * @brief Builds DMRS DL PDSCH Mapping type A
3212  *
3213  * @details
3214  *
3215  *    Function : BuildDMRSDLPdschMapTypeA
3216  *
3217  *    Functionality: Builds DMRS DL PDSCH Mapping type A
3218  *
3219  * @params[in]
3220  * struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA *dmrsDlCfg
3221  * @return ROK     - success
3222  *         RFAILED - failure
3223  *
3224  * ****************************************************************/
3225    uint8_t BuildDMRSDLPdschMapTypeA
3226 (
3227  struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA *dmrsDlCfg
3228  )
3229 {
3230    dmrsDlCfg->present = PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA_PR_setup;
3231    dmrsDlCfg->choice.setup = NULLP;
3232    CU_ALLOC(dmrsDlCfg->choice.setup, sizeof(struct DMRS_DownlinkConfig));
3233    if(!dmrsDlCfg->choice.setup)
3234    {
3235       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
3236       return RFAILED;
3237    }
3238
3239    dmrsDlCfg->choice.setup->dmrs_Type = NULLP;
3240    dmrsDlCfg->choice.setup->dmrs_AdditionalPosition = NULLP;
3241    CU_ALLOC(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition, sizeof(long));
3242    if(!dmrsDlCfg->choice.setup->dmrs_AdditionalPosition)
3243    {
3244       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSDLPdschMapTypeA");
3245       return RFAILED;
3246    }
3247    *(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition) = DMRS_ADDITIONAL_POS;
3248
3249    dmrsDlCfg->choice.setup->maxLength = NULLP;
3250    dmrsDlCfg->choice.setup->scramblingID0 = NULLP;
3251    dmrsDlCfg->choice.setup->scramblingID1 = NULLP;
3252    dmrsDlCfg->choice.setup->phaseTrackingRS = NULLP;
3253
3254    return ROK;
3255 }
3256
3257 /*******************************************************************
3258  *
3259  * @brief Builds TCI states to add/modify list
3260  *
3261  * @details
3262  *
3263  *    Function : BuildTCIStatesToAddModList
3264  *
3265  *    Functionality:Builds TCI states to add/modify list
3266  *
3267  * @params[in]
3268  * struct PDSCH_Config__tci_StatesToAddModList *tciStatesList
3269  *
3270  * @return ROK     - success
3271  *         RFAILED - failure
3272  *
3273  * ****************************************************************/
3274 uint8_t BuildTCIStatesToAddModList(struct PDSCH_Config__tci_StatesToAddModList *tciStatesList)
3275 {
3276    return ROK;
3277 }
3278
3279 /*******************************************************************
3280  *
3281  * @brief Builds PDSCH time domain allocation list
3282  *
3283  * @details
3284  *
3285  *    Function : BuildPdschTimeDomAllocList
3286  *
3287  *    Functionality: Builds PDSCH time domain allocation list
3288  *
3289  * @params[in]
3290  * struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList
3291  *
3292  * @return ROK     - success
3293  *         RFAILED - failure
3294  *
3295  * ****************************************************************/
3296    uint8_t BuildPdschTimeDomAllocList
3297 (
3298  struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList
3299  )
3300 {
3301    uint8_t idx;
3302    uint8_t elementCnt;
3303    struct PDSCH_TimeDomainResourceAllocation *timeDomAlloc;
3304
3305    timeDomAllocList->present = \
3306                                PDSCH_Config__pdsch_TimeDomainAllocationList_PR_setup;
3307
3308    timeDomAllocList->choice.setup = NULLP;
3309    CU_ALLOC(timeDomAllocList->choice.setup, \
3310          sizeof(struct PDSCH_TimeDomainResourceAllocationList));
3311    if(!timeDomAllocList->choice.setup)
3312    {
3313       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
3314       return RFAILED;
3315    }
3316
3317    elementCnt = 2;
3318    timeDomAllocList->choice.setup->list.count = elementCnt;
3319    timeDomAllocList->choice.setup->list.size = \
3320                                                elementCnt * sizeof(struct PDSCH_TimeDomainResourceAllocation *);
3321
3322    timeDomAllocList->choice.setup->list.array = NULLP;
3323    CU_ALLOC(timeDomAllocList->choice.setup->list.array, \
3324          timeDomAllocList->choice.setup->list.size);
3325    if(!timeDomAllocList->choice.setup->list.array)
3326    {
3327       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
3328       return RFAILED;
3329    }
3330
3331    for(idx = 0; idx < elementCnt; idx++)
3332    {
3333       timeDomAllocList->choice.setup->list.array[idx] = NULLP;
3334       CU_ALLOC(timeDomAllocList->choice.setup->list.array[idx], \
3335             sizeof(struct PDSCH_TimeDomainResourceAllocation));
3336       if(!timeDomAllocList->choice.setup->list.array[idx])
3337       {
3338          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
3339          return RFAILED;
3340       }
3341    }
3342
3343    idx = 0;
3344    timeDomAlloc = timeDomAllocList->choice.setup->list.array[idx];
3345    CU_ALLOC(timeDomAlloc->k0, sizeof(long));
3346    if(!timeDomAlloc->k0)
3347    {
3348        DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
3349        return RFAILED;
3350    }
3351    *(timeDomAlloc->k0) = 0;
3352    timeDomAlloc->mappingType = PDSCH_MAPPING_TYPE_A;
3353    timeDomAlloc->startSymbolAndLength = 66;
3354
3355    idx++;
3356    timeDomAlloc = timeDomAllocList->choice.setup->list.array[idx];
3357    CU_ALLOC(timeDomAlloc->k0, sizeof(long));
3358    if(!timeDomAlloc->k0)
3359    {
3360       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
3361       return RFAILED;
3362    }
3363    *(timeDomAlloc->k0) = 1;
3364    timeDomAlloc->mappingType = PDSCH_MAPPING_TYPE_A;
3365    timeDomAlloc->startSymbolAndLength = 66;
3366
3367    return ROK;
3368 }
3369
3370 /*******************************************************************
3371  *
3372  * @brief Builds PDSCH PRB Bundling type
3373  *
3374  * @details
3375  *
3376  *    Function : BuildPdschPrbBundlingType
3377  *
3378  *    Functionality: Builds PDSCH PRB Bundling type
3379  *
3380  * @params[in]
3381  * struct PDSCH_Config__prb_BundlingType *prbBndlType
3382  *
3383  * @return ROK     - success
3384  *         RFAILED - failure
3385  *
3386  * ****************************************************************/
3387    uint8_t BuildPdschPrbBundlingType
3388 (
3389  struct PDSCH_Config__prb_BundlingType *prbBndlType
3390  )
3391 {
3392    prbBndlType->present = PDSCH_Config__prb_BundlingType_PR_staticBundling;
3393
3394    prbBndlType->choice.staticBundling = NULLP;
3395    CU_ALLOC(prbBndlType->choice.staticBundling, \
3396          sizeof(struct PDSCH_Config__prb_BundlingType__staticBundling));
3397    if(!prbBndlType->choice.staticBundling)
3398    {
3399       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschPrbBundlingType");
3400       return RFAILED;
3401    }
3402    prbBndlType->choice.staticBundling->bundleSize = NULLP;
3403
3404    return ROK;
3405 }
3406
3407 /*******************************************************************
3408  *
3409  * @brief Builds BWP DL dedicated PDSCH config
3410  *
3411  * @details
3412  *
3413  *    Function : BuildBWPDlDedPdschCfg
3414  *
3415  *    Functionality: Builds BWP DL dedicated PDSCH config
3416  *
3417  * @params[in] struct PDSCH_Config *pdschCfg
3418  *
3419  * @return ROK     - success
3420  *         RFAILED - failure
3421  *
3422  * ****************************************************************/
3423 uint8_t BuildBWPDlDedPdschCfg(struct PDSCH_Config *pdschCfg)
3424 {
3425    pdschCfg->dataScramblingIdentityPDSCH = NULLP;
3426
3427    pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA = NULLP;
3428    CU_ALLOC(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA, \
3429          sizeof(struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA));
3430    if(!pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA)
3431    {
3432       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
3433       return RFAILED;
3434    }
3435
3436    if(BuildDMRSDLPdschMapTypeA(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA) != ROK)
3437    {
3438       return RFAILED;
3439    }
3440
3441    pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeB = NULLP;
3442    pdschCfg->tci_StatesToAddModList = NULLP;
3443    pdschCfg->tci_StatesToReleaseList = NULLP;
3444    pdschCfg->vrb_ToPRB_Interleaver = NULLP;
3445 #if 0
3446    CU_ALLOC(pdschCfg->tci_StatesToAddModList, sizeof(struct PDSCH_Config__tci_StatesToAddModList));
3447    if(!pdschCfg->tci_StatesToAddModList)
3448    {
3449       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
3450       return RFAILED;
3451    }
3452    if(BuildTCIStatesToAddModList(pdschCfg->tci_StatesToAddModList) != ROK)
3453    {
3454       return RFAILED;
3455    }
3456 #endif
3457
3458    pdschCfg->resourceAllocation = RES_ALLOC_TYPE;
3459
3460    pdschCfg->pdsch_TimeDomainAllocationList = NULLP;
3461    CU_ALLOC(pdschCfg->pdsch_TimeDomainAllocationList, \
3462          sizeof(struct PDSCH_Config__pdsch_TimeDomainAllocationList));
3463    if(!pdschCfg->pdsch_TimeDomainAllocationList)
3464    {
3465       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
3466       return RFAILED;
3467    }
3468    if(BuildPdschTimeDomAllocList(pdschCfg->pdsch_TimeDomainAllocationList) != ROK)
3469    {
3470       return RFAILED;
3471    }
3472    pdschCfg->pdsch_AggregationFactor = NULLP;
3473    pdschCfg->rateMatchPatternToAddModList = NULLP;
3474    pdschCfg->rateMatchPatternToReleaseList = NULLP;
3475    pdschCfg->rateMatchPatternGroup1 = NULLP;
3476    pdschCfg->rateMatchPatternGroup2 = NULLP;
3477    pdschCfg->rbg_Size = PDSCH_RBG_SIZE;
3478    pdschCfg->mcs_Table = NULLP;
3479
3480    pdschCfg->maxNrofCodeWordsScheduledByDCI = NULLP;
3481    CU_ALLOC(pdschCfg->maxNrofCodeWordsScheduledByDCI, sizeof(long));
3482    if(!pdschCfg->maxNrofCodeWordsScheduledByDCI)
3483    {
3484       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
3485       return RFAILED;
3486    }
3487    *(pdschCfg->maxNrofCodeWordsScheduledByDCI) = PDSCH_MAX_CODEWORD_SCH_BY_DCI;
3488
3489    if(BuildPdschPrbBundlingType(&pdschCfg->prb_BundlingType) != ROK)
3490    {
3491       return RFAILED;
3492    }
3493
3494    pdschCfg->zp_CSI_RS_ResourceToAddModList = NULLP;
3495    pdschCfg->zp_CSI_RS_ResourceToReleaseList = NULLP;
3496    pdschCfg->aperiodic_ZP_CSI_RS_ResourceSetsToAddModList = NULLP;
3497    pdschCfg->aperiodic_ZP_CSI_RS_ResourceSetsToReleaseList = NULLP;
3498    pdschCfg->sp_ZP_CSI_RS_ResourceSetsToAddModList = NULLP;
3499    pdschCfg->sp_ZP_CSI_RS_ResourceSetsToReleaseList = NULLP;
3500    pdschCfg->p_ZP_CSI_RS_ResourceSet = NULLP;
3501
3502    return ROK;
3503 }
3504
3505 /*******************************************************************
3506  *
3507  * @brief Builds intitial DL BWP
3508  * @details
3509  *
3510  *    Function : BuildInitialDlBWP
3511  *
3512  *    Functionality: Builds intitial DL BWP in spCellCfgDed
3513  *
3514  * @params[in] BWP_DownlinkDedicated_t *dlBwp
3515  *
3516  * @return ROK     - success
3517  *         RFAILED - failure
3518  *
3519  * ****************************************************************/
3520 uint8_t BuildInitialDlBWP(BWP_DownlinkDedicated_t *dlBwp)
3521 {
3522    dlBwp->pdcch_Config = NULLP;
3523    CU_ALLOC(dlBwp->pdcch_Config, sizeof(struct BWP_DownlinkDedicated__pdcch_Config));
3524    if(!dlBwp->pdcch_Config)
3525    {
3526       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failure in BuildInitialDlBWP");
3527       return RFAILED;
3528    }
3529    dlBwp->pdcch_Config->present = BWP_DownlinkDedicated__pdcch_Config_PR_setup;
3530
3531    dlBwp->pdcch_Config->choice.setup = NULLP;
3532    CU_ALLOC(dlBwp->pdcch_Config->choice.setup, sizeof(struct PDCCH_Config));
3533    if(!dlBwp->pdcch_Config->choice.setup)
3534    {
3535       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failure in BuildInitialDlBWP");
3536       return RFAILED;
3537    }
3538    if(BuildBWPDlDedPdcchCfg(dlBwp->pdcch_Config->choice.setup) != ROK)
3539    {
3540       return RFAILED;
3541    }
3542
3543    dlBwp->pdsch_Config = NULLP;
3544    CU_ALLOC(dlBwp->pdsch_Config, sizeof(struct BWP_DownlinkDedicated__pdsch_Config));
3545    if(!dlBwp->pdsch_Config)
3546    {
3547       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failure in BuildInitialDlBWP");
3548       return RFAILED;
3549    }
3550    dlBwp->pdsch_Config->present = BWP_DownlinkDedicated__pdsch_Config_PR_setup;
3551
3552    dlBwp->pdsch_Config->choice.setup = NULLP;
3553    CU_ALLOC(dlBwp->pdsch_Config->choice.setup, sizeof(struct PDSCH_Config));
3554    if(!dlBwp->pdsch_Config->choice.setup)
3555    {
3556       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failure in BuildInitialDlBWP");
3557       return RFAILED;
3558    }
3559
3560    if(BuildBWPDlDedPdschCfg(dlBwp->pdsch_Config->choice.setup) != ROK)
3561    {
3562       return RFAILED;
3563    }
3564
3565    dlBwp->sps_Config = NULLP;
3566    dlBwp->radioLinkMonitoringConfig = NULLP;
3567    return ROK;
3568 }
3569
3570 /*******************************************************************
3571  *
3572  * @brief Builds DMRS UL Pusch Mapping type A
3573  *
3574  * @details
3575  *
3576  *    Function : BuildDMRSULPuschMapTypeA
3577  *
3578  *    Functionality: Builds DMRS UL Pusch Mapping type A
3579  *
3580  * @params[in]
3581  *    struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA *dmrsUlCfg
3582  * @return ROK     - success
3583  *         RFAILED - failure
3584  *
3585  * ****************************************************************/
3586    uint8_t BuildDMRSULPuschMapTypeA
3587 (
3588  struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA *dmrsUlCfg
3589  )
3590 {
3591    dmrsUlCfg->present = PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA_PR_setup;
3592    dmrsUlCfg->choice.setup= NULLP;
3593    CU_ALLOC(dmrsUlCfg->choice.setup, sizeof(DMRS_UplinkConfig_t));
3594    if(!dmrsUlCfg->choice.setup)
3595    {
3596       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
3597       return RFAILED;
3598    }
3599
3600    dmrsUlCfg->choice.setup->dmrs_Type = NULLP;
3601    dmrsUlCfg->choice.setup->dmrs_AdditionalPosition = NULLP;
3602    CU_ALLOC(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition, sizeof(long));
3603    if(!dmrsUlCfg->choice.setup->dmrs_AdditionalPosition)
3604    {
3605       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
3606       return RFAILED;
3607    }
3608    *(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition) = DMRS_ADDITIONAL_POS;
3609
3610    dmrsUlCfg->choice.setup->phaseTrackingRS = NULLP;
3611    dmrsUlCfg->choice.setup->maxLength = NULLP;
3612    dmrsUlCfg->choice.setup->transformPrecodingDisabled = NULLP;
3613    CU_ALLOC(dmrsUlCfg->choice.setup->transformPrecodingDisabled, \
3614          sizeof(struct DMRS_UplinkConfig__transformPrecodingDisabled));
3615    if(!dmrsUlCfg->choice.setup->transformPrecodingDisabled)
3616    {
3617       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
3618       return RFAILED;
3619    }
3620
3621    dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0 = NULLP;
3622    CU_ALLOC(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0,\
3623          sizeof(long));
3624    if(!dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0)
3625    {
3626       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
3627       return RFAILED;
3628    }
3629    *(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0) = SCRAMBLING_ID;
3630
3631    dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID1 = NULLP;
3632    dmrsUlCfg->choice.setup->transformPrecodingEnabled = NULLP;
3633    return ROK;
3634 }
3635
3636 /*******************************************************************
3637  *
3638  * @brief Build PUSCH time domain allocation list
3639  *
3640  * @details
3641  *
3642  *    Function : BuildPuschTimeDomAllocList
3643  *
3644  *    Functionality: Build PUSCH time domain allocation list
3645  *
3646  * @params[in]
3647  * struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList
3648  *
3649  * @return ROK     - success
3650  *         RFAILED - failure
3651  *
3652  * ****************************************************************/
3653    uint8_t BuildPuschTimeDomAllocList
3654 (
3655  struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList
3656  )
3657 {
3658    uint8_t idx;
3659    uint8_t elementCnt;
3660    PUSCH_TimeDomainResourceAllocation_t  *timeDomAlloc;
3661
3662    timeDomAllocList->present = PUSCH_Config__pusch_TimeDomainAllocationList_PR_setup;
3663    timeDomAllocList->choice.setup = NULLP;
3664    CU_ALLOC(timeDomAllocList->choice.setup, \
3665          sizeof(struct PUSCH_TimeDomainResourceAllocationList));
3666    if(!timeDomAllocList->choice.setup)
3667    {
3668       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
3669       return RFAILED;
3670    }
3671
3672    elementCnt = 2;
3673    timeDomAllocList->choice.setup->list.count = elementCnt;
3674    timeDomAllocList->choice.setup->list.size = \
3675                                                elementCnt * sizeof(PUSCH_TimeDomainResourceAllocation_t *);
3676    timeDomAllocList->choice.setup->list.array = NULLP;
3677    CU_ALLOC(timeDomAllocList->choice.setup->list.array, \
3678          timeDomAllocList->choice.setup->list.size);
3679    if(!timeDomAllocList->choice.setup->list.array)
3680    {
3681       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
3682       return RFAILED;
3683    }
3684
3685    for(idx = 0; idx < elementCnt; idx++)
3686    {
3687       timeDomAllocList->choice.setup->list.array[idx] = NULLP;
3688       CU_ALLOC(timeDomAllocList->choice.setup->list.array[idx],\
3689             sizeof(PUSCH_TimeDomainResourceAllocation_t));
3690       if(!timeDomAllocList->choice.setup->list.array[idx])
3691       {
3692          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
3693          return RFAILED;
3694       }
3695    }
3696
3697    idx = 0;
3698    timeDomAlloc = timeDomAllocList->choice.setup->list.array[idx];
3699    CU_ALLOC(timeDomAlloc->k2, sizeof(long));
3700    if(!timeDomAlloc->k2)
3701    {
3702       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
3703       return RFAILED;
3704    }
3705    *(timeDomAlloc->k2) = PUSCH_K2_CFG1;
3706    timeDomAlloc->mappingType = PUSCH_MAPPING_TYPE_A;
3707    timeDomAlloc->startSymbolAndLength = 66;
3708
3709    idx++;
3710    timeDomAlloc = timeDomAllocList->choice.setup->list.array[idx];
3711    CU_ALLOC(timeDomAlloc->k2, sizeof(long));
3712    if(!timeDomAlloc->k2)
3713    {
3714        DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
3715        return RFAILED;
3716    }
3717    *(timeDomAlloc->k2) = PUSCH_K2_CFG2;
3718    timeDomAlloc->mappingType = PUSCH_MAPPING_TYPE_A;
3719    timeDomAlloc->startSymbolAndLength = 66;
3720
3721    return ROK;
3722 }
3723
3724 /*******************************************************************
3725  *
3726  * @brief Builds BWP UL dedicated PUSCH Config
3727  *
3728  * @details
3729  *
3730  *    Function : BuildBWPUlDedPuschCfg
3731  *
3732  *    Functionality:
3733  *      Builds BWP UL dedicated PUSCH Config
3734  *
3735  * @params[in] : PUSCH_Config_t *puschCfg
3736  *
3737  * @return ROK     - success
3738  *         RFAILED - failure
3739  *
3740  * ****************************************************************/
3741 uint8_t BuildBWPUlDedPuschCfg(PUSCH_Config_t *puschCfg)
3742 {
3743    puschCfg->dataScramblingIdentityPUSCH = NULLP;
3744    CU_ALLOC(puschCfg->dataScramblingIdentityPUSCH, sizeof(long));
3745    if(!puschCfg->dataScramblingIdentityPUSCH)
3746    {
3747       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
3748       return RFAILED;
3749    }
3750    *(puschCfg->dataScramblingIdentityPUSCH) = SCRAMBLING_ID;
3751
3752    puschCfg->txConfig = NULLP;
3753    puschCfg->dmrs_UplinkForPUSCH_MappingTypeA = NULLP;
3754    CU_ALLOC(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA, \
3755          sizeof(struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA));
3756    if(!puschCfg->dmrs_UplinkForPUSCH_MappingTypeA)
3757    {
3758       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
3759       return RFAILED;
3760    }
3761
3762    if(BuildDMRSULPuschMapTypeA(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA) != ROK)
3763    {
3764       return RFAILED;
3765    }
3766
3767    puschCfg->dmrs_UplinkForPUSCH_MappingTypeB = NULLP;
3768    puschCfg->pusch_PowerControl = NULLP;
3769    puschCfg->frequencyHopping = NULLP;
3770    puschCfg->frequencyHoppingOffsetLists = NULLP;
3771    puschCfg->resourceAllocation = RES_ALLOC_TYPE;
3772
3773    puschCfg->pusch_TimeDomainAllocationList = NULLP;
3774    CU_ALLOC(puschCfg->pusch_TimeDomainAllocationList, \
3775          sizeof(struct PUSCH_Config__pusch_TimeDomainAllocationList));
3776    if(!puschCfg->pusch_TimeDomainAllocationList)
3777    {
3778       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
3779       return RFAILED;
3780    }
3781
3782    if(BuildPuschTimeDomAllocList(puschCfg->pusch_TimeDomainAllocationList) != ROK)
3783    {
3784       return RFAILED;
3785    }
3786
3787    puschCfg->pusch_AggregationFactor = NULLP;
3788    puschCfg->mcs_Table = NULLP;
3789    puschCfg->mcs_TableTransformPrecoder = NULLP;
3790    puschCfg->transformPrecoder = NULLP;
3791    CU_ALLOC(puschCfg->transformPrecoder, sizeof(long));
3792    if(!puschCfg->transformPrecoder)
3793    {
3794       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
3795       return RFAILED;
3796    }
3797    *(puschCfg->transformPrecoder) = PUSCH_TRANSFORM_PRECODER;
3798
3799    puschCfg->codebookSubset = NULLP;
3800    puschCfg->maxRank = NULLP;
3801    puschCfg->rbg_Size = NULLP;
3802    puschCfg->uci_OnPUSCH = NULLP;
3803    puschCfg->tp_pi2BPSK = NULLP;
3804
3805    return ROK;
3806 }
3807
3808 /*******************************************************************
3809  *
3810  * @brief Builds BWP UL dedicated PUCCH Config
3811  *
3812  * @details
3813  *
3814  *    Function : BuildBWPUlDedPucchCfg
3815  *
3816  *    Functionality:
3817  *      Builds BWP UL dedicated PUCCH Config
3818  *
3819  * @params[in] : PUCCH_Config_t *pucchCfg
3820  *
3821  * @return ROK     - success
3822  *         RFAILED - failure
3823  *
3824  * ****************************************************************/
3825 uint8_t BuildBWPUlDedPucchCfg(PUCCH_Config_t *pucchCfg)
3826 {
3827    uint8_t arrIdx, elementCnt;
3828
3829    CU_ALLOC(pucchCfg->dl_DataToUL_ACK, sizeof(struct PUCCH_Config__dl_DataToUL_ACK));
3830    if(pucchCfg->dl_DataToUL_ACK == NULLP)
3831    {
3832       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
3833       return RFAILED;
3834    }
3835
3836    elementCnt = 2;
3837    pucchCfg->dl_DataToUL_ACK->list.count = elementCnt;
3838    pucchCfg->dl_DataToUL_ACK->list.size = elementCnt * sizeof(long *);
3839    CU_ALLOC(pucchCfg->dl_DataToUL_ACK->list.array, pucchCfg->dl_DataToUL_ACK->list.size);
3840    if(pucchCfg->dl_DataToUL_ACK->list.array == NULLP)
3841    {
3842       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
3843       return RFAILED;
3844    }
3845
3846    for(arrIdx = 0; arrIdx <  pucchCfg->dl_DataToUL_ACK->list.count; arrIdx++)
3847    {
3848       CU_ALLOC(pucchCfg->dl_DataToUL_ACK->list.array[arrIdx], sizeof(long));
3849       if(pucchCfg->dl_DataToUL_ACK->list.array[arrIdx] == NULLP)
3850       {
3851           DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
3852           return RFAILED;
3853       }
3854    }
3855
3856    arrIdx = 0;
3857    *(pucchCfg->dl_DataToUL_ACK->list.array[arrIdx++]) = 4;
3858    *(pucchCfg->dl_DataToUL_ACK->list.array[arrIdx]) = 5;
3859
3860    return ROK;
3861 }
3862
3863 /*******************************************************************
3864  *
3865  * @brief Fills SRS resource to add/modify list
3866  *
3867  * @details
3868  *
3869  *    Function : BuildSrsRsrcAddModList
3870  *
3871  *    Functionality: Fills SRS resource to add/modify list
3872  *
3873  * @params[in]
3874  * @return ROK     - success
3875  *         RFAILED - failure
3876  *
3877  * ****************************************************************/
3878 uint8_t BuildSrsRsrcAddModList(struct SRS_Config__srs_ResourceToAddModList *resourceList)
3879 {
3880    uint8_t   elementCnt;
3881    uint8_t   rsrcIdx;
3882
3883    elementCnt = 1;
3884    resourceList->list.count = elementCnt;
3885    resourceList->list.size = elementCnt * sizeof(SRS_Resource_t *);
3886    resourceList->list.array = NULLP;
3887    CU_ALLOC(resourceList->list.array, resourceList->list.size);
3888    if(!resourceList->list.array)
3889    {
3890       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed in BuildSrsRsrcAddModList");
3891       return RFAILED;
3892    }
3893
3894    for(rsrcIdx = 0; rsrcIdx < resourceList->list.count; rsrcIdx++)
3895    {
3896       CU_ALLOC(resourceList->list.array[rsrcIdx], sizeof(SRS_Resource_t));
3897       if(!resourceList->list.array[rsrcIdx])
3898       {
3899          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed in BuildSrsRsrcAddModList");
3900          return RFAILED;
3901       }
3902    }
3903
3904    rsrcIdx = 0;
3905    resourceList->list.array[rsrcIdx]->srs_ResourceId = SRS_RSRC_ID;
3906    resourceList->list.array[rsrcIdx]->nrofSRS_Ports = SRS_Resource__nrofSRS_Ports_port1;
3907    resourceList->list.array[rsrcIdx]->transmissionComb.present = SRS_Resource__transmissionComb_PR_n2;
3908
3909    resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2 = NULLP;
3910    CU_ALLOC(resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2, \
3911          sizeof(struct SRS_Resource__transmissionComb__n2));
3912    if(!resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2)
3913    {
3914       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed in BuildSrsRsrcAddModList");
3915       return RFAILED;
3916    }
3917    resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2->combOffset_n2\
3918       = SRS_COMB_OFFSET_N2;
3919    resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2->cyclicShift_n2\
3920       = SRS_CYCLIC_SHIFT_N2;
3921
3922    resourceList->list.array[rsrcIdx]->resourceMapping.startPosition = \
3923                                                                       0;
3924    resourceList->list.array[rsrcIdx]->resourceMapping.nrofSymbols =  \
3925                                                                      SRS_Resource__resourceMapping__nrofSymbols_n1;
3926    resourceList->list.array[rsrcIdx]->resourceMapping.repetitionFactor = \
3927                                                                          SRS_Resource__resourceMapping__repetitionFactor_n1;
3928
3929    resourceList->list.array[rsrcIdx]->freqDomainPosition = SRS_FREQ_DOM_POS;
3930    resourceList->list.array[rsrcIdx]->freqDomainShift = SRS_FREQ_DOM_SHIFT;
3931    resourceList->list.array[rsrcIdx]->freqHopping.c_SRS = C_SRS;
3932    resourceList->list.array[rsrcIdx]->freqHopping.b_SRS = B_SRS;
3933    resourceList->list.array[rsrcIdx]->freqHopping.b_hop = B_HOP;
3934    resourceList->list.array[rsrcIdx]->groupOrSequenceHopping = \
3935                                                                SRS_Resource__groupOrSequenceHopping_neither;
3936
3937    /* Setting resource type to aperiodic for intergration purposes */
3938    resourceList->list.array[rsrcIdx]->resourceType.present = \
3939                                                              SRS_Resource__resourceType_PR_aperiodic;
3940    resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic = NULLP;
3941    CU_ALLOC(resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic,
3942          sizeof(struct SRS_Resource__resourceType__aperiodic));
3943    if(!resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic)
3944    {
3945       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed in BuildSrsRsrcAddModList");
3946       return RFAILED;
3947    }
3948    resourceList->list.array[rsrcIdx]->sequenceId = SRS_SEQ_ID;
3949
3950    return ROK;
3951 }
3952
3953 /*******************************************************************
3954  *
3955  * @brief Build SRS resource set Add/mod list
3956  *
3957  * @details
3958  *
3959  *    Function : BuildSrsRsrcSetAddModList
3960  *
3961  *    Functionality: Build SRS resource set Add/mod list
3962  *
3963  * @params[in]
3964  * @return ROK     - success
3965  *         RFAILED - failure
3966  *
3967  * ****************************************************************/
3968    uint8_t BuildSrsRsrcSetAddModList
3969 (
3970  struct SRS_Config__srs_ResourceSetToAddModList *rsrcSetList
3971  )
3972 {
3973    uint8_t  elementCnt;
3974    uint8_t  rSetIdx;
3975    uint8_t  rsrcIdx;
3976    struct SRS_ResourceSet__srs_ResourceIdList *rsrcIdList;
3977
3978    elementCnt = 1;
3979    rsrcSetList->list.count = elementCnt;
3980    rsrcSetList->list.size = elementCnt * sizeof(SRS_ResourceSet_t *);
3981    rsrcSetList->list.array = NULLP;
3982    CU_ALLOC(rsrcSetList->list.array, rsrcSetList->list.size);
3983    if(!rsrcSetList->list.array)
3984    {
3985       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed in BuildSrsRsrcSetAddModList");
3986       return RFAILED;
3987    }
3988
3989    for(rSetIdx = 0; rSetIdx < rsrcSetList->list.count; rSetIdx++)
3990    {
3991       CU_ALLOC(rsrcSetList->list.array[rSetIdx], sizeof(SRS_ResourceSet_t));
3992       if(!rsrcSetList->list.array[rSetIdx])
3993       {
3994          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed in BuildSrsRsrcSetAddModList");
3995          return RFAILED;
3996       }
3997    }
3998
3999    rSetIdx = 0;
4000    rsrcSetList->list.array[rSetIdx]->srs_ResourceSetId = SRS_RSET_ID;
4001
4002    /* Fill Resource Id list in resource set */
4003    rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList = NULLP;
4004    CU_ALLOC(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList,\
4005          sizeof(struct SRS_ResourceSet__srs_ResourceIdList));
4006    if(!rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList)
4007    {
4008       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
4009       return RFAILED;
4010    }
4011
4012    elementCnt = 1;
4013    rsrcIdList = rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList;
4014    rsrcIdList->list.count = elementCnt;
4015    rsrcIdList->list.size = elementCnt * sizeof(SRS_ResourceId_t *);
4016    rsrcIdList->list.array = NULLP;
4017    CU_ALLOC(rsrcIdList->list.array, rsrcIdList->list.size);
4018    if(!rsrcIdList->list.array)
4019    {
4020       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed in BuildSrsRsrcSetAddModList");
4021       return RFAILED;
4022    }
4023
4024    for(rsrcIdx = 0; rsrcIdx < rsrcIdList->list.count; rsrcIdx++)
4025    {
4026       CU_ALLOC(rsrcIdList->list.array[rsrcIdx], sizeof(SRS_ResourceId_t));
4027       if(!rsrcIdList->list.array[rsrcIdx])
4028       {
4029          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed in BuildSrsRsrcSetAddModList");
4030          return RFAILED;
4031       }
4032    }
4033
4034    rsrcIdx = 0;
4035    *rsrcIdList->list.array[rsrcIdx] = SRS_RSRC_ID;
4036
4037    /* Fill resource type */
4038    rsrcSetList->list.array[rSetIdx]->resourceType.present = \
4039                                                             SRS_ResourceSet__resourceType_PR_aperiodic;
4040
4041    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic = NULLP;
4042    CU_ALLOC(rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic, \
4043          sizeof(struct SRS_ResourceSet__resourceType__aperiodic));
4044    if(!rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic)
4045    {
4046       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed in BuildSrsRsrcSetAddModList");
4047       return RFAILED;
4048    }
4049    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic->aperiodicSRS_ResourceTrigger \
4050       = APERIODIC_SRS_RESRC_TRIGGER;
4051
4052    /* TODO : Fill values for below IEs as expected by Viavi */
4053    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic->csi_RS = NULLP;
4054    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic->slotOffset = NULLP;
4055
4056
4057    rsrcSetList->list.array[rSetIdx]->usage = SRS_ResourceSet__usage_codebook;
4058    rsrcSetList->list.array[rSetIdx]->alpha = NULLP;
4059    rsrcSetList->list.array[rSetIdx]->p0 = NULLP;
4060    rsrcSetList->list.array[rSetIdx]->pathlossReferenceRS = NULLP;
4061    rsrcSetList->list.array[rSetIdx]->srs_PowerControlAdjustmentStates = NULLP;
4062
4063    return ROK;
4064 }
4065
4066 /*******************************************************************
4067  *
4068  * @brief Builds BWP UL dedicated SRS Config
4069  *
4070  * @details
4071  *
4072  *    Function : BuildBWPUlDedSrsCfg
4073  *
4074  *    Functionality: Builds BWP UL dedicated SRS Config
4075  *
4076  * @params[in] SRS Config
4077  * @return ROK     - success
4078  *         RFAILED - failure
4079  *
4080  * ****************************************************************/
4081 uint8_t BuildBWPUlDedSrsCfg(SRS_Config_t *srsCfg)
4082 {
4083    srsCfg->srs_ResourceSetToReleaseList = NULLP;
4084    srsCfg->srs_ResourceSetToAddModList = NULLP;
4085    CU_ALLOC(srsCfg->srs_ResourceSetToAddModList, \
4086          sizeof(struct SRS_Config__srs_ResourceSetToAddModList));
4087    if(!srsCfg->srs_ResourceSetToAddModList)
4088    {
4089       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed in BuildBWPUlDedSrsCfg");
4090       return RFAILED;
4091    }
4092    if(BuildSrsRsrcSetAddModList(srsCfg->srs_ResourceSetToAddModList) != ROK)
4093    {
4094       return RFAILED;
4095    }
4096
4097    srsCfg->srs_ResourceToReleaseList = NULLP;
4098
4099    /* Resource to Add/Modify list */
4100    srsCfg->srs_ResourceToAddModList = NULLP;
4101    CU_ALLOC(srsCfg->srs_ResourceToAddModList, \
4102          sizeof(struct SRS_Config__srs_ResourceToAddModList));
4103    if(!srsCfg->srs_ResourceToAddModList)
4104    {
4105       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed in BuildBWPUlDedSrsCfg");
4106       return RFAILED;
4107    }
4108
4109    if(BuildSrsRsrcAddModList(srsCfg->srs_ResourceToAddModList) != ROK)
4110    {
4111       return RFAILED;
4112    }
4113
4114    srsCfg->tpc_Accumulation = NULLP;
4115
4116    return ROK;
4117 }
4118
4119 /*******************************************************************
4120  *
4121  * @brief Builds inital UL BWP
4122  *
4123  * @details
4124  *
4125  *    Function : BuildInitialUlBWP
4126  *
4127  *    Functionality: Builds initial UL BWP
4128  *
4129  * @params[in] BWP_UplinkDedicated_t *ulBwp
4130  * @return ROK     - success
4131  *         RFAILED - failure
4132  *
4133  * ****************************************************************/
4134 uint8_t BuildInitialUlBWP(BWP_UplinkDedicated_t *ulBwp)
4135 {
4136    ulBwp->pucch_Config = NULLP;
4137    ulBwp->pucch_Config = NULLP;
4138    CU_ALLOC(ulBwp->pucch_Config, sizeof(struct BWP_UplinkDedicated__pucch_Config));
4139    if(!ulBwp->pucch_Config)
4140    {
4141       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
4142       return RFAILED;
4143    }
4144
4145    ulBwp->pucch_Config->present = BWP_UplinkDedicated__pucch_Config_PR_setup;
4146    ulBwp->pucch_Config->choice.setup = NULLP;
4147    CU_ALLOC(ulBwp->pucch_Config->choice.setup, sizeof(PUCCH_Config_t));
4148    if(!ulBwp->pucch_Config->choice.setup)
4149    {
4150       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
4151       return RFAILED;
4152    }
4153
4154    if(BuildBWPUlDedPucchCfg(ulBwp->pucch_Config->choice.setup) != ROK)
4155    {
4156       return RFAILED;
4157    }
4158
4159    /* Fill BWP UL dedicated PUSCH config */
4160    ulBwp->pusch_Config = NULLP;
4161    CU_ALLOC(ulBwp->pusch_Config, sizeof(struct BWP_UplinkDedicated__pusch_Config));
4162    if(!ulBwp->pusch_Config)
4163    {
4164       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
4165       return RFAILED;
4166    }
4167
4168    ulBwp->pusch_Config->present = BWP_UplinkDedicated__pusch_Config_PR_setup;
4169    ulBwp->pusch_Config->choice.setup = NULLP;
4170    CU_ALLOC(ulBwp->pusch_Config->choice.setup, sizeof(PUSCH_Config_t));
4171    if(!ulBwp->pusch_Config->choice.setup)
4172    {
4173       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
4174       return RFAILED;
4175    }
4176
4177    if(BuildBWPUlDedPuschCfg(ulBwp->pusch_Config->choice.setup) != ROK)
4178    {
4179       return RFAILED;
4180    }
4181
4182    ulBwp->configuredGrantConfig = NULLP;
4183
4184    /* Fill BPW UL dedicated SRS config */
4185    ulBwp->srs_Config = NULLP;
4186    CU_ALLOC(ulBwp->srs_Config, sizeof(struct BWP_UplinkDedicated__srs_Config));
4187    if(!ulBwp->srs_Config)
4188    {
4189       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
4190       return RFAILED;
4191    }
4192
4193    ulBwp->srs_Config->present = BWP_UplinkDedicated__srs_Config_PR_setup;
4194    ulBwp->srs_Config->choice.setup = NULLP;
4195    CU_ALLOC(ulBwp->srs_Config->choice.setup, sizeof(SRS_Config_t));
4196    if(!ulBwp->srs_Config->choice.setup)
4197    {
4198       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
4199       return RFAILED;
4200    }
4201
4202    if(BuildBWPUlDedSrsCfg(ulBwp->srs_Config->choice.setup) != ROK)
4203    {
4204       return RFAILED;
4205    }
4206
4207    ulBwp->beamFailureRecoveryConfig = NULLP;
4208
4209    return ROK;
4210 }
4211
4212 /*******************************************************************
4213  *
4214  * @brief Builds Pusch Serving cell Config
4215  *
4216  * @details
4217  *
4218  *    Function : BuildPuschSrvCellCfg
4219  *
4220  *    Functionality: Builds Pusch Serving cell Config
4221  *
4222  * @params[in] struct UplinkConfig__pusch_ServingCellConfig *puschCfg
4223  *
4224  * @return ROK     - success
4225  *         RFAILED - failure
4226  *
4227  * ****************************************************************/
4228 uint8_t BuildPuschSrvCellCfg(struct UplinkConfig__pusch_ServingCellConfig *puschCfg)
4229 {
4230    puschCfg->present = UplinkConfig__pusch_ServingCellConfig_PR_setup;
4231    puschCfg->choice.setup = NULLP;
4232    CU_ALLOC(puschCfg->choice.setup, sizeof(struct PUSCH_ServingCellConfig));
4233    if(!puschCfg->choice.setup)
4234    {
4235       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
4236       return RFAILED;
4237    }
4238
4239    puschCfg->choice.setup->codeBlockGroupTransmission = NULLP;
4240    puschCfg->choice.setup->rateMatching = NULLP;
4241    puschCfg->choice.setup->xOverhead = NULLP;
4242    puschCfg->choice.setup->ext1 = NULLP;
4243    CU_ALLOC(puschCfg->choice.setup->ext1, sizeof(struct PUSCH_ServingCellConfig__ext1));
4244    if(!puschCfg->choice.setup->ext1)
4245    {
4246       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
4247       return RFAILED;
4248    }
4249
4250    puschCfg->choice.setup->ext1->maxMIMO_Layers = NULLP;
4251    CU_ALLOC(puschCfg->choice.setup->ext1->maxMIMO_Layers, sizeof(long));
4252    if(!puschCfg->choice.setup->ext1->maxMIMO_Layers)
4253    {
4254       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
4255       return RFAILED;
4256    }
4257    *(puschCfg->choice.setup->ext1->maxMIMO_Layers) = PUSCH_MAX_MIMO_LAYERS;
4258
4259    puschCfg->choice.setup->ext1->processingType2Enabled= NULLP;
4260    CU_ALLOC(puschCfg->choice.setup->ext1->processingType2Enabled,sizeof(BOOLEAN_t));
4261    if(!puschCfg->choice.setup->ext1->processingType2Enabled)
4262    {
4263       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
4264       return RFAILED;
4265    }
4266    *(puschCfg->choice.setup->ext1->processingType2Enabled) = PUSCH_PROCESS_TYPE2_ENABLED;
4267    return ROK;
4268 }
4269
4270 /*******************************************************************
4271  *
4272  * @brief Builds UL config
4273  * @details
4274  *
4275  *    Function : BuildUlCfg
4276  *
4277  *    Functionality: Builds UL config in spCellCfgDed
4278  *
4279  * @params[in] UplinkConfig_t *ulCfg
4280  *
4281  * @return ROK     - success
4282  *         RFAILED - failure
4283  *
4284  * ****************************************************************/
4285 uint8_t BuildUlCfg(UplinkConfig_t *ulCfg)
4286 {
4287    ulCfg->initialUplinkBWP = NULLP;
4288    CU_ALLOC(ulCfg->initialUplinkBWP, sizeof(BWP_UplinkDedicated_t));
4289    if(!ulCfg->initialUplinkBWP)
4290    {
4291       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failed in BuildUlCfg");
4292       return RFAILED;
4293    }
4294
4295    if(BuildInitialUlBWP(ulCfg->initialUplinkBWP) != ROK)
4296    {
4297       return RFAILED;
4298    }
4299
4300    ulCfg->uplinkBWP_ToReleaseList = NULLP;
4301    ulCfg->uplinkBWP_ToAddModList = NULLP;
4302    ulCfg->firstActiveUplinkBWP_Id = NULLP;
4303    CU_ALLOC(ulCfg->firstActiveUplinkBWP_Id, sizeof(BWP_Id_t));
4304    if(!ulCfg->firstActiveUplinkBWP_Id)
4305    {
4306       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failed in BuildUlCfg");
4307       return RFAILED;
4308    }
4309    *(ulCfg->firstActiveUplinkBWP_Id) = ACTIVE_UL_BWP_ID;
4310
4311    ulCfg->pusch_ServingCellConfig = NULLP;
4312    CU_ALLOC(ulCfg->pusch_ServingCellConfig, \
4313          sizeof(struct UplinkConfig__pusch_ServingCellConfig));
4314    if(!ulCfg->pusch_ServingCellConfig)
4315    {
4316       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failed in BuildUlCfg");
4317       return RFAILED;
4318    }
4319
4320    if(BuildPuschSrvCellCfg(ulCfg->pusch_ServingCellConfig) != ROK)
4321    {
4322       return RFAILED;
4323    }
4324
4325    ulCfg->carrierSwitching = NULLP;
4326    ulCfg->ext1 = NULLP;
4327    return ROK;
4328 }
4329
4330 /*******************************************************************
4331  *
4332  * @brief Builds PDSCH serving cell config
4333  * @details
4334  *
4335  *    Function : BuildPdschSrvCellCfg
4336  *
4337  *    Functionality: Builds PDSCH serving cell config in spCellCfgDed
4338  *
4339  * @params[in] struct ServingCellConfig__pdsch_ServingCellConfig *pdschCfg
4340  *
4341  * @return ROK     - success
4342  *         RFAILED - failure
4343  *
4344  * ****************************************************************/
4345 uint8_t BuildPdschSrvCellCfg(struct ServingCellConfig__pdsch_ServingCellConfig *pdschCfg)
4346 {
4347    pdschCfg->present =  ServingCellConfig__pdsch_ServingCellConfig_PR_setup;
4348    pdschCfg->choice.setup = NULLP;
4349    CU_ALLOC(pdschCfg->choice.setup, sizeof( struct PDSCH_ServingCellConfig));
4350    if(!pdschCfg->choice.setup)
4351    {
4352       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschSrvCellCfg");
4353       return RFAILED;
4354    }
4355
4356    pdschCfg->choice.setup->codeBlockGroupTransmission = NULLP;
4357    pdschCfg->choice.setup->xOverhead = NULLP;
4358    pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH = NULLP;
4359    CU_ALLOC(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH, sizeof(long));
4360    if(!pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH)
4361    {
4362       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschSrvCellCfg");
4363       return RFAILED;
4364    }
4365    *(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH)= PDSCH_NUM_HARQ_PROC;
4366    pdschCfg->choice.setup->pucch_Cell = NULLP;
4367    pdschCfg->choice.setup->ext1 = NULLP;
4368
4369    return ROK;
4370 }
4371
4372 /*******************************************************************
4373  *
4374  * @brief Builds CSI Meas config
4375  * @details
4376  *
4377  *    Function : BuildCsiMeasCfg
4378  *
4379  *    Functionality: Builds CSI Meas config in spCellCfgDed
4380  *
4381  * @params[in] struct ServingCellConfig__csi_MeasConfig *csiMeasCfg
4382  *
4383  * @return ROK     - success
4384  *         RFAILED - failure
4385  *
4386  * ****************************************************************/
4387 uint8_t BuildCsiMeasCfg(struct ServingCellConfig__csi_MeasConfig *csiMeasCfg)
4388 {
4389
4390    return ROK;
4391 }
4392
4393 /*******************************************************************
4394  *
4395  * @brief Builds Spcell config dedicated
4396  * @details
4397  *
4398  *    Function : BuildSpCellCfgDed
4399  *
4400  *    Functionality: Builds sp cell config dedicated in spCellCfg
4401  *
4402  * @params[in] ServingCellConfig_t srvCellCfg
4403  *
4404  * @return ROK     - success
4405  *         RFAILED - failure
4406  *
4407  * ****************************************************************/
4408 uint8_t BuildSpCellCfgDed(ServingCellConfig_t *srvCellCfg)
4409 {
4410    srvCellCfg->tdd_UL_DL_ConfigurationDedicated = NULLP;
4411
4412    srvCellCfg->initialDownlinkBWP = NULLP;
4413    CU_ALLOC(srvCellCfg->initialDownlinkBWP, sizeof(BWP_DownlinkDedicated_t));
4414    if(!srvCellCfg->initialDownlinkBWP)
4415    {
4416       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
4417       return RFAILED;
4418    }
4419
4420    if(BuildInitialDlBWP(srvCellCfg->initialDownlinkBWP) != ROK)
4421    {
4422       DU_LOG("\nERROR  -->  F1AP : BuildInitialDlBWP failed");
4423       return RFAILED;
4424    }
4425    srvCellCfg->downlinkBWP_ToReleaseList = NULLP;
4426    srvCellCfg->downlinkBWP_ToAddModList = NULLP;
4427
4428    srvCellCfg->firstActiveDownlinkBWP_Id = NULLP;
4429    CU_ALLOC(srvCellCfg->firstActiveDownlinkBWP_Id, sizeof(long));
4430    if(!srvCellCfg->firstActiveDownlinkBWP_Id)
4431    {
4432       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
4433       return RFAILED;
4434    }
4435    *(srvCellCfg->firstActiveDownlinkBWP_Id) = ACTIVE_DL_BWP_ID;
4436
4437    srvCellCfg->bwp_InactivityTimer = NULLP;
4438
4439    srvCellCfg->defaultDownlinkBWP_Id = NULLP;
4440    CU_ALLOC(srvCellCfg->defaultDownlinkBWP_Id, sizeof(long));
4441    if(!srvCellCfg->defaultDownlinkBWP_Id)
4442    {
4443       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
4444       return RFAILED;
4445    }
4446    *(srvCellCfg->defaultDownlinkBWP_Id) = ACTIVE_DL_BWP_ID;
4447
4448    srvCellCfg->uplinkConfig = NULLP;
4449    CU_ALLOC(srvCellCfg->uplinkConfig, sizeof(UplinkConfig_t));
4450    if(!srvCellCfg->uplinkConfig)
4451    {
4452       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
4453       return RFAILED;
4454    }
4455
4456    if(BuildUlCfg(srvCellCfg->uplinkConfig) != ROK)
4457    {
4458       DU_LOG("\nERROR  -->  F1AP : BuildUlCfg failed");
4459       return RFAILED;
4460    }
4461    srvCellCfg->supplementaryUplink = NULLP;
4462    srvCellCfg->pdcch_ServingCellConfig = NULLP;
4463
4464    srvCellCfg->pdsch_ServingCellConfig = NULLP;
4465    CU_ALLOC(srvCellCfg->pdsch_ServingCellConfig, sizeof(struct  ServingCellConfig__pdsch_ServingCellConfig));
4466    if(!srvCellCfg->pdsch_ServingCellConfig)
4467    {
4468       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
4469       return RFAILED;
4470    }
4471
4472    if(BuildPdschSrvCellCfg(srvCellCfg->pdsch_ServingCellConfig) != ROK)
4473    {
4474       DU_LOG("\nERROR  -->  F1AP : BuildPdschSrvCellCfg failed");
4475       return RFAILED;
4476    }
4477
4478    srvCellCfg->csi_MeasConfig = NULLP;
4479 #if 0
4480    CU_ALLOC(srvCellCfg->csi_MeasConfig, sizeof(struct   ServingCellConfig__csi_MeasConfig))
4481       if(!srvCellCfg->csi_MeasConfig)
4482       {
4483          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
4484          return RFAILED;
4485       }
4486
4487    if(BuildCsiMeasCfg(srvCellCfg->csi_MeasConfig) != ROK)
4488    {
4489       DU_LOG("\nF1AP : BuildCsiMeasCfg failed");
4490       return RFAILED;
4491    }
4492 #endif
4493    srvCellCfg->sCellDeactivationTimer = NULLP;
4494    srvCellCfg->crossCarrierSchedulingConfig = NULLP;
4495    srvCellCfg->tag_Id = TAG_ID;
4496    srvCellCfg->dummy = NULLP;
4497    srvCellCfg->pathlossReferenceLinking = NULLP;
4498    srvCellCfg->servingCellMO = NULLP;
4499    srvCellCfg->ext1 = NULLP;
4500
4501    return ROK;
4502 }
4503 /*******************************************************************
4504  *
4505  * @brief Builds Spcell config
4506  *
4507  * @details
4508  *
4509  *    Function : BuildSpCellCfg
4510  *
4511  *    Functionality: Builds sp cell config in DuToCuRrcContainer
4512  *
4513  * @params[in] SpCellConfig_t spCellCfg
4514  *
4515  * @return ROK     - success
4516  *         RFAILED - failure
4517  *
4518  * ****************************************************************/
4519 uint8_t BuildSpCellCfg(SpCellConfig_t *spCellCfg)
4520 {
4521
4522    spCellCfg->servCellIndex = NULLP;
4523    CU_ALLOC(spCellCfg->servCellIndex, sizeof(long));
4524    if(!spCellCfg->servCellIndex)
4525    {
4526       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfg");
4527       return RFAILED;
4528    }
4529    *(spCellCfg->servCellIndex) = SERV_CELL_IDX;
4530
4531    spCellCfg->reconfigurationWithSync = NULLP;
4532    spCellCfg->rlf_TimersAndConstants = NULLP;
4533    spCellCfg->rlmInSyncOutOfSyncThreshold = NULLP;
4534    CU_ALLOC(spCellCfg->rlmInSyncOutOfSyncThreshold, sizeof(long));
4535    if(!spCellCfg->rlmInSyncOutOfSyncThreshold)
4536    {
4537       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfg");
4538       return RFAILED;
4539    }
4540    *(spCellCfg->rlmInSyncOutOfSyncThreshold) = RLM_SYNC_OUT_SYNC_THRESHOLD;
4541
4542    spCellCfg->spCellConfigDedicated = NULLP;
4543    CU_ALLOC(spCellCfg->spCellConfigDedicated, sizeof(ServingCellConfig_t));
4544    if(!spCellCfg->spCellConfigDedicated)
4545    {
4546       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfg");
4547       return RFAILED;
4548    }
4549    if(BuildSpCellCfgDed(spCellCfg->spCellConfigDedicated) != ROK)
4550    {
4551       DU_LOG("\nERROR  -->  F1AP : BuildSpCellCfgDed failed");
4552       return RFAILED;
4553    }
4554    return ROK;
4555 }
4556 /*******************************************************************
4557  *
4558  * @brief Builds Phy cell group config
4559  *
4560  * @details
4561  *
4562  *    Function : BuildPhyCellGrpCfg
4563  *
4564  *    Functionality: Builds Phy cell group config in DuToCuRrcContainer
4565  *
4566  * @params[in] PhysicalCellGroupConfig_t *phyCellGrpCfg
4567  *
4568  * @return ROK     - success
4569  *         RFAILED - failure
4570  *
4571  * ****************************************************************/
4572 uint8_t BuildPhyCellGrpCfg(PhysicalCellGroupConfig_t *phyCellGrpCfg)
4573 {
4574    phyCellGrpCfg->harq_ACK_SpatialBundlingPUCCH = NULLP;
4575    phyCellGrpCfg->harq_ACK_SpatialBundlingPUSCH = NULLP;
4576
4577    phyCellGrpCfg->p_NR_FR1 = NULLP;
4578    CU_ALLOC(phyCellGrpCfg->p_NR_FR1, sizeof(long));
4579    if(!phyCellGrpCfg->p_NR_FR1)
4580    {
4581       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildPhyCellGrpCfg");
4582       return RFAILED;
4583    }
4584    *(phyCellGrpCfg->p_NR_FR1)             = P_NR_FR1;
4585    phyCellGrpCfg->pdsch_HARQ_ACK_Codebook = PDSCH_HARQ_ACK_CODEBOOK;
4586    phyCellGrpCfg->tpc_SRS_RNTI = NULLP;
4587    phyCellGrpCfg->tpc_PUCCH_RNTI = NULLP;
4588    phyCellGrpCfg->tpc_PUSCH_RNTI = NULLP;
4589    phyCellGrpCfg->sp_CSI_RNTI = NULLP;
4590    phyCellGrpCfg->cs_RNTI = NULLP;
4591    phyCellGrpCfg->ext1 = NULLP;
4592    phyCellGrpCfg->ext2 = NULLP;
4593
4594    return ROK;
4595 }
4596
4597 /*******************************************************************
4598  *
4599  * @brief Builds tag config
4600  *
4601  * @details
4602  *
4603  *    Function : BuildTagConfig
4604  *
4605  *    Functionality: Builds tag config in MacCellGroupConfig
4606  *
4607  * @params[in] TAG_Config *tag_Config
4608  *
4609  * @return ROK     - success
4610  *         RFAILED - failure
4611  *
4612  * ****************************************************************/
4613 uint8_t BuildTagConfig(struct TAG_Config *tagConfig)
4614 {
4615    struct TAG_Config__tag_ToAddModList *tagList;
4616    uint8_t                     idx, elementCnt;
4617
4618    tagConfig->tag_ToReleaseList = NULLP;
4619    tagConfig->tag_ToAddModList = NULLP;
4620    CU_ALLOC(tagConfig->tag_ToAddModList, sizeof(struct TAG_Config__tag_ToAddModList));
4621    if(!tagConfig->tag_ToAddModList)
4622    {
4623       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildTagConfig");
4624       return RFAILED;
4625    }
4626
4627    elementCnt = 1; //ODU_VALUE_ONE;
4628    tagList = tagConfig->tag_ToAddModList;
4629    tagList->list.count = elementCnt;
4630    tagList->list.size  =  elementCnt * sizeof(struct TAG *);
4631
4632    tagList->list.array = NULLP;
4633    CU_ALLOC(tagList->list.array, tagList->list.size);
4634    if(!tagList->list.array)
4635    {
4636       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildTagConfig");
4637       return RFAILED;
4638    }
4639
4640    for(idx=0; idx<tagList->list.count; idx++)
4641    {
4642       tagList->list.array[idx] = NULLP;
4643       CU_ALLOC(tagList->list.array[idx], sizeof(struct TAG));
4644       if(!tagList->list.array[idx])
4645       {
4646          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildTagConfig");
4647          return RFAILED;
4648       }
4649    }
4650
4651    idx = 0;
4652    tagList->list.array[idx]->tag_Id = TAG_ID;
4653    tagList->list.array[idx]->timeAlignmentTimer = TIME_ALIGNMENT_TMR;
4654
4655    return ROK;
4656 }
4657
4658 /*******************************************************************
4659  *
4660  * @brief Builds PHR Config
4661  *
4662  * @details
4663  *
4664  *    Function : BuildPhrConfig
4665  *
4666  *    Functionality: Builds phrConfig in MacCellGroupConfig
4667  *
4668  * @params[in] PHR Config *
4669  *
4670  * @return ROK     - success
4671  *         RFAILED - failure
4672  *
4673  * ****************************************************************/
4674 uint8_t BuildPhrConfig(struct MAC_CellGroupConfig__phr_Config *phrConfig)
4675 {
4676
4677    phrConfig->present = MAC_CellGroupConfig__phr_Config_PR_setup;
4678    phrConfig->choice.setup = NULLP;
4679    CU_ALLOC(phrConfig->choice.setup, sizeof(struct PHR_Config));
4680    if(!phrConfig->choice.setup)
4681    {
4682       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildPhrConfig");
4683       return RFAILED;
4684    }
4685
4686    phrConfig->choice.setup->phr_PeriodicTimer        = PHR_PERIODIC_TMR;
4687    phrConfig->choice.setup->phr_ProhibitTimer        = PHR_PROHIBHIT_TMR;
4688    phrConfig->choice.setup->phr_Tx_PowerFactorChange = PHR_PWR_FACTOR_CHANGE;
4689    phrConfig->choice.setup->multiplePHR              = false;
4690    phrConfig->choice.setup->dummy                    = false;
4691    phrConfig->choice.setup->phr_Type2OtherCell       = false;
4692    phrConfig->choice.setup->phr_ModeOtherCG          = PHR_MODE_OTHER_CG;
4693
4694    return ROK;
4695 }
4696
4697 /*******************************************************************
4698  *
4699  * @brief Builds BSR Config
4700  *
4701  * @details
4702  *
4703  *    Function : BuildBsrConfig
4704  *
4705  *    Functionality: Builds BuildBsrConfig in MacCellGroupConfig
4706  *
4707  * @params[in] BSR_Config *bsrConfig
4708  *
4709  * @return ROK     - success
4710  *         RFAILED - failure
4711  *
4712  * ****************************************************************/
4713 uint8_t BuildBsrConfig(struct BSR_Config *bsrConfig)
4714 {
4715    bsrConfig->periodicBSR_Timer = PERIODIC_BSR_TMR;
4716    bsrConfig->retxBSR_Timer     = RETX_BSR_TMR;
4717    bsrConfig->logicalChannelSR_DelayTimer = NULLP;
4718
4719    return ROK;
4720 }
4721
4722 /*******************************************************************
4723  *
4724  * @brief Builds scheduling request config
4725  *
4726  * @details
4727  *
4728  *    Function : BuildSchedulingReqConfig
4729  *
4730  *    Functionality: Builds BuildSchedulingReqConfig in MacCellGroupConfig
4731  *
4732  * @params[in] SchedulingRequestConfig *schedulingRequestConfig
4733  *
4734  * @return ROK     - success
4735  *         RFAILED - failure
4736  *
4737  * ****************************************************************/
4738 uint8_t BuildSchedulingReqConfig(struct SchedulingRequestConfig *schedulingRequestConfig)
4739 {
4740    struct SchedulingRequestConfig__schedulingRequestToAddModList *schReqList;
4741    uint8_t                     idx, elementCnt;
4742
4743    schedulingRequestConfig->schedulingRequestToAddModList = NULLP;
4744    CU_ALLOC(schedulingRequestConfig->schedulingRequestToAddModList,
4745          sizeof(struct SchedulingRequestConfig__schedulingRequestToAddModList));
4746    if(!schedulingRequestConfig->schedulingRequestToAddModList)
4747    {
4748       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSchedulingReqConfig");
4749       return RFAILED;
4750    }
4751
4752    elementCnt = 1; //ODU_VALUE_ONE;
4753    schReqList = schedulingRequestConfig->schedulingRequestToAddModList;
4754    schReqList->list.count = elementCnt;
4755    schReqList->list.size  = elementCnt * sizeof(struct SchedulingRequestToAddMod *);
4756
4757    schReqList->list.array = NULLP;
4758    CU_ALLOC(schReqList->list.array, schReqList->list.size);
4759    if(!schReqList->list.array)
4760    {
4761       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSchedulingReqConfig");
4762       return RFAILED;
4763    }
4764
4765    for(idx=0;idx<schReqList->list.count; idx++)
4766    {
4767       schReqList->list.array[idx] = NULLP;
4768       CU_ALLOC(schReqList->list.array[idx], sizeof(struct SchedulingRequestToAddMod));
4769       if(!schReqList->list.array[idx])
4770       {
4771          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSchedulingReqConfig");
4772          return RFAILED;
4773       }
4774    }
4775
4776    idx = 0;
4777    schReqList->list.array[idx]->schedulingRequestId = SCH_REQ_ID;
4778
4779    schReqList->list.array[idx]->sr_ProhibitTimer = NULLP;
4780    CU_ALLOC(schReqList->list.array[idx]->sr_ProhibitTimer, sizeof(long));
4781    if(!schReqList->list.array[idx]->sr_ProhibitTimer)
4782    {
4783       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSchedulingReqConfig");
4784       return RFAILED;
4785    }
4786    *(schReqList->list.array[idx]->sr_ProhibitTimer) = SR_PROHIBIT_TMR;
4787    schReqList->list.array[idx]->sr_TransMax = SR_TRANS_MAX;
4788    schedulingRequestConfig->schedulingRequestToReleaseList = NULLP;
4789
4790    return ROK;
4791 }
4792 /*******************************************************************
4793  *
4794  * @brief Builds Mac cell group config
4795  *
4796  * @details
4797  *
4798  *    Function : BuildMacCellGrpCfg
4799  *
4800  *    Functionality: Builds Mac cell group config in DuToCuRrcContainer
4801  *
4802  * @params[in] MAC_CellGroupConfig_t *macCellGrpCfg
4803  *
4804  * @return ROK     - success
4805  *         RFAILED - failure
4806  *
4807  * ****************************************************************/
4808 uint8_t BuildMacCellGrpCfg(MAC_CellGroupConfig_t *macCellGrpCfg)
4809 {
4810    macCellGrpCfg->drx_Config = NULLP;
4811    macCellGrpCfg->schedulingRequestConfig = NULLP;
4812    CU_ALLOC(macCellGrpCfg->schedulingRequestConfig, sizeof(struct SchedulingRequestConfig));
4813    if(!macCellGrpCfg->schedulingRequestConfig)
4814    {
4815       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacCellGrpCfg");
4816       return RFAILED;
4817    }
4818
4819    if(BuildSchedulingReqConfig(macCellGrpCfg->schedulingRequestConfig) != ROK)
4820    {
4821       DU_LOG("\nERROR  -->  F1AP : BuildSchedulingReqConfig failed");
4822       return RFAILED;
4823    }
4824
4825    macCellGrpCfg->bsr_Config = NULLP;
4826    CU_ALLOC(macCellGrpCfg->bsr_Config, sizeof(struct BSR_Config));
4827    if(!macCellGrpCfg->bsr_Config)
4828    {
4829       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacCellGrpCfg");
4830       return RFAILED;
4831    }
4832
4833    if(BuildBsrConfig(macCellGrpCfg->bsr_Config) != ROK)
4834    {
4835       DU_LOG("\nERROR  -->  F1AP : BuildBsrConfig failed");
4836       return RFAILED;
4837    }
4838
4839    macCellGrpCfg->tag_Config = NULLP;
4840    CU_ALLOC(macCellGrpCfg->tag_Config, sizeof(struct TAG_Config));
4841    if(!macCellGrpCfg->tag_Config)
4842    {
4843       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacCellGrpCfg");
4844       return RFAILED;
4845    }
4846
4847    if(BuildTagConfig(macCellGrpCfg->tag_Config) != ROK)
4848    {
4849       DU_LOG("\nERROR  -->  F1AP : BuildTagConfig failed");
4850       return RFAILED;
4851    }
4852
4853    macCellGrpCfg->phr_Config = NULLP;
4854    CU_ALLOC(macCellGrpCfg->phr_Config, sizeof(struct MAC_CellGroupConfig__phr_Config));
4855    if(!macCellGrpCfg->phr_Config)
4856    {
4857       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacCellGrpCfg");
4858       return RFAILED;
4859    }
4860
4861    if(BuildPhrConfig(macCellGrpCfg->phr_Config) != ROK)
4862    {
4863       DU_LOG("\nERROR  -->  F1AP : BuildPhrConfig failed");
4864       return RFAILED;
4865    }
4866
4867    macCellGrpCfg->skipUplinkTxDynamic = false;
4868    macCellGrpCfg->ext1 = NULLP;
4869
4870    return ROK;
4871 }
4872 /*******************************************************************
4873  *
4874  * @brief Frees memeory allocated for SearchSpcToAddModList
4875  *
4876  * @details
4877  *
4878  *    Function : FreeSearchSpcToAddModList
4879  *
4880  *    Functionality: Deallocating memory of SearchSpcToAddModList
4881  *
4882  * @params[in] struct PDCCH_Config__searchSpacesToAddModList *searchSpcList
4883  *
4884  * @return void
4885  *
4886  4221 * ****************************************************************/
4887 void FreeSearchSpcToAddModList(struct PDCCH_Config__searchSpacesToAddModList *searchSpcList)
4888 {
4889    uint8_t idx1=0;
4890    uint8_t idx2=0;
4891    struct  SearchSpace *searchSpc=NULLP;
4892
4893    if(searchSpcList->list.array)
4894    {
4895       if(searchSpcList->list.array[idx2])
4896       {
4897          searchSpc = searchSpcList->list.array[idx2];
4898          if(searchSpc->controlResourceSetId)
4899          {
4900             if(searchSpc->monitoringSlotPeriodicityAndOffset)
4901             {
4902                if(searchSpc->monitoringSymbolsWithinSlot)
4903                {
4904                   if(searchSpc->monitoringSymbolsWithinSlot->buf)
4905                   {
4906                      if(searchSpc->nrofCandidates)
4907                      {
4908                         if(searchSpc->searchSpaceType)
4909                         {
4910                            CU_FREE(searchSpc->searchSpaceType->choice.ue_Specific,\
4911                                  sizeof(struct SearchSpace__searchSpaceType__ue_Specific));
4912                            CU_FREE(searchSpc->searchSpaceType, sizeof(struct
4913                                     SearchSpace__searchSpaceType));
4914                         }
4915                         CU_FREE(searchSpc->nrofCandidates,
4916                               sizeof(struct SearchSpace__nrofCandidates));
4917                      }
4918                      CU_FREE(searchSpc->monitoringSymbolsWithinSlot->buf, \
4919                            searchSpc->monitoringSymbolsWithinSlot->size);
4920                   }
4921                   CU_FREE(searchSpc->monitoringSymbolsWithinSlot,
4922                         sizeof(BIT_STRING_t));
4923                }
4924                CU_FREE(searchSpc->monitoringSlotPeriodicityAndOffset, \
4925                      sizeof(struct SearchSpace__monitoringSlotPeriodicityAndOffset));
4926             }
4927             CU_FREE(searchSpc->controlResourceSetId,
4928                   sizeof(ControlResourceSetId_t));
4929          }
4930       }
4931       for(idx1 = 0; idx1 < searchSpcList->list.count; idx1++)
4932       {
4933          CU_FREE(searchSpcList->list.array[idx1],
4934                sizeof(struct SearchSpace));
4935       }
4936       CU_FREE(searchSpcList->list.array,searchSpcList->list.size);
4937    }
4938 }
4939 /*******************************************************************
4940  *
4941  * @brief Frees memory allocated for PdschTimeDomAllocList
4942  *
4943  * @details
4944  *
4945  *    Function : FreePdschTimeDomAllocList
4946  *
4947  *    Functionality: Deallocating memory of PdschTimeDomAllocList
4948  *
4949  * @params[in] struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList
4950  *
4951  * @return void
4952  *
4953  4221 * ****************************************************************/
4954 void FreePdschTimeDomAllocList( struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList)
4955 {
4956    uint8_t idx1=0;
4957
4958    if(timeDomAllocList->choice.setup)
4959    {
4960       if(timeDomAllocList->choice.setup->list.array)
4961       {
4962          for(idx1 = 0; idx1 <timeDomAllocList->choice.setup->list.count ; idx1++)
4963          {
4964             CU_FREE(timeDomAllocList->choice.setup->list.array[idx1],
4965                   sizeof(struct PDSCH_TimeDomainResourceAllocation));
4966          }
4967          CU_FREE(timeDomAllocList->choice.setup->list.array, \
4968                timeDomAllocList->choice.setup->list.size);
4969       }
4970       CU_FREE(timeDomAllocList->choice.setup,\
4971             sizeof(struct PDSCH_TimeDomainResourceAllocationList));
4972    }
4973 }
4974 /*******************************************************************
4975  *
4976  * @brief Frees memory allocated for PuschTimeDomAllocList
4977  *
4978  *@details
4979  *
4980  *    Function : FreePuschTimeDomAllocList
4981  *
4982  *    Functionality: Deallocating memory of PuschTimeDomAllocList
4983  *
4984  * @params[in] PUSCH_Config_t *puschCfg
4985  *
4986  * @return void
4987  *
4988  ***********************************************************************/
4989 void FreePuschTimeDomAllocList(PUSCH_Config_t *puschCfg)
4990 {
4991    uint8_t idx1=0;
4992    uint8_t idx2=0;
4993    struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList_t=NULLP;
4994
4995    if(puschCfg->pusch_TimeDomainAllocationList)
4996    {
4997       timeDomAllocList_t=puschCfg->pusch_TimeDomainAllocationList;
4998       if(timeDomAllocList_t->choice.setup)
4999       {
5000          if(timeDomAllocList_t->choice.setup->list.array)
5001          {
5002             CU_FREE(timeDomAllocList_t->choice.setup->list.array[idx2]->k2, sizeof(long));
5003             for(idx1 = 0; idx1<timeDomAllocList_t->choice.setup->list.count; idx1++)
5004             {
5005                CU_FREE(timeDomAllocList_t->choice.setup->list.array[idx1],\
5006                      sizeof(PUSCH_TimeDomainResourceAllocation_t));
5007             }
5008             CU_FREE(timeDomAllocList_t->choice.setup->list.array, \
5009                   timeDomAllocList_t->choice.setup->list.size);
5010          }
5011          CU_FREE(timeDomAllocList_t->choice.setup, \
5012                sizeof(struct PUSCH_TimeDomainResourceAllocationList));
5013       }
5014       CU_FREE(puschCfg->transformPrecoder, sizeof(long));
5015       CU_FREE(puschCfg->pusch_TimeDomainAllocationList, \
5016             sizeof(struct PUSCH_Config__pusch_TimeDomainAllocationList));
5017    }
5018
5019 }
5020 /*******************************************************************
5021  *
5022  * @brief Frees memory allocated for InitialUlBWP
5023  *
5024  * @details
5025  *
5026  *    Function : FreeInitialUlBWP
5027  *
5028  *    Functionality: Deallocating memory of InitialUlBWP
5029  *
5030  * @params[in] BWP_UplinkDedicated_t *ulBwp
5031  *
5032  * @return void
5033  *
5034  * ****************************************************************/
5035 void FreeInitialUlBWP(BWP_UplinkDedicated_t *ulBwp)
5036 {
5037    uint8_t  rSetIdx, rsrcIdx;
5038    SRS_Config_t   *srsCfg = NULLP;
5039    PUSCH_Config_t *puschCfg = NULLP;
5040    struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA *dmrsUlCfg = NULLP;
5041    struct SRS_Config__srs_ResourceSetToAddModList *rsrcSetList = NULLP;
5042    struct SRS_ResourceSet__srs_ResourceIdList *rsrcIdList = NULLP;
5043    struct SRS_Config__srs_ResourceToAddModList *resourceList = NULLP;
5044
5045    if(ulBwp->pusch_Config)
5046    {
5047       if(ulBwp->pusch_Config->choice.setup)
5048       {
5049          puschCfg=ulBwp->pusch_Config->choice.setup;
5050          if(puschCfg->dataScramblingIdentityPUSCH)
5051          {
5052             if(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA)
5053             {
5054                FreePuschTimeDomAllocList(puschCfg);
5055                dmrsUlCfg=puschCfg->dmrs_UplinkForPUSCH_MappingTypeA;
5056                if(dmrsUlCfg->choice.setup)
5057                {
5058                   if(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition)
5059                   {
5060                      if(dmrsUlCfg->choice.setup->transformPrecodingDisabled)
5061                      {
5062                         CU_FREE(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0,\
5063                               sizeof(long));
5064                         CU_FREE(dmrsUlCfg->choice.setup->transformPrecodingDisabled,
5065                               sizeof(struct DMRS_UplinkConfig__transformPrecodingDisabled));
5066                      }
5067                      CU_FREE(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition,
5068                            sizeof(long));
5069                   }
5070                   CU_FREE(dmrsUlCfg->choice.setup,sizeof(DMRS_UplinkConfig_t));
5071                }
5072                CU_FREE(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA, \
5073                      sizeof(struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA));
5074             }
5075             CU_FREE(puschCfg->dataScramblingIdentityPUSCH, sizeof(long));
5076          }
5077          CU_FREE(ulBwp->pusch_Config->choice.setup, sizeof(PUSCH_Config_t));
5078       }
5079       CU_FREE(ulBwp->pusch_Config, sizeof(struct BWP_UplinkDedicated__pusch_Config));
5080
5081       /* Free SRS-Config */
5082       if(ulBwp->srs_Config)
5083       {
5084          if(ulBwp->srs_Config->choice.setup)
5085          {
5086             srsCfg = ulBwp->srs_Config->choice.setup;
5087
5088             /* Free Resource Set to add/mod list */
5089             if(srsCfg->srs_ResourceSetToAddModList)
5090             {
5091                rsrcSetList = srsCfg->srs_ResourceSetToAddModList;
5092                if(rsrcSetList->list.array)
5093                {
5094                   rSetIdx = 0;
5095
5096                   /* Free SRS resource Id list in this SRS resource set */
5097                   if(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList)
5098                   {
5099                      rsrcIdList = rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList;
5100
5101                      if(rsrcIdList->list.array)
5102                      {
5103                         for(rsrcIdx = 0; rsrcIdx < rsrcIdList->list.count; rsrcIdx++)
5104                         {
5105                            CU_FREE(rsrcIdList->list.array[rsrcIdx], sizeof(SRS_ResourceId_t));
5106                         }
5107                         CU_FREE(rsrcIdList->list.array, rsrcIdList->list.size);
5108                      }
5109                      CU_FREE(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList,\
5110                            sizeof(struct SRS_ResourceSet__srs_ResourceIdList));
5111                   }
5112
5113                   /* Free resource type info for this SRS resource set */
5114                   CU_FREE(rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic, \
5115                         sizeof(struct SRS_ResourceSet__resourceType__aperiodic));
5116
5117                   /* Free memory for each resource set */
5118                   for(rSetIdx = 0; rSetIdx < rsrcSetList->list.count; rSetIdx++)
5119                   {
5120                      CU_FREE(rsrcSetList->list.array[rSetIdx], sizeof(SRS_ResourceSet_t));
5121                   }
5122                   CU_FREE(rsrcSetList->list.array, rsrcSetList->list.size);
5123                }
5124                CU_FREE(srsCfg->srs_ResourceSetToAddModList, \
5125                      sizeof(struct SRS_Config__srs_ResourceSetToAddModList));
5126             }
5127
5128             /* Free resource to add/modd list */
5129             if(srsCfg->srs_ResourceToAddModList)
5130             {
5131                resourceList = srsCfg->srs_ResourceToAddModList;
5132                if(resourceList->list.array)
5133                {
5134                   rsrcIdx = 0;
5135                   CU_FREE(resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2,\
5136                         sizeof(struct SRS_Resource__transmissionComb__n2));
5137                   CU_FREE(resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic,\
5138                         sizeof(struct SRS_Resource__resourceType__aperiodic));
5139
5140                   for(rsrcIdx = 0; rsrcIdx < resourceList->list.count; rsrcIdx++)
5141                   {
5142                      CU_FREE(resourceList->list.array[rsrcIdx], sizeof(SRS_Resource_t));
5143                   }
5144                   CU_FREE(resourceList->list.array, resourceList->list.size);
5145                }
5146                CU_FREE(srsCfg->srs_ResourceToAddModList, \
5147                      sizeof(struct SRS_Config__srs_ResourceToAddModList));
5148             }
5149
5150             CU_FREE(ulBwp->srs_Config->choice.setup, sizeof(SRS_Config_t));
5151          }
5152          CU_FREE(ulBwp->srs_Config, sizeof(struct BWP_UplinkDedicated__srs_Config));
5153       }
5154    }
5155 }
5156 /*******************************************************************
5157  *
5158  * @brief Frees memory allocated for initialUplinkBWP
5159  *
5160  * @details
5161  *
5162  *    Function : FreeinitialUplinkBWP
5163  *
5164  *    Functionality: Deallocating memory of initialUplinkBWP
5165  *
5166  * @params[in] UplinkConfig_t *ulCfg
5167  *
5168  * @return void
5169  *
5170  *
5171  * ****************************************************************/
5172 void FreeinitialUplinkBWP(UplinkConfig_t *ulCfg)
5173 {
5174    BWP_UplinkDedicated_t *ulBwp=NULLP;
5175    struct UplinkConfig__pusch_ServingCellConfig *puschCfg=NULLP;
5176
5177    if(ulCfg->initialUplinkBWP)
5178    {
5179       ulBwp=ulCfg->initialUplinkBWP;
5180       if(ulCfg->firstActiveUplinkBWP_Id)
5181       {
5182          if(ulCfg->pusch_ServingCellConfig)
5183          {
5184             puschCfg=ulCfg->pusch_ServingCellConfig;
5185             if(puschCfg->choice.setup)
5186             {
5187                if(puschCfg->choice.setup->ext1)
5188                {
5189                   CU_FREE(puschCfg->choice.setup->ext1->\
5190                         processingType2Enabled,sizeof(BOOLEAN_t));
5191                   CU_FREE(puschCfg->choice.setup->ext1->\
5192                         maxMIMO_Layers,sizeof(long));
5193                   CU_FREE(puschCfg->choice.setup->ext1, \
5194                         sizeof(struct PUSCH_ServingCellConfig__ext1));
5195                }
5196                CU_FREE(puschCfg->choice.setup, sizeof(struct PUSCH_ServingCellConfig));
5197             }
5198             CU_FREE(ulCfg->pusch_ServingCellConfig, sizeof(struct UplinkConfig__pusch_ServingCellConfig));
5199          }
5200          CU_FREE(ulCfg->firstActiveUplinkBWP_Id, sizeof(BWP_Id_t));
5201       }
5202       FreeInitialUlBWP(ulBwp);
5203       CU_FREE(ulCfg->initialUplinkBWP, sizeof(BWP_UplinkDedicated_t));
5204    }
5205 }
5206 /*******************************************************************
5207  *
5208  * @brief Frees emmory allocated for BWPDlDedPdschCfg
5209  *
5210  * @details
5211  *
5212  *    Function : FreeBWPDlDedPdschCfg
5213  *
5214  *    Functionality: Deallocating memory of BWPDlDedPdschCfg
5215  *
5216  * @params[in] BWP_DownlinkDedicated_t *dlBwp
5217  *
5218  * @return void
5219  *
5220  *
5221  * ****************************************************************/
5222 void FreeBWPDlDedPdschCfg(BWP_DownlinkDedicated_t *dlBwp)
5223 {
5224    struct PDSCH_Config *pdschCfg=NULLP;
5225    struct PDSCH_Config__prb_BundlingType *prbBndlType=NULLP;
5226    struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList=NULLP;
5227    struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA *dmrsDlCfg=NULLP;
5228
5229    if(dlBwp->pdsch_Config->choice.setup)
5230    {
5231       pdschCfg=dlBwp->pdsch_Config->choice.setup;
5232       if(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA)
5233       {
5234          if(pdschCfg->pdsch_TimeDomainAllocationList)
5235          {
5236             timeDomAllocList=pdschCfg->pdsch_TimeDomainAllocationList;
5237             if(pdschCfg->maxNrofCodeWordsScheduledByDCI)
5238             {
5239                prbBndlType=&pdschCfg->prb_BundlingType;
5240                CU_FREE(prbBndlType->choice.staticBundling,\
5241                      sizeof(struct PDSCH_Config__prb_BundlingType__staticBundling));
5242                CU_FREE(pdschCfg->maxNrofCodeWordsScheduledByDCI, sizeof(long));
5243             }
5244             FreePdschTimeDomAllocList(timeDomAllocList);
5245             CU_FREE(pdschCfg->pdsch_TimeDomainAllocationList, \
5246                   sizeof(struct PDSCH_Config__pdsch_TimeDomainAllocationList));
5247          }
5248          dmrsDlCfg=pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA;
5249          if(dmrsDlCfg->choice.setup)
5250          {
5251             CU_FREE(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition,
5252                   sizeof(long));
5253             CU_FREE(dmrsDlCfg->choice.setup, sizeof(struct DMRS_DownlinkConfig));
5254          }
5255          CU_FREE(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA, \
5256                sizeof(struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA));
5257       }
5258       CU_FREE(dlBwp->pdsch_Config->choice.setup, sizeof(struct PDSCH_Config));
5259    }
5260 }
5261 /*******************************************************************
5262  *
5263  * @brief Frees emmory allocated for BWPDlDedPdcchCfg
5264  *
5265  * @details
5266  *
5267  *    Function : FreeBWPDlDedPdcchCfg
5268  *
5269  *    Functionality: Deallocating memory of BWPDlDedPdcchCfg
5270  *
5271  * @params[in] BWP_DownlinkDedicated_t *dlBwp
5272  *
5273  * @return void
5274  *
5275  *
5276  * ****************************************************************/
5277 void FreeBWPDlDedPdcchCfg(BWP_DownlinkDedicated_t *dlBwp)
5278 {
5279    uint8_t idx1=0;
5280    uint8_t idx2=0;
5281    struct PDCCH_Config *pdcchCfg=NULLP;
5282    struct ControlResourceSet *controlRSet=NULLP;
5283    struct PDCCH_Config__controlResourceSetToAddModList *controlRSetList=NULLP;
5284
5285    if(dlBwp->pdcch_Config->choice.setup)
5286    {
5287       pdcchCfg=dlBwp->pdcch_Config->choice.setup;
5288       if(pdcchCfg->controlResourceSetToAddModList)
5289       {
5290          controlRSetList = pdcchCfg->controlResourceSetToAddModList;
5291          if(controlRSetList->list.array)
5292          {
5293             controlRSet = controlRSetList->list.array[idx2];
5294             if(controlRSet)
5295             {
5296                if(controlRSet->frequencyDomainResources.buf)
5297                {
5298                   if(controlRSet->pdcch_DMRS_ScramblingID)
5299                   {
5300                      if(pdcchCfg->searchSpacesToAddModList)
5301                      {
5302                         FreeSearchSpcToAddModList(pdcchCfg->searchSpacesToAddModList);
5303                         CU_FREE(pdcchCfg->searchSpacesToAddModList, \
5304                               sizeof(struct PDCCH_Config__searchSpacesToAddModList));
5305                      }
5306                      CU_FREE(controlRSet->pdcch_DMRS_ScramblingID, sizeof(long));
5307                   }
5308                   CU_FREE(controlRSet->frequencyDomainResources.buf, \
5309                         controlRSet->frequencyDomainResources.size);
5310                }
5311             }
5312             for(idx1 = 0; idx1 <controlRSetList->list.count; idx1++)
5313             {
5314                CU_FREE(controlRSetList->list.array[idx1], sizeof(struct ControlResourceSet));
5315             }
5316             CU_FREE(controlRSetList->list.array, controlRSetList->list.size);
5317          }
5318          CU_FREE(pdcchCfg->controlResourceSetToAddModList, \
5319                sizeof(struct PDCCH_Config__controlResourceSetToAddModList));
5320       }
5321       CU_FREE(dlBwp->pdcch_Config->choice.setup, sizeof(struct PDCCH_Config));
5322    }
5323 }
5324 /*******************************************************************
5325  *
5326  * @brief Builds RLC Config
5327  *
5328  * @details
5329  *
5330  *    Function : BuildRlcConfig
5331  *
5332  *    Functionality: Builds RLC Config in BuildRlcBearerToAddModList
5333  *
5334  * @params[in] RLC_Config *rlcConfig
5335  *
5336  * @return ROK     - success
5337  *         RFAILED - failure
5338  *
5339  * ****************************************************************/
5340 uint8_t BuildRlcConfig(struct RLC_Config *rlcConfig)
5341 {
5342
5343    rlcConfig->present = RLC_Config_PR_am;
5344
5345    rlcConfig->choice.am = NULLP;
5346    CU_ALLOC(rlcConfig->choice.am, sizeof(struct RLC_Config__am));
5347    if(!rlcConfig->choice.am)
5348    {
5349       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfig");
5350       return RFAILED;
5351    }
5352
5353    /* UL */
5354    rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength = NULLP;
5355    CU_ALLOC(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
5356    if(!rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength)
5357    {
5358       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfig");
5359       return RFAILED;
5360    }
5361    *(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength) = SN_FIELD_LEN;
5362    rlcConfig->choice.am->ul_AM_RLC.t_PollRetransmit  = T_POLL_RETRANSMIT;
5363    rlcConfig->choice.am->ul_AM_RLC.pollPDU           = POLL_PDU;
5364    rlcConfig->choice.am->ul_AM_RLC.pollByte          = POLL_BYTE;
5365    rlcConfig->choice.am->ul_AM_RLC.maxRetxThreshold  = MAX_RETX_THRESHOLD;
5366
5367    /* DL */
5368    rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength = NULLP;
5369    CU_ALLOC(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
5370    if(!rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength)
5371    {
5372       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfig");
5373       return RFAILED;
5374    }
5375    *(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength) = SN_FIELD_LEN;
5376    rlcConfig->choice.am->dl_AM_RLC.t_Reassembly      = T_REASSEMBLY;
5377    rlcConfig->choice.am->dl_AM_RLC.t_StatusProhibit  = T_STATUS_PROHIBHIT;
5378
5379    return ROK;
5380 }
5381
5382 /*******************************************************************
5383  *
5384  * @brief Builds MAC LC Config
5385  *
5386  * @details
5387  *
5388  *    Function : BuildMacLCConfig
5389  *
5390  *    Functionality: Builds MAC LC Config in BuildRlcBearerToAddModList
5391  *
5392  * @params[in] struct LogicalChannelConfig macLcConfig
5393  *
5394  * @return ROK     - success
5395  *         RFAILED - failure
5396  *
5397  * ****************************************************************/
5398 uint8_t BuildMacLCConfig(struct LogicalChannelConfig *macLcConfig)
5399 {
5400
5401    macLcConfig->ul_SpecificParameters = NULLP;
5402    CU_ALLOC(macLcConfig->ul_SpecificParameters, sizeof(struct LogicalChannelConfig__ul_SpecificParameters));
5403    if(!macLcConfig->ul_SpecificParameters)
5404    {
5405       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacLCConfig");
5406       return RFAILED;
5407    }
5408
5409    macLcConfig->ul_SpecificParameters->priority = MAC_LC_PRIORITY;
5410    macLcConfig->ul_SpecificParameters->prioritisedBitRate =     PRIORTISIED_BIT_RATE;
5411    macLcConfig->ul_SpecificParameters->bucketSizeDuration =     BUCKET_SIZE_DURATION;
5412    macLcConfig->ul_SpecificParameters->allowedServingCells = NULLP;
5413    macLcConfig->ul_SpecificParameters->allowedSCS_List = NULLP;
5414    macLcConfig->ul_SpecificParameters->maxPUSCH_Duration = NULLP;
5415    macLcConfig->ul_SpecificParameters->configuredGrantType1Allowed = NULLP;
5416
5417    macLcConfig->ul_SpecificParameters->logicalChannelGroup = NULLP;
5418    CU_ALLOC(macLcConfig->ul_SpecificParameters->logicalChannelGroup,    sizeof(long));
5419    if(!macLcConfig->ul_SpecificParameters->logicalChannelGroup)
5420    {
5421       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacLCConfig");
5422       return RFAILED;
5423    }
5424    *(macLcConfig->ul_SpecificParameters->logicalChannelGroup) = LC_GRP;
5425
5426    macLcConfig->ul_SpecificParameters->schedulingRequestID = NULLP;
5427    CU_ALLOC(macLcConfig->ul_SpecificParameters->schedulingRequestID,    sizeof(SchedulingRequestId_t));
5428    if(!macLcConfig->ul_SpecificParameters->schedulingRequestID)
5429    {
5430       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacLCConfig");
5431       return RFAILED;
5432    }
5433    *(macLcConfig->ul_SpecificParameters->schedulingRequestID) = SCH_REQ_ID;
5434
5435    macLcConfig->ul_SpecificParameters->logicalChannelSR_Mask = false;
5436    macLcConfig->ul_SpecificParameters->logicalChannelSR_DelayTimerApplied = false;
5437    macLcConfig->ul_SpecificParameters->bitRateQueryProhibitTimer = NULLP;
5438
5439    return ROK;
5440 }
5441 /*******************************************************************
5442  *
5443  * @brief Builds RLC Bearer to Add/Mod list
5444  *
5445  * @details
5446  *
5447  *    Function :BuildRlcBearerToAddModList
5448  *
5449  *    Functionality: Builds RLC Bearer to Add/Mod list in DuToCuRrcContainer
5450  *
5451  * @params[in] rlc_BearerToAddModList
5452  *
5453  * @return ROK     - success
5454  *         RFAILED - failure
5455  *
5456  * ****************************************************************/
5457 uint8_t BuildRlcBearerToAddModList(struct CellGroupConfigRrc__rlc_BearerToAddModList *rlcBearerList)
5458 {
5459    uint8_t                     idx, elementCnt;
5460
5461    elementCnt = 1;
5462    rlcBearerList->list.count = elementCnt;
5463    rlcBearerList->list.size  = elementCnt * sizeof(struct RLC_BearerConfig *);
5464
5465    rlcBearerList->list.array = NULLP;
5466    CU_ALLOC(rlcBearerList->list.array, rlcBearerList->list.size);
5467    if(!rlcBearerList->list.array)
5468    {
5469       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
5470       return RFAILED;
5471    }
5472
5473    for(idx=0; idx<rlcBearerList->list.count; idx++)
5474    {
5475       rlcBearerList->list.array[idx] = NULLP;
5476       CU_ALLOC(rlcBearerList->list.array[idx], sizeof(struct RLC_BearerConfig));
5477       if(!rlcBearerList->list.array[idx])
5478       {
5479          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
5480          return RFAILED;
5481       }
5482    }
5483
5484    idx = 0;
5485    rlcBearerList->list.array[idx]->logicalChannelIdentity = RLC_LCID;
5486
5487    CU_ALLOC(rlcBearerList->list.array[idx]->servedRadioBearer, sizeof(struct RLC_BearerConfig__servedRadioBearer));
5488    if(!rlcBearerList->list.array[idx]->servedRadioBearer)
5489    {
5490       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
5491       return RFAILED;
5492    }
5493
5494    rlcBearerList->list.array[idx]->servedRadioBearer->present = RLC_BearerConfig__servedRadioBearer_PR_srb_Identity;
5495    rlcBearerList->list.array[idx]->servedRadioBearer->choice.srb_Identity = SRB_ID_1;
5496
5497    rlcBearerList->list.array[idx]->reestablishRLC = NULLP;
5498    rlcBearerList->list.array[idx]->rlc_Config = NULLP;
5499    CU_ALLOC(rlcBearerList->list.array[idx]->rlc_Config, sizeof(struct RLC_Config));
5500    if(!rlcBearerList->list.array[idx]->rlc_Config)
5501    {
5502       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
5503       return RFAILED;
5504    }
5505
5506    if(BuildRlcConfig(rlcBearerList->list.array[idx]->rlc_Config) != ROK)
5507    {
5508       DU_LOG("\nERROR  -->  F1AP : BuildRlcConfig failed");
5509       return RFAILED;
5510    }
5511
5512    rlcBearerList->list.array[idx]->mac_LogicalChannelConfig = NULLP;
5513    CU_ALLOC(rlcBearerList->list.array[idx]->mac_LogicalChannelConfig, sizeof(struct LogicalChannelConfig));
5514    if(!rlcBearerList->list.array[idx]->mac_LogicalChannelConfig)
5515    {
5516       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
5517       return RFAILED;
5518    }
5519
5520    if(BuildMacLCConfig(rlcBearerList->list.array[idx]->mac_LogicalChannelConfig) != ROK)
5521    {
5522       DU_LOG("\nERROR  -->  F1AP : BuildMacLCConfig failed");
5523       return RFAILED;
5524    }
5525
5526    return ROK;
5527 }
5528
5529 /*******************************************************************
5530  *
5531  * @brief Free memory allocated for CellGroupConfig
5532  *
5533  * @details
5534  *
5535  *    Function : FreeMemCellGrpCfg
5536  *
5537  *    Functionality: Deallocating memory of CellGroupConfig
5538  *
5539  * @params[in] pointer to CellGroupConfigRrc_t
5540  *
5541  * @return ROK     - success
5542  *         RFAILED - failure
5543  *
5544  ******************************************************************/
5545 uint8_t FreeMemCellGrpCfg(CellGroupConfigRrc_t *cellGrpCfg)
5546 {
5547    uint8_t idx=0;
5548    SpCellConfig_t *spCellCfg=NULLP;
5549    ServingCellConfig_t *srvCellCfg=NULLP;
5550    BWP_DownlinkDedicated_t *dlBwp=NULLP;
5551    MAC_CellGroupConfig_t *macCellGrpCfg=NULLP;
5552    PhysicalCellGroupConfig_t *phyCellGrpCfg=NULLP;
5553    struct CellGroupConfigRrc__rlc_BearerToAddModList *rlcBearerList=NULLP;
5554    struct RLC_Config *rlcConfig=NULLP;
5555    struct LogicalChannelConfig *macLcConfig=NULLP;
5556    struct SchedulingRequestConfig *schedulingRequestConfig=NULLP;
5557    struct SchedulingRequestConfig__schedulingRequestToAddModList *schReqList=NULLP;
5558    struct TAG_Config *tagConfig=NULLP;
5559    struct TAG_Config__tag_ToAddModList *tagList=NULLP;
5560    struct MAC_CellGroupConfig__phr_Config *phrConfig=NULLP;
5561    struct ServingCellConfig__pdsch_ServingCellConfig *pdschCfg=NULLP;
5562
5563    rlcBearerList = cellGrpCfg->rlc_BearerToAddModList;
5564    if(rlcBearerList)
5565    {
5566       if(rlcBearerList->list.array)
5567       {
5568          for(idx=0; idx<rlcBearerList->list.count; idx++)
5569          {
5570             if(rlcBearerList->list.array[idx])
5571             {
5572                rlcConfig   = rlcBearerList->list.array[idx]->rlc_Config;
5573                macLcConfig = rlcBearerList->list.array[idx]->mac_LogicalChannelConfig;
5574                if(rlcConfig)
5575                {
5576                   if(rlcConfig->choice.am)
5577                   {
5578                      CU_FREE(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
5579                      CU_FREE(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
5580                      CU_FREE(rlcConfig->choice.am, sizeof(struct RLC_Config__am));
5581                   }
5582                   CU_FREE(rlcConfig, sizeof(struct RLC_Config));
5583                }
5584                CU_FREE(rlcBearerList->list.array[idx]->servedRadioBearer, sizeof(struct RLC_BearerConfig__servedRadioBearer));
5585                if(macLcConfig)
5586                {
5587                   if(macLcConfig->ul_SpecificParameters)
5588                   {
5589                      CU_FREE(macLcConfig->ul_SpecificParameters->schedulingRequestID,   sizeof(SchedulingRequestId_t));
5590                      CU_FREE(macLcConfig->ul_SpecificParameters->logicalChannelGroup,   sizeof(long));
5591                      CU_FREE(macLcConfig->ul_SpecificParameters, sizeof(struct LogicalChannelConfig__ul_SpecificParameters));
5592                   }
5593                   CU_FREE(rlcBearerList->list.array[idx]->mac_LogicalChannelConfig, sizeof(struct LogicalChannelConfig));
5594                }
5595                CU_FREE(rlcBearerList->list.array[idx], sizeof(struct RLC_BearerConfig));
5596             }
5597          }
5598          CU_FREE(rlcBearerList->list.array, rlcBearerList->list.size);
5599       }
5600       CU_FREE(cellGrpCfg->rlc_BearerToAddModList, sizeof(struct CellGroupConfigRrc__rlc_BearerToAddModList));
5601    }
5602
5603    macCellGrpCfg = cellGrpCfg->mac_CellGroupConfig;
5604    if(macCellGrpCfg)
5605    {
5606       schedulingRequestConfig = macCellGrpCfg->schedulingRequestConfig;
5607       if(schedulingRequestConfig)
5608       {
5609          schReqList = schedulingRequestConfig->schedulingRequestToAddModList;
5610          if(schReqList)
5611          {
5612             if(schReqList->list.array)
5613             {
5614                for(idx=0;idx<schReqList->list.count; idx++)
5615                {
5616                   if(schReqList->list.array[idx])
5617                   {
5618                      CU_FREE(schReqList->list.array[idx]->sr_ProhibitTimer, sizeof(long));
5619                      CU_FREE(schReqList->list.array[idx], sizeof(struct SchedulingRequestToAddMod));
5620                   }
5621                }
5622                CU_FREE(schReqList->list.array, schReqList->list.size);
5623             }
5624             CU_FREE(schedulingRequestConfig->schedulingRequestToAddModList,\
5625                   sizeof(struct SchedulingRequestConfig__schedulingRequestToAddModList));    }
5626             CU_FREE(macCellGrpCfg->schedulingRequestConfig, sizeof(struct SchedulingRequestConfig));
5627       }
5628       if(macCellGrpCfg->bsr_Config)
5629       {
5630          CU_FREE(macCellGrpCfg->bsr_Config, sizeof(struct BSR_Config));
5631       }
5632       tagConfig = macCellGrpCfg->tag_Config;
5633       if(tagConfig)
5634       {
5635          tagList = tagConfig->tag_ToAddModList;
5636          if(tagList)
5637          {
5638             if(tagList->list.array)
5639             {
5640                for(idx=0; idx<tagList->list.count; idx++)
5641                {
5642                   CU_FREE(tagList->list.array[idx], sizeof(struct TAG));
5643                }
5644                CU_FREE(tagList->list.array, tagList->list.size);
5645             }
5646             CU_FREE(tagConfig->tag_ToAddModList, sizeof(struct TAG_Config__tag_ToAddModList));
5647          }
5648          CU_FREE(tagConfig, sizeof(struct TAG_Config));
5649       }
5650
5651       phrConfig = macCellGrpCfg->phr_Config;
5652       if(phrConfig)
5653       {
5654          CU_FREE(phrConfig->choice.setup, sizeof(struct PHR_Config));
5655          CU_FREE(phrConfig, sizeof(struct MAC_CellGroupConfig__phr_Config));
5656       }
5657
5658       CU_FREE(macCellGrpCfg, sizeof(MAC_CellGroupConfig_t));
5659    }
5660
5661    phyCellGrpCfg = cellGrpCfg->physicalCellGroupConfig;
5662    if(phyCellGrpCfg)
5663    {
5664       CU_FREE(phyCellGrpCfg->p_NR_FR1, sizeof(long));
5665       CU_FREE(phyCellGrpCfg, sizeof(PhysicalCellGroupConfig_t));
5666    }
5667
5668    spCellCfg = cellGrpCfg->spCellConfig;
5669    if(spCellCfg)
5670    {
5671       if(spCellCfg->servCellIndex)
5672       {
5673          if(spCellCfg->rlmInSyncOutOfSyncThreshold)
5674          {
5675             if(spCellCfg->spCellConfigDedicated)
5676             {
5677                srvCellCfg = spCellCfg->spCellConfigDedicated;
5678                if(srvCellCfg->initialDownlinkBWP)
5679                {
5680                   dlBwp = srvCellCfg->initialDownlinkBWP;
5681                   if(srvCellCfg->firstActiveDownlinkBWP_Id)
5682                   {
5683                      if(srvCellCfg->defaultDownlinkBWP_Id)
5684                      {
5685                         if(srvCellCfg->uplinkConfig)
5686                         {
5687                            if(srvCellCfg->pdsch_ServingCellConfig)
5688                            {
5689                               pdschCfg= srvCellCfg->pdsch_ServingCellConfig;
5690                               if(pdschCfg->choice.setup)
5691                               {
5692                                  CU_FREE(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH,sizeof(long));
5693                                  CU_FREE(pdschCfg->choice.setup, sizeof( struct PDSCH_ServingCellConfig));
5694                               }
5695                               CU_FREE(srvCellCfg->pdsch_ServingCellConfig, sizeof(struct
5696                                        ServingCellConfig__pdsch_ServingCellConfig));
5697                            }
5698                            FreeinitialUplinkBWP(srvCellCfg->uplinkConfig);
5699                            CU_FREE(srvCellCfg->uplinkConfig, sizeof(UplinkConfig_t));
5700                         }
5701                         CU_FREE(srvCellCfg->defaultDownlinkBWP_Id, sizeof(long));
5702                      }
5703                      CU_FREE(srvCellCfg->firstActiveDownlinkBWP_Id, sizeof(long));
5704                   }
5705                   if(dlBwp->pdcch_Config)
5706                   {
5707                      if(dlBwp->pdsch_Config)
5708                      {
5709                         FreeBWPDlDedPdschCfg(dlBwp);
5710                         CU_FREE(dlBwp->pdsch_Config, sizeof(struct BWP_DownlinkDedicated__pdsch_Config));
5711                      }
5712                      FreeBWPDlDedPdcchCfg(dlBwp);
5713                      CU_FREE(dlBwp->pdcch_Config, sizeof(struct BWP_DownlinkDedicated__pdcch_Config));
5714                   }
5715                   CU_FREE(srvCellCfg->initialDownlinkBWP, sizeof(BWP_DownlinkDedicated_t));
5716                }
5717                CU_FREE(spCellCfg->spCellConfigDedicated, sizeof(ServingCellConfig_t));
5718             }
5719             CU_FREE(spCellCfg->rlmInSyncOutOfSyncThreshold, sizeof(long));
5720          }
5721          CU_FREE(spCellCfg->servCellIndex, sizeof(long));
5722       }
5723       CU_FREE(spCellCfg,sizeof(SpCellConfig_t));
5724    }
5725    return ROK;
5726 }
5727
5728 /*******************************************************************
5729  *
5730  * @brief Fills CellGroupConfig
5731  *
5732  * @details
5733  *
5734  *    Function : fillCellGrpCfg
5735  *
5736  *    Functionality: Fills CellGroupConfig
5737  *
5738  * @params[in] pointer to CellGroupConfigRrc_t
5739  *
5740  * @return ROK     - success
5741  *         RFAILED - failure
5742  *
5743  ******************************************************************/
5744
5745 uint8_t fillCellGrpCfg(CellGroupConfig_t *cellGrp)
5746 {
5747    uint8_t               ret = RFAILED;
5748    CellGroupConfigRrc_t  cellGrpCfg;
5749    asn_enc_rval_t        encRetVal;
5750
5751    while(true)
5752    {
5753       cellGrpCfg.cellGroupId = CELL_GRP_ID;
5754
5755       cellGrpCfg.rlc_BearerToAddModList = NULLP;
5756       CU_ALLOC(cellGrpCfg.rlc_BearerToAddModList, sizeof(struct CellGroupConfigRrc__rlc_BearerToAddModList));
5757       if(!cellGrpCfg.rlc_BearerToAddModList)
5758       {
5759          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in CellGrpConfig");
5760          break;
5761       }
5762       if(BuildRlcBearerToAddModList(cellGrpCfg.rlc_BearerToAddModList) != ROK)
5763       {
5764          DU_LOG("\nERROR  -->  F1AP : fillCellGrpCfg failed");
5765          break;
5766       }
5767
5768       cellGrpCfg.rlc_BearerToReleaseList = NULLP;
5769       cellGrpCfg.mac_CellGroupConfig = NULLP;
5770       CU_ALLOC(cellGrpCfg.mac_CellGroupConfig, sizeof(MAC_CellGroupConfig_t));
5771       if(!cellGrpCfg.mac_CellGroupConfig)
5772       {
5773          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in fillCellGrpCfg");
5774          break;
5775       }
5776       if(BuildMacCellGrpCfg(cellGrpCfg.mac_CellGroupConfig) != ROK)
5777       {
5778          DU_LOG("\nERROR  -->  F1AP : BuildMacCellGrpCfg failed");
5779          break;
5780       }
5781
5782
5783       cellGrpCfg.physicalCellGroupConfig = NULLP;
5784       CU_ALLOC(cellGrpCfg.physicalCellGroupConfig, sizeof(PhysicalCellGroupConfig_t));
5785       if(!cellGrpCfg.physicalCellGroupConfig)
5786       {
5787          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildDuToCuRrcContainer");
5788          break;
5789       }
5790       if(BuildPhyCellGrpCfg(cellGrpCfg.physicalCellGroupConfig) != ROK)
5791       {
5792          DU_LOG("\nERROR  -->  F1AP : BuildPhyCellGrpCfg failed");
5793          break;
5794       }
5795
5796       cellGrpCfg.spCellConfig = NULLP;
5797       CU_ALLOC(cellGrpCfg.spCellConfig, sizeof(SpCellConfig_t));
5798       if(!cellGrpCfg.spCellConfig)
5799       {
5800          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildDuToCuRrcContainer");
5801          break;
5802       }
5803       if(BuildSpCellCfg(cellGrpCfg.spCellConfig) != ROK)
5804       {
5805          DU_LOG("\nERROR  -->  F1AP : BuildSpCellCfg failed");
5806          break;
5807       }
5808
5809       cellGrpCfg.sCellToAddModList = NULLP;
5810       cellGrpCfg.sCellToReleaseList = NULLP;
5811       cellGrpCfg.ext1 = NULLP;
5812
5813       /* encode cellGrpCfg into duToCuRrcContainer */
5814       xer_fprint(stdout, &asn_DEF_CellGroupConfigRrc, &cellGrpCfg);
5815       cmMemset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
5816       encBufSize = 0;
5817       encRetVal = aper_encode(&asn_DEF_CellGroupConfigRrc, 0, &cellGrpCfg, PrepFinalEncBuf, encBuf);
5818       /* Encode results */
5819       if(encRetVal.encoded == ENCODE_FAIL)
5820       {
5821          DU_LOG( "\nERROR  -->  F1AP : Could not encode DuToCuRrcContainer (at %s)\n",\
5822                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
5823          break;
5824       }
5825       else
5826       {
5827          DU_LOG("\nDEBUG  -->  F1AP : Created APER encodedbuffer for DuToCuRrcContainer\n");
5828          for(int i=0; i< encBufSize; i++)
5829          {
5830             DU_LOG("%x",encBuf[i]);
5831          }
5832       }
5833
5834       cellGrp->size = encBufSize;
5835       CU_ALLOC(cellGrp->buf, cellGrp->size);
5836       if(!cellGrp->buf)
5837       {
5838          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDuToCuRrcContainer");
5839          break;
5840       }
5841       memcpy(cellGrp->buf, encBuf, cellGrp->size);
5842       ret = ROK;
5843       break;
5844    }
5845    FreeMemCellGrpCfg(&cellGrpCfg);
5846    return ROK;
5847 }
5848
5849 /*******************************************************************
5850  *
5851  * @brief Free UE Capability RAT container
5852  *
5853  * @details
5854  *
5855  *    Function : freeUeCapRatCont
5856  *
5857  *    Functionality:
5858  *       Free UE Capability RAT conatiner
5859  *
5860  * @params[in]
5861  * @return ROK     - success
5862  *         RFAILED - failure
5863  *
5864  * ****************************************************************/
5865 void freeUeCapRatCont(UE_NR_Capability_t *ueNrCap)
5866 {
5867    uint8_t idx;
5868    FeatureSets_t *featureSets;
5869
5870    if(ueNrCap->rf_Parameters.supportedBandListNR.list.array)
5871    {
5872       for(idx = 0; idx < ueNrCap->rf_Parameters.supportedBandListNR.list.count; idx++)
5873       {
5874          if(ueNrCap->rf_Parameters.supportedBandListNR.list.array[idx])
5875             CU_FREE(ueNrCap->rf_Parameters.supportedBandListNR.list.array[idx], sizeof(struct BandNR));
5876       }
5877       CU_FREE(ueNrCap->rf_Parameters.supportedBandListNR.list.array, ueNrCap->rf_Parameters.supportedBandListNR.list.size);
5878    }
5879
5880    if(ueNrCap->featureSets)
5881    {
5882       featureSets = ueNrCap->featureSets;
5883       if(featureSets->featureSetsDownlinkPerCC)
5884       {
5885          if(featureSets->featureSetsDownlinkPerCC->list.array)
5886          {
5887             for(idx = 0; idx < featureSets->featureSetsDownlinkPerCC->list.count; idx++)
5888             {
5889                   if(featureSets->featureSetsDownlinkPerCC->list.array[idx]->supportedModulationOrderDL)
5890                      CU_FREE(featureSets->featureSetsDownlinkPerCC->list.array[idx]->supportedModulationOrderDL, \
5891                         sizeof(ModulationOrder_t));
5892                   CU_FREE(featureSets->featureSetsDownlinkPerCC->list.array[idx], sizeof(struct FeatureSetDownlinkPerCC));
5893             }
5894             CU_FREE(featureSets->featureSetsDownlinkPerCC->list.array, featureSets->featureSetsDownlinkPerCC->list.size);
5895          }
5896          CU_FREE(featureSets->featureSetsDownlinkPerCC, sizeof(struct FeatureSets__featureSetsDownlinkPerCC));
5897       }
5898
5899       if(featureSets->featureSetsUplinkPerCC)
5900       {
5901          if(featureSets->featureSetsUplinkPerCC->list.array)
5902          {
5903             for(idx = 0; idx < featureSets->featureSetsUplinkPerCC->list.count; idx++)
5904             {
5905                if(featureSets->featureSetsUplinkPerCC->list.array[idx])
5906                {
5907                   if(featureSets->featureSetsUplinkPerCC->list.array[idx]->supportedModulationOrderUL)
5908                      CU_FREE(featureSets->featureSetsUplinkPerCC->list.array[idx]->supportedModulationOrderUL,\
5909                          sizeof(ModulationOrder_t));
5910                   CU_FREE(featureSets->featureSetsUplinkPerCC->list.array[idx], sizeof(struct FeatureSetUplinkPerCC));
5911                }
5912             }
5913             CU_FREE(featureSets->featureSetsUplinkPerCC->list.array,  featureSets->featureSetsUplinkPerCC->list.size);
5914          }
5915          CU_FREE(featureSets->featureSetsUplinkPerCC, sizeof(struct FeatureSets__featureSetsUplinkPerCC));
5916       }
5917       CU_FREE(ueNrCap->featureSets, sizeof(struct FeatureSets));
5918    }
5919 }
5920
5921 /*******************************************************************
5922  *
5923  * @brief Free UE capability RAT container list
5924  *
5925  * @details
5926  *
5927  *    Function : freeUeCapRatContList
5928  *
5929  *    Functionality: Free UE capability RAT container list
5930  *
5931  * @params[in]
5932  * @return ROK     - success
5933  *         RFAILED - failure
5934  *
5935  * ****************************************************************/
5936 void freeUeCapRatContList(UE_CapabilityRAT_ContainerListRRC_t *ueCapablityList)
5937 {
5938    uint8_t idx;
5939    if(ueCapablityList->list.array)
5940    {
5941       for(idx = 0; idx < ueCapablityList->list.count; idx++)
5942       {
5943          if(ueCapablityList->list.array[idx])
5944             CU_FREE(ueCapablityList->list.array[idx], sizeof(UE_CapabilityRAT_Container_t));
5945       }
5946       CU_FREE(ueCapablityList->list.array, ueCapablityList->list.size);
5947    }
5948 }
5949
5950 /*******************************************************************
5951  *
5952  * @brief Fill feature sets
5953  *
5954  * @details
5955  *
5956  *    Function : fillFeatureSets
5957  *
5958  *    Functionality: Fill feature sets
5959  *
5960  * @params[in]
5961  * @return ROK     - success
5962  *         RFAILED - failure
5963  *
5964  * ****************************************************************/
5965 uint8_t fillFeatureSets(FeatureSets_t *featureSets)
5966 {
5967    uint8_t idx, elementCnt;
5968
5969    featureSets->featureSetsDownlink = NULLP;
5970    CU_ALLOC(featureSets->featureSetsDownlinkPerCC, sizeof(struct FeatureSets__featureSetsDownlinkPerCC));
5971    if(!featureSets->featureSetsDownlinkPerCC)
5972    {
5973       DU_LOG("\nERROR  --> F1AP : Memory allocation failed in fillFeatureSets");
5974       return RFAILED;
5975    }
5976
5977    elementCnt = 1;
5978    featureSets->featureSetsDownlinkPerCC->list.count = elementCnt;
5979    featureSets->featureSetsDownlinkPerCC->list.size = elementCnt * sizeof(struct FeatureSetDownlinkPerCC *);
5980    CU_ALLOC(featureSets->featureSetsDownlinkPerCC->list.array, featureSets->featureSetsDownlinkPerCC->list.size);
5981    if(!featureSets->featureSetsDownlinkPerCC->list.array)
5982    {
5983       DU_LOG("\nERROR  --> F1AP : Memory allocation failed in fillFeatureSets");
5984       return RFAILED;
5985    }
5986
5987    for(idx = 0; idx < elementCnt; idx++)
5988    {
5989       CU_ALLOC(featureSets->featureSetsDownlinkPerCC->list.array[idx], sizeof(struct FeatureSetDownlinkPerCC));
5990       if(!featureSets->featureSetsDownlinkPerCC->list.array[idx])
5991       {
5992          DU_LOG("\nERROR  --> F1AP : Memory allocation failed in fillFeatureSets");
5993          return RFAILED;
5994       }
5995    }
5996
5997    idx = 0;
5998    featureSets->featureSetsDownlinkPerCC->list.array[idx]->supportedSubcarrierSpacingDL = SubcarrierSpacing_kHz15;
5999    featureSets->featureSetsDownlinkPerCC->list.array[idx]->supportedBandwidthDL.present = SupportedBandwidth_PR_fr1;
6000    featureSets->featureSetsDownlinkPerCC->list.array[idx]->supportedBandwidthDL.choice.fr1 = SupportedBandwidth__fr1_mhz20;
6001    featureSets->featureSetsDownlinkPerCC->list.array[idx]->channelBW_90mhz = NULLP;
6002    featureSets->featureSetsDownlinkPerCC->list.array[idx]->maxNumberMIMO_LayersPDSCH = NULLP;
6003
6004    CU_ALLOC(featureSets->featureSetsDownlinkPerCC->list.array[idx]->supportedModulationOrderDL, sizeof(ModulationOrder_t));
6005    if(!featureSets->featureSetsDownlinkPerCC->list.array[idx]->supportedModulationOrderDL)
6006    {
6007       DU_LOG("\nERROR  --> F1AP : Memory allocation failed in fillFeatureSets");
6008       return RFAILED;
6009    }
6010    *(featureSets->featureSetsDownlinkPerCC->list.array[idx]->supportedModulationOrderDL) = ModulationOrder_qam64;
6011
6012    featureSets->featureSetsUplink = NULLP;
6013    CU_ALLOC(featureSets->featureSetsUplinkPerCC, sizeof(struct FeatureSets__featureSetsUplinkPerCC));
6014    if(!featureSets->featureSetsUplinkPerCC)
6015    {
6016       DU_LOG("\nERROR  --> F1AP : Memory allocation failed in fillFeatureSets");
6017       return RFAILED;
6018    }
6019
6020    elementCnt = 1;
6021    featureSets->featureSetsUplinkPerCC->list.count = elementCnt;
6022    featureSets->featureSetsUplinkPerCC->list.size = elementCnt * sizeof(struct FeatureSetUplinkPerCC *);
6023    CU_ALLOC(featureSets->featureSetsUplinkPerCC->list.array, featureSets->featureSetsUplinkPerCC->list.size);
6024    if(!featureSets->featureSetsUplinkPerCC->list.array)
6025    {
6026       DU_LOG("\nERROR  --> F1AP : Memory allocation failed in fillFeatureSets");
6027       return RFAILED;
6028    }
6029
6030    for(idx = 0; idx < elementCnt; idx++)
6031    {
6032       CU_ALLOC(featureSets->featureSetsUplinkPerCC->list.array[idx], sizeof(struct FeatureSetUplinkPerCC));
6033       if(!featureSets->featureSetsUplinkPerCC->list.array[idx])
6034       {
6035          DU_LOG("\nERROR  --> F1AP : Memory allocation failed in fillFeatureSets");
6036          return RFAILED;
6037       }
6038    }
6039
6040    idx = 0;
6041    featureSets->featureSetsUplinkPerCC->list.array[idx]->supportedSubcarrierSpacingUL = SubcarrierSpacing_kHz15;
6042    featureSets->featureSetsUplinkPerCC->list.array[idx]->supportedBandwidthUL.present = SupportedBandwidth_PR_fr1;
6043    featureSets->featureSetsUplinkPerCC->list.array[idx]->supportedBandwidthUL.choice.fr1 = SupportedBandwidth__fr1_mhz20;
6044    featureSets->featureSetsUplinkPerCC->list.array[idx]->channelBW_90mhz = NULLP;
6045    featureSets->featureSetsUplinkPerCC->list.array[idx]->mimo_CB_PUSCH = NULLP;
6046    featureSets->featureSetsUplinkPerCC->list.array[idx]->maxNumberMIMO_LayersNonCB_PUSCH = NULLP;
6047
6048    CU_ALLOC(featureSets->featureSetsUplinkPerCC->list.array[idx]->supportedModulationOrderUL, sizeof(ModulationOrder_t));
6049    if(!featureSets->featureSetsUplinkPerCC->list.array[idx]->supportedModulationOrderUL)
6050    {
6051       DU_LOG("\nERROR  --> F1AP : Memory allocation failed in fillFeatureSets");
6052       return RFAILED;
6053    }
6054    *(featureSets->featureSetsUplinkPerCC->list.array[idx]->supportedModulationOrderUL) = ModulationOrder_qam16;
6055
6056    return ROK;
6057 }
6058
6059 /*******************************************************************
6060  *
6061  * @brief Fill UE capability RAT container
6062  *
6063  * @details
6064  *
6065  *    Function : fillUeCapRatCont
6066  *
6067  *    Functionality: Fill UE capability RAT container
6068  *
6069  * @params[in] UE Capability RAT container buffer
6070  * @return ROK     - success
6071  *         RFAILED - failure
6072  *
6073  * ****************************************************************/
6074 uint8_t fillUeCapRatCont(OCTET_STRING_t *ueCapRatContBuf)
6075 {
6076    uint8_t             ret = ROK;
6077    uint8_t             idx, elementCnt;
6078    asn_enc_rval_t      encRetVal;
6079    UE_NR_Capability_t  ueNrCap;
6080
6081    while(true)
6082    {
6083       ueNrCap.accessStratumRelease = AccessStratumRelease_rel15;
6084
6085       /* Filling PDCP parameters */
6086       ueNrCap.pdcp_Parameters.supportedROHC_Profiles.profile0x0000 = false;
6087       ueNrCap.pdcp_Parameters.supportedROHC_Profiles.profile0x0001 = false;
6088       ueNrCap.pdcp_Parameters.supportedROHC_Profiles.profile0x0002 = false;
6089       ueNrCap.pdcp_Parameters.supportedROHC_Profiles.profile0x0003 = false;
6090       ueNrCap.pdcp_Parameters.supportedROHC_Profiles.profile0x0004 = false;
6091       ueNrCap.pdcp_Parameters.supportedROHC_Profiles.profile0x0006 = false;
6092       ueNrCap.pdcp_Parameters.supportedROHC_Profiles.profile0x0101 = false;
6093       ueNrCap.pdcp_Parameters.supportedROHC_Profiles.profile0x0102 = false;
6094       ueNrCap.pdcp_Parameters.supportedROHC_Profiles.profile0x0103 = false;
6095       ueNrCap.pdcp_Parameters.supportedROHC_Profiles.profile0x0104 = false;
6096       ueNrCap.pdcp_Parameters.maxNumberROHC_ContextSessions = PDCP_Parameters__maxNumberROHC_ContextSessions_cs2;
6097       ueNrCap.pdcp_Parameters.uplinkOnlyROHC_Profiles = NULLP;
6098       ueNrCap.pdcp_Parameters.continueROHC_Context = NULLP;
6099       ueNrCap.pdcp_Parameters.outOfOrderDelivery = NULLP;
6100       ueNrCap.pdcp_Parameters.shortSN = NULLP;
6101       ueNrCap.pdcp_Parameters.pdcp_DuplicationSRB = NULLP;
6102       ueNrCap.pdcp_Parameters.pdcp_DuplicationMCG_OrSCG_DRB = NULLP;
6103
6104       ueNrCap.rlc_Parameters = NULLP;
6105       ueNrCap.mac_Parameters = NULLP;
6106
6107       /* Filling PHY parameters */
6108       ueNrCap.phy_Parameters.phy_ParametersCommon = NULLP;
6109       ueNrCap.phy_Parameters.phy_ParametersXDD_Diff = NULLP;
6110       ueNrCap.phy_Parameters.phy_ParametersFRX_Diff = NULLP;
6111       ueNrCap.phy_Parameters.phy_ParametersFR1 = NULLP;
6112       ueNrCap.phy_Parameters.phy_ParametersFR2 = NULLP;
6113
6114       /* Filling RF parameters */
6115       elementCnt = 1;
6116       ueNrCap.rf_Parameters.supportedBandListNR.list.count = elementCnt;
6117       ueNrCap.rf_Parameters.supportedBandListNR.list.size = elementCnt * sizeof(struct BandNR *);
6118       CU_ALLOC(ueNrCap.rf_Parameters.supportedBandListNR.list.array, ueNrCap.rf_Parameters.supportedBandListNR.list.size);
6119       if(!ueNrCap.rf_Parameters.supportedBandListNR.list.array)
6120       {
6121          DU_LOG("\nERROR  --> F1AP : Memory allocation failed in fillUeCapRatCont");
6122          ret = RFAILED;
6123          break;
6124       }
6125
6126       for(idx = 0; idx < elementCnt; idx++)
6127       {
6128          CU_ALLOC(ueNrCap.rf_Parameters.supportedBandListNR.list.array[idx], sizeof(struct BandNR));
6129          if(!ueNrCap.rf_Parameters.supportedBandListNR.list.array[idx])
6130          {
6131             ret = RFAILED;
6132             break;
6133          }
6134       }
6135       if(ret == RFAILED)
6136          break;
6137
6138       idx = 0;
6139       ueNrCap.rf_Parameters.supportedBandListNR.list.array[idx]->bandNR = 1;
6140       ueNrCap.rf_Parameters.supportedBandCombinationList = NULLP;
6141       ueNrCap.rf_Parameters.appliedFreqBandListFilter = NULLP;
6142
6143       ueNrCap.measAndMobParameters = NULLP;
6144       ueNrCap.fdd_Add_UE_NR_Capabilities = NULLP;
6145       ueNrCap.tdd_Add_UE_NR_Capabilities = NULLP;
6146       ueNrCap.fr1_Add_UE_NR_Capabilities = NULLP;
6147       ueNrCap.fr2_Add_UE_NR_Capabilities = NULLP;
6148       ueNrCap.featureSets = NULLP;
6149
6150       CU_ALLOC(ueNrCap.featureSets, sizeof(struct FeatureSets));
6151       if(!ueNrCap.featureSets)
6152       {
6153          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in fillUeCapRatCont");
6154          ret = RFAILED;
6155          break;
6156       }
6157
6158       if(fillFeatureSets(ueNrCap.featureSets) != ROK)
6159       {
6160          DU_LOG("\nERROR  -->  fillDLFeatureSets() failed ");
6161          ret = RFAILED;
6162          break;
6163       }
6164
6165       ueNrCap.featureSetCombinations = NULLP;
6166       ueNrCap.lateNonCriticalExtension = NULLP;
6167       ueNrCap.nonCriticalExtension = NULLP;
6168
6169       /* encode UE Capability RAT Container List into duToCuRrcContainer */
6170       xer_fprint(stdout, &asn_DEF_UE_NR_Capability, &ueNrCap);
6171       cmMemset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
6172       encBufSize = 0;
6173       encRetVal = aper_encode(&asn_DEF_UE_NR_Capability, 0, &ueNrCap, PrepFinalEncBuf, encBuf);
6174
6175       /* Encode results */
6176       if(encRetVal.encoded == ENCODE_FAIL)
6177       {
6178          DU_LOG( "\nERROR  -->  F1AP : Could not encode UE Capability RAT Container (at %s)\n",\
6179             encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
6180          break;
6181       }
6182       else
6183       {
6184          DU_LOG("\nDEBUG  -->  F1AP : Created APER encodedbuffer for UE Capability RAT Container\n");
6185          for(int i=0; i< encBufSize; i++)
6186          {
6187             DU_LOG("%x",encBuf[i]);
6188          }
6189       }
6190
6191       ueCapRatContBuf->size = encBufSize;
6192       CU_ALLOC(ueCapRatContBuf->buf, ueCapRatContBuf->size);
6193       if(!ueCapRatContBuf->buf)
6194       {
6195          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in fillUeCapabilityContainer");
6196          break;
6197       }
6198       memcpy(ueCapRatContBuf->buf, encBuf, ueCapRatContBuf->size);
6199       ret = ROK;
6200       break;
6201    }
6202    freeUeCapRatCont(&ueNrCap);
6203    return ROK;
6204 }
6205
6206 /*******************************************************************
6207  *
6208  * @brief Fill UE Capability RAT container list
6209  *
6210  * @details
6211  *
6212  *    Function : fillUeCapRatContList
6213  *
6214  *    Functionality: Fill UE Capability RAT container list
6215
6216  *
6217  * @params[in] UE capability RAT container list buffer
6218  * @return ROK     - success
6219  *         RFAILED - failure
6220  *
6221  * ****************************************************************/
6222 uint8_t fillUeCapRatContList(UE_CapabilityRAT_ContainerList_t *ueCapablityListBuf)
6223 {
6224     uint8_t          ret = RFAILED;
6225     uint8_t          idx, elementCnt;
6226     asn_enc_rval_t   encRetVal;
6227     UE_CapabilityRAT_ContainerListRRC_t  ueCapablityList;
6228
6229     while(true)
6230     {
6231        elementCnt = 1;
6232        ueCapablityList.list.count = elementCnt;
6233        ueCapablityList.list.size = elementCnt * sizeof(UE_CapabilityRAT_Container_t *);
6234
6235        CU_ALLOC(ueCapablityList.list.array, ueCapablityList.list.size);
6236        if(!ueCapablityList.list.array)
6237        {
6238           DU_LOG("\nERROR  -->  Memory allocation failed in fillUeCapRatContList");
6239           ret = RFAILED;
6240           break;
6241        }
6242
6243        for(idx=0; idx<elementCnt; idx++)
6244        {
6245           CU_ALLOC(ueCapablityList.list.array[idx], sizeof(UE_CapabilityRAT_Container_t));
6246           if(ueCapablityList.list.array[idx] == NULLP)
6247           {
6248              DU_LOG("\nERROR  -->  Memory allocation failed in fillUeCapRatContList");
6249              ret = RFAILED;
6250              break;
6251           }
6252        }
6253        idx = 0;
6254        ueCapablityList.list.array[idx]->rat_Type = RAT_Type_nr;
6255        ret = fillUeCapRatCont(&ueCapablityList.list.array[idx]->ue_CapabilityRAT_Container);
6256
6257        /* encode UE Capability RAT Container List into duToCuRrcContainer */
6258        xer_fprint(stdout, &asn_DEF_UE_CapabilityRAT_ContainerListRRC, &ueCapablityList);
6259        cmMemset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
6260        encBufSize = 0;
6261        encRetVal = aper_encode(&asn_DEF_UE_CapabilityRAT_ContainerListRRC, 0, \
6262           &ueCapablityList, PrepFinalEncBuf, encBuf);
6263
6264        /* Encode results */
6265        if(encRetVal.encoded == ENCODE_FAIL)
6266        {
6267           DU_LOG( "\nERROR  -->  F1AP : Could not encode UE Capability RAT Container (at %s)\n",\
6268              encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
6269           break;
6270        }
6271        else
6272        {
6273           DU_LOG("\nDEBUG  -->  F1AP : Created APER encodedbuffer for UE Capability RAT Container\n");
6274           for(int i=0; i< encBufSize; i++)
6275           {
6276              DU_LOG("%x",encBuf[i]);
6277           }
6278        }
6279
6280        ueCapablityListBuf->size = encBufSize;
6281        CU_ALLOC(ueCapablityListBuf->buf, ueCapablityListBuf->size);
6282        if(!ueCapablityListBuf->buf)
6283        {
6284           DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in fillUeCapabilityContainer");
6285           break;
6286        }
6287        memcpy(ueCapablityListBuf->buf, encBuf, ueCapablityListBuf->size);
6288        ret = ROK;
6289        break;
6290     }
6291     freeUeCapRatContList(&ueCapablityList);
6292     return ROK;
6293 }
6294
6295 /*******************************************************************
6296  *
6297  * @brief Fills CuToDuContainer
6298  *
6299  * @details
6300  *
6301  *    Function : fillCuToDuContainer
6302  *
6303  *    Functionality: Fills CuToDuContainer
6304  *
6305  * @params[in] pointer to CUtoDURRCInformation_t
6306  *
6307  * @return ROK     - success
6308  *         RFAILED - failure
6309  *
6310  ******************************************************************/
6311
6312 uint8_t fillCuToDuContainer(CUtoDURRCInformation_t *rrcMsg)
6313 {
6314    uint8_t elementCnt = 0;
6315    uint8_t ret = ROK;
6316    uint8_t idx, idx2, rrcBufLen;
6317
6318    CU_ALLOC(rrcMsg->uE_CapabilityRAT_ContainerList, sizeof(UE_CapabilityRAT_ContainerList_t));
6319    if(!rrcMsg->uE_CapabilityRAT_ContainerList)
6320    {
6321       DU_LOG("\nERROR  -->  F1AP : Memory allocation for CUtoDURRCInformation_ExtIEs failed");
6322       return RFAILED;
6323    }
6324    ret = fillUeCapRatContList(rrcMsg->uE_CapabilityRAT_ContainerList);
6325
6326    CU_ALLOC(rrcMsg->iE_Extensions, sizeof(ProtocolExtensionContainer_4624P16_t));
6327    if(rrcMsg->iE_Extensions)
6328    {
6329       elementCnt = 1;
6330       rrcMsg->iE_Extensions->list.count = elementCnt;
6331       rrcMsg->iE_Extensions->list.size = elementCnt * sizeof(CUtoDURRCInformation_ExtIEs_t);
6332
6333       /* Initialize the CUtoDURRCInformation_ExtIEs */
6334       CU_ALLOC(rrcMsg->iE_Extensions->list.array, rrcMsg->iE_Extensions->list.size);
6335
6336       if(rrcMsg->iE_Extensions->list.array == NULLP)
6337       {
6338          DU_LOG("\nERROR  -->  F1AP : Memory allocation for CUtoDURRCInformation_ExtIEs failed");
6339          ret = RFAILED;
6340       }
6341
6342       for(idx=0; idx<elementCnt; idx++)
6343       {
6344          CU_ALLOC(rrcMsg->iE_Extensions->list.array[idx], sizeof(CUtoDURRCInformation_ExtIEs_t));
6345          if(rrcMsg->iE_Extensions->list.array[idx] == NULLP)
6346          {
6347             ret = RFAILED;
6348          }
6349       }
6350       idx = 0;
6351       /* Filling CellGroupConfig_t IE */
6352       rrcMsg->iE_Extensions->list.array[idx]->id = ProtocolIE_ID_id_CellGroupConfig;
6353       rrcMsg->iE_Extensions->list.array[idx]->criticality = Criticality_ignore;
6354       rrcMsg->iE_Extensions->list.array[idx]->extensionValue.present  =\
6355                                                                        CUtoDURRCInformation_ExtIEs__extensionValue_PR_CellGroupConfig;
6356       ret = fillCellGrpCfg(&rrcMsg->iE_Extensions->list.array[idx]->extensionValue.choice.CellGroupConfig);
6357    }
6358    return ret;
6359 }
6360
6361 /*******************************************************************
6362  *
6363  * @brief Free CuToDuContainer
6364  *
6365  * @details
6366  *
6367  *    Function : FreeCuToDuInfo
6368  *
6369  *    Functionality: Free CuToDuContainer
6370  *
6371  * @params[in] pointer to CUtoDURRCInformation_t
6372  *
6373  * @return ROK     - success
6374  *         RFAILED - failure
6375  *
6376  ******************************************************************/
6377
6378 void FreeCuToDuInfo(CUtoDURRCInformation_t *rrcMsg)
6379 {
6380    uint8_t idx, idx2;
6381
6382    if(rrcMsg->uE_CapabilityRAT_ContainerList)
6383    {
6384       if(rrcMsg->uE_CapabilityRAT_ContainerList->buf)
6385          CU_FREE(rrcMsg->uE_CapabilityRAT_ContainerList->buf, rrcMsg->uE_CapabilityRAT_ContainerList->size);
6386       CU_FREE(rrcMsg->uE_CapabilityRAT_ContainerList, sizeof(UE_CapabilityRAT_ContainerList_t));
6387    }
6388    if(rrcMsg->iE_Extensions)
6389    {
6390       if(rrcMsg->iE_Extensions->list.array)
6391       {
6392          for(idx= 0; idx < rrcMsg->iE_Extensions->list.count; idx++)
6393          {
6394             if(rrcMsg->iE_Extensions->list.array[idx])
6395             {
6396                switch(rrcMsg->iE_Extensions->list.array[idx]->id)
6397                {
6398                   case ProtocolIE_ID_id_CellGroupConfig:
6399                      if(rrcMsg->iE_Extensions->list.array[idx]->extensionValue.choice.CellGroupConfig.buf != NULLP)
6400                      {
6401                         CU_FREE(rrcMsg->iE_Extensions->list.array[idx]->extensionValue.choice.CellGroupConfig.buf,\
6402                               rrcMsg->iE_Extensions->list.array[idx]->extensionValue.choice.CellGroupConfig.size);
6403
6404                      }
6405                      break;
6406                   default:
6407                      DU_LOG("\nERROR  -->  F1AP : Invalid Event type %ld at FreeCuToDuInfo()", \
6408                            rrcMsg->iE_Extensions->list.array[idx]->id);
6409                      break;
6410                }
6411             }
6412             break;
6413          }
6414          for(idx2 = 0; idx2 < idx; idx2++)
6415          {
6416             CU_FREE(rrcMsg->iE_Extensions->list.array[idx2], sizeof(CUtoDURRCInformation_ExtIEs_t));
6417          }
6418          CU_FREE(rrcMsg->iE_Extensions->list.array, rrcMsg->iE_Extensions->list.size);
6419
6420       }
6421
6422       CU_FREE(rrcMsg->iE_Extensions, sizeof(ProtocolExtensionContainer_4624P16_t));
6423    }
6424 }
6425 /*******************************************************************
6426  *
6427  * @brief Builds and sends the UE Setup Request
6428  *
6429  * @details
6430  *
6431  *    Function : BuildAndSendUeContextSetupReq
6432  *
6433  *    Functionality: Constructs the UE Setup Request and sends
6434  *                   it to the CU through SCTP.
6435  *
6436  * @params[in]
6437  *
6438  * @return ROK     - success
6439  *         RFAILED - failure
6440  *
6441  * ****************************************************************/
6442 uint8_t BuildAndSendUeContextSetupReq(uint8_t cuUeF1apId, uint8_t duUeF1apId, \
6443       uint16_t rrcContLen, uint8_t *rrcContainer)
6444 {
6445    uint8_t   Nrcgiret;
6446    uint8_t   SplCellListret;
6447    uint8_t   SrbSetupret;
6448    uint8_t   elementCnt;
6449    uint8_t   idx, bufLen;
6450    uint8_t   idx1;
6451    F1AP_PDU_t           *f1apMsg = NULLP;
6452    UEContextSetupRequest_t *ueSetReq = NULLP;
6453    asn_enc_rval_t encRetVal;        /* Encoder return value */
6454    memset(&encRetVal, 0, sizeof(asn_enc_rval_t));
6455    uint8_t ret= RFAILED;
6456    uint8_t ret1;
6457    while(true)
6458    {
6459       DU_LOG("\nINFO  -->  F1AP : Building UE Context Setup Request\n");
6460
6461       CU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
6462       if(f1apMsg == NULLP)
6463       {
6464          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
6465          break;
6466       }
6467
6468       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
6469       CU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
6470       if(f1apMsg->choice.initiatingMessage == NULLP)
6471       {
6472          DU_LOG("\nERROR  -->  F1AP : Memory allocation for     F1AP-PDU failed");
6473          break;
6474       }
6475
6476       f1apMsg->choice.initiatingMessage->procedureCode = \
6477                                                          ProcedureCode_id_UEContextSetup;
6478       f1apMsg->choice.initiatingMessage->criticality = Criticality_reject;
6479       f1apMsg->choice.initiatingMessage->value.present = \
6480                                                          InitiatingMessage__value_PR_UEContextSetupRequest;
6481       ueSetReq =
6482          &f1apMsg->choice.initiatingMessage->value.choice.UEContextSetupRequest;
6483
6484       elementCnt = 12;
6485       ueSetReq->protocolIEs.list.count = elementCnt;
6486       ueSetReq->protocolIEs.list.size = \
6487                                         elementCnt * sizeof(UEContextSetupRequestIEs_t *);
6488
6489       /* Initialize the UESetup members */
6490       CU_ALLOC(ueSetReq->protocolIEs.list.array,ueSetReq->protocolIEs.list.size);
6491
6492       if(ueSetReq->protocolIEs.list.array == NULLP)
6493       {
6494          DU_LOG("\nERROR  -->  F1AP : Memory allocation for UE Context SetupRequest failed");
6495          break;
6496       }
6497
6498       for(idx1=0; idx1<elementCnt; idx1++)
6499       {
6500          CU_ALLOC(ueSetReq->protocolIEs.list.array[idx1],sizeof(UEContextSetupRequestIEs_t));
6501          if(ueSetReq->protocolIEs.list.array[idx1] == NULLP)
6502          {
6503             break;
6504          }
6505       }
6506
6507       idx = 0;
6508
6509       /*GNB CU UE F1AP ID*/
6510       ueSetReq->protocolIEs.list.array[idx]->id = \
6511                                                   ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
6512       ueSetReq->protocolIEs.list.array[idx]->criticality        =       Criticality_reject;
6513       ueSetReq->protocolIEs.list.array[idx]->value.present = \
6514                                                              UEContextSetupRequestIEs__value_PR_GNB_CU_UE_F1AP_ID;
6515       ueSetReq->protocolIEs.list.array[idx]->value.choice.GNB_CU_UE_F1AP_ID = cuUeF1apId;
6516
6517       /*GNB DU UE F1AP ID*/
6518       idx++;
6519       ueSetReq->protocolIEs.list.array[idx]->id = \
6520                                                   ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
6521       ueSetReq->protocolIEs.list.array[idx]->criticality        =       Criticality_ignore;
6522       ueSetReq->protocolIEs.list.array[idx]->value.present = \
6523                                                              UEContextSetupRequestIEs__value_PR_GNB_DU_UE_F1AP_ID;
6524       ueSetReq->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID = duUeF1apId;
6525
6526       /*Special Cell ID*/
6527       idx++;
6528       ueSetReq->protocolIEs.list.array[idx]->id = \
6529                                                   ProtocolIE_ID_id_SpCell_ID;
6530       ueSetReq->protocolIEs.list.array[idx]->criticality        =       Criticality_reject;
6531       ueSetReq->protocolIEs.list.array[idx]->value.present = \
6532                                                              UEContextSetupRequestIEs__value_PR_NRCGI;
6533       Nrcgiret = BuildNrcgi(&ueSetReq->protocolIEs.list.array[idx]->value.choice.NRCGI);
6534       if(Nrcgiret != ROK)
6535       {
6536          break;
6537       }
6538
6539       /*Served Cell Index*/
6540       idx++;
6541       ueSetReq->protocolIEs.list.array[idx]->id = \
6542                                                   ProtocolIE_ID_id_ServCellIndex;
6543       ueSetReq->protocolIEs.list.array[idx]->criticality        =       Criticality_reject;
6544       ueSetReq->protocolIEs.list.array[idx]->value.present = \
6545                                                              UEContextSetupRequestIEs__value_PR_ServCellIndex;
6546       ueSetReq->protocolIEs.list.array[idx]->value.choice.ServCellIndex = \
6547                                                                           CELL_INDEX;
6548
6549       /*CellULConfigured*/
6550       idx++;
6551       ueSetReq->protocolIEs.list.array[idx]->id = \
6552                                                   ProtocolIE_ID_id_SpCellULConfigured;
6553       ueSetReq->protocolIEs.list.array[idx]->criticality        =       Criticality_ignore;
6554       ueSetReq->protocolIEs.list.array[idx]->value.present = \
6555                                                              UEContextSetupRequestIEs__value_PR_CellULConfigured;
6556       ueSetReq->protocolIEs.list.array[idx]->value.choice.CellULConfigured = \
6557                                                                              CellULConfigured_none;
6558
6559       /*CUtoDURRCContainer*/
6560       idx++;
6561       ueSetReq->protocolIEs.list.array[idx]->id = \
6562                                                   ProtocolIE_ID_id_CUtoDURRCInformation;
6563       ueSetReq->protocolIEs.list.array[idx]->criticality        =       Criticality_reject;
6564       ueSetReq->protocolIEs.list.array[idx]->value.present = \
6565                                                              UEContextSetupRequestIEs__value_PR_CUtoDURRCInformation;
6566       if(fillCuToDuContainer(&ueSetReq->protocolIEs.list.array[idx]->value.choice.CUtoDURRCInformation))
6567       {
6568          break;
6569       }
6570
6571       /*Special Cells to be SetupList*/
6572       idx++;
6573       ueSetReq->protocolIEs.list.array[idx]->id = \
6574                                                   ProtocolIE_ID_id_SCell_ToBeSetup_List;
6575       ueSetReq->protocolIEs.list.array[idx]->criticality        =       Criticality_ignore;
6576       ueSetReq->protocolIEs.list.array[idx]->value.present = \
6577                                                              UEContextSetupRequestIEs__value_PR_SCell_ToBeSetup_List;
6578       SplCellListret = BuildSplCellList(&ueSetReq->protocolIEs.list.array[idx]->value.choice.SCell_ToBeSetup_List);
6579       if(SplCellListret != ROK)
6580       {
6581          break;
6582       }
6583       /*SRBs To Be Setup List*/
6584       idx++;
6585       ueSetReq->protocolIEs.list.array[idx]->id = \
6586                                                   ProtocolIE_ID_id_SRBs_ToBeSetup_List;
6587       ueSetReq->protocolIEs.list.array[idx]->criticality        =       Criticality_reject;
6588       ueSetReq->protocolIEs.list.array[idx]->value.present = \
6589                                                              UEContextSetupRequestIEs__value_PR_SRBs_ToBeSetup_List;
6590       SrbSetupret =     BuildSRBSetup(&ueSetReq->protocolIEs.list.array[idx]->value.choice.SRBs_ToBeSetup_List);
6591       if(SrbSetupret != ROK)
6592       {
6593          break;
6594       }
6595       /*DRBs to Be Setup List*/
6596       idx++;
6597       ueSetReq->protocolIEs.list.array[idx]->id = \
6598                                                   ProtocolIE_ID_id_DRBs_ToBeSetup_List;
6599       ueSetReq->protocolIEs.list.array[idx]->criticality        =       Criticality_reject;
6600       ueSetReq->protocolIEs.list.array[idx]->value.present = \
6601                                                              UEContextSetupRequestIEs__value_PR_DRBs_ToBeSetup_List;
6602       ret1 = BuildDRBSetup(&ueSetReq->protocolIEs.list.array[idx]->value.choice.DRBs_ToBeSetup_List);
6603       if(ret1 != ROK)
6604       {
6605          break;
6606       }
6607       /* RRC Container for security mode */
6608       idx++;
6609       ueSetReq->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_RRCContainer;
6610       ueSetReq->protocolIEs.list.array[idx]->criticality = Criticality_reject;
6611       ueSetReq->protocolIEs.list.array[idx]->value.present = \
6612                                                              UEContextSetupRequestIEs__value_PR_RRCContainer;
6613       char secModeBuf[9]={0x00, 0x02, 0x22, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00};
6614       bufLen =9;
6615       ueSetReq->protocolIEs.list.array[idx]->value.choice.RRCContainer.size = bufLen;
6616       CU_ALLOC(ueSetReq->protocolIEs.list.array[idx]->value.choice.RRCContainer.buf,
6617             ueSetReq->protocolIEs.list.array[idx]->value.choice.RRCContainer.size);
6618       if(!ueSetReq->protocolIEs.list.array[idx]->value.choice.RRCContainer.buf)
6619       {
6620          DU_LOG("\nERROR  -->  F1AP : Memory allocation for BuildAndSendUeContextSetupReq failed");
6621          break;
6622       }
6623       memset(ueSetReq->protocolIEs.list.array[idx]->value.choice.RRCContainer.buf, 0, bufLen);
6624       memcpy(ueSetReq->protocolIEs.list.array[idx]->value.choice.RRCContainer.buf, secModeBuf, bufLen);
6625
6626       /* RRC delivery status request */
6627       idx++;
6628       ueSetReq->protocolIEs.list.array[idx]->id = \
6629                                                   ProtocolIE_ID_id_RRCDeliveryStatusRequest;
6630       ueSetReq->protocolIEs.list.array[idx]->criticality = Criticality_ignore;
6631       ueSetReq->protocolIEs.list.array[idx]->value.present = \
6632                                                              UEContextSetupRequestIEs__value_PR_RRCDeliveryStatusRequest;
6633       ueSetReq->protocolIEs.list.array[idx]->value.choice.RRCDeliveryStatusRequest = \
6634                                                                                      RRCDeliveryStatusRequest_true;
6635
6636       /* Bit Rate hardcoded as in reference logs */
6637       idx++;
6638       ueSetReq->protocolIEs.list.array[idx]->id = \
6639                                                   ProtocolIE_ID_id_GNB_DU_UE_AMBR_UL;
6640       ueSetReq->protocolIEs.list.array[idx]->criticality = Criticality_ignore;
6641       ueSetReq->protocolIEs.list.array[idx]->value.present = \
6642                                                              UEContextSetupRequestIEs__value_PR_BitRate;
6643       char bitRateBuf[4]= {0x3B, 0x37, 0xF4, 0xCD};
6644       bufLen = 4;
6645       ueSetReq->protocolIEs.list.array[idx]->value.choice.BitRate.size = bufLen;
6646       CU_ALLOC(ueSetReq->protocolIEs.list.array[idx]->value.choice.BitRate.buf,\
6647             ueSetReq->protocolIEs.list.array[idx]->value.choice.BitRate.size);
6648       if(!ueSetReq->protocolIEs.list.array[idx]->value.choice.BitRate.buf)
6649       {
6650          DU_LOG("\nERROR  -->  F1AP : Failed to allocate memory for Bit Rate in BuildAndSendUeContextSetupReq()");
6651          break;
6652       }
6653       memset(ueSetReq->protocolIEs.list.array[idx]->value.choice.BitRate.buf, 0, bufLen);
6654       memcpy(ueSetReq->protocolIEs.list.array[idx]->value.choice.BitRate.buf, bitRateBuf, bufLen);
6655
6656       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
6657
6658       /* Encode the F1SetupRequest type as APER */
6659       memset(encBuf, 0, ENC_BUF_MAX_LEN);
6660       encBufSize = 0;
6661       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
6662             encBuf);
6663       /* Encode results */
6664       if(encRetVal.encoded == ENCODE_FAIL)
6665       {
6666          DU_LOG( "\nERROR  -->  F1AP : Could not encode UE Context Setup Request structure (at %s)\n",\
6667                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
6668          break;
6669       }
6670       else
6671       {
6672          DU_LOG("\nDEBUG  -->  F1AP : Created APER encodedbuffer for UE Context Setup Request\n");
6673          for(int i=0; i< encBufSize; i++)
6674          {
6675             DU_LOG("%x",encBuf[i]);
6676          }
6677       }
6678
6679       /* Sending  msg  */
6680       if(SendF1APMsg(CU_APP_MEM_REG,CU_POOL)    !=      ROK)
6681       {
6682          DU_LOG("\nERROR  -->  F1AP : Sending UE Context Setup Request Failed");
6683          break;
6684       }
6685       ret = ROK;
6686       break;
6687    }
6688    FreeUeContextSetupReq(f1apMsg);
6689
6690    return ret;
6691 }/* End of BuildAndSendUeContextSetupReq*/
6692
6693 /**********************************************************************
6694  * @brief Function to extractTeId received in UE context setup Response
6695  *
6696  * @details
6697  *
6698  *    Function : extractTeId
6699  *
6700  *    Functionality:
6701  *         - Function to extract TeId
6702  *
6703  * @params[in]
6704  * @return ROK     - success
6705  *         RFAILED - failure
6706  *
6707  **********************************************************************/
6708 uint8_t extractTeId(DLUPTNLInformation_ToBeSetup_List_t *dlTnlInfo)
6709 {
6710    uint8_t arrIdx = 0;
6711    uint32_t teId = 0;
6712    GTPTunnel_t *gtpDl = NULLP;
6713
6714    for(arrIdx =0; arrIdx < dlTnlInfo->list.count; arrIdx++)
6715    {
6716       if(dlTnlInfo->list.array[arrIdx]->dLUPTNLInformation.present == UPTransportLayerInformation_PR_gTPTunnel)
6717       {
6718          if(dlTnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel != NULLP)
6719          {
6720             gtpDl = dlTnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel;
6721             if(gtpDl->gTP_TEID.size > 0)
6722             {
6723                teIdStringToInt(gtpDl->gTP_TEID.buf, &teId);
6724             }
6725             else
6726                DU_LOG("\nERROR  -->  EGTP: No TeId received");
6727             return(teId);
6728          }
6729       }
6730    }
6731    return teId;
6732 }
6733
6734 /****************************************************************
6735  * @brief Function to add Drb tunnels
6736  *
6737  * @details
6738  *
6739  *    Function : addDrbTunnels
6740  *
6741  *    Functionality:
6742  *         - Function to add Drb tunnels
6743  *
6744  * @params[in]
6745  * @return ROK     - success
6746  *         RFAILED - failure
6747  *
6748  * ****************************************************************/
6749 uint8_t addDrbTunnels(uint8_t teId)
6750 {
6751    uint8_t ret = ROK;
6752    EgtpTnlEvt tnlEvt;
6753
6754    if(teId > MAX_TEID || teId < MIN_TEID)
6755    {
6756       DU_LOG("\nERROR  -->  EGTP : TEID(%x) OUT Of Range",teId);
6757    }
6758    memset(&tnlEvt, 0, sizeof(EgtpTnlEvt));
6759    tnlEvt.action = EGTP_TNL_MGMT_ADD;
6760    tnlEvt.lclTeid = teId;
6761    tnlEvt.remTeid = teId;
6762    ret = cuEgtpTnlMgmtReq(tnlEvt);
6763    if(ret != ROK)
6764    {
6765       DU_LOG("\nERROR  -->  EGTP : Tunnel management request failed for teId %x", teId);
6766    }
6767    return ROK;
6768 }
6769
6770 /****************************************************************
6771  * @brief Function to process Drb Setup List
6772  *
6773  * @details
6774  *
6775  *    Function : procDrbSetupList
6776  *
6777  *    Functionality:
6778  *         - Function to process DRB Setup List
6779  *
6780  * @params[in]
6781  * @return ROK     - success
6782  *         RFAILED - failure
6783  *
6784  * ****************************************************************/
6785 uint8_t procDrbSetupList(DRBs_Setup_List_t *drbSetupList)
6786 {
6787    uint8_t arrIdx = 0;
6788    uint32_t teId = 0;
6789    DRBs_Setup_ItemIEs_t *drbItemIe = NULLP;
6790
6791    if(drbSetupList != NULLP)
6792    {
6793       for(arrIdx = 0; arrIdx < drbSetupList->list.count; arrIdx++)
6794       {
6795          drbItemIe = ((DRBs_Setup_ItemIEs_t *)drbSetupList->list.array[arrIdx]);
6796          if(drbItemIe->value.present == DRBs_Setup_ItemIEs__value_PR_DRBs_Setup_Item)
6797          {
6798             /* extracting teId */
6799             teId  = extractTeId(&drbItemIe->value.choice.DRBs_Setup_Item.dLUPTNLInformation_ToBeSetup_List);
6800             if(teId > 0)
6801             {
6802               if(addDrbTunnels(teId)== ROK)
6803               {
6804                 DU_LOG("\nDEBUG  --> EGTP: Tunnel Added for TeId %d", teId);
6805               }
6806             }
6807             else
6808                return RFAILED;
6809          }
6810       }
6811    }
6812    return ROK;
6813 }
6814
6815 /****************************************************************
6816  * @brief Function to process Ue Context Setup Response
6817  *
6818  * @details
6819  *
6820  *    Function : procUeContextSetupResponse
6821  *
6822  *    Functionality:
6823  *         - Function to process Ue Context Setup Response
6824  *
6825  * @params[in]
6826  * @return ROK     - success
6827  *         RFAILED - failure
6828  *
6829  * ****************************************************************/
6830 uint8_t procUeContextSetupResponse(F1AP_PDU_t *f1apMsg)
6831 {
6832    uint8_t idx, duUeF1apId;
6833    UEContextSetupResponse_t *ueCtxtSetupRsp = NULLP;
6834    ueCtxtSetupRsp = &f1apMsg->choice.successfulOutcome->value.choice.UEContextSetupResponse;
6835
6836    for(idx=0; idx < ueCtxtSetupRsp->protocolIEs.list.count; idx++)
6837    {
6838       switch(ueCtxtSetupRsp->protocolIEs.list.array[idx]->id)
6839       {
6840           case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
6841              {
6842                 duUeF1apId = ueCtxtSetupRsp->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID;
6843                 break;
6844              }
6845           case ProtocolIE_ID_id_DRBs_Setup_List:
6846              {
6847                 /* Adding Tunnels for successful DRB */
6848                 procDrbSetupList(&ueCtxtSetupRsp->protocolIEs.list.array[idx]->value.choice.DRBs_Setup_List);
6849                 break;
6850
6851              }
6852       }
6853    }
6854    ueCb[duUeF1apId-1].f1apMsgDb.dlRrcMsgCount++; /* keeping DL RRC Msg Count */
6855    return ROK;
6856 }
6857
6858 /****************************************************************
6859  * @brief Function to process Ul Rrc Msg received from DU
6860  *
6861  * @details
6862  *
6863  *    Function : procUlRrcMsg
6864  *
6865  *    Functionality:
6866  *         - Function to process Ul Rrc Msg received from DU
6867  *
6868  * @params[in]
6869  * @return ROK     - success
6870  *         RFAILED - failure
6871  *
6872  * ****************************************************************/
6873
6874 uint8_t procUlRrcMsg(F1AP_PDU_t *f1apMsg)
6875 {
6876    uint8_t idx, ret, srbId, rrcMsgType;
6877    uint8_t cuUeF1apId, duUeF1apId;
6878    uint8_t *rrcContainer = NULLP;
6879    uint16_t rrcContLen;
6880    ULRRCMessageTransfer_t *ulRrcMsg = NULLP;
6881
6882    ret = ROK;
6883    ulRrcMsg = &f1apMsg->choice.initiatingMessage->value.choice.ULRRCMessageTransfer;
6884
6885    for(idx=0; idx < ulRrcMsg->protocolIEs.list.count; idx++)
6886    {
6887       switch(ulRrcMsg->protocolIEs.list.array[idx]->id)
6888       {
6889          case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
6890             {
6891                cuUeF1apId = ulRrcMsg->protocolIEs.list.array[idx]->value.choice.GNB_CU_UE_F1AP_ID;
6892                break;
6893             }
6894          case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
6895             {
6896                duUeF1apId = ulRrcMsg->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID;
6897                break;
6898             }
6899          case ProtocolIE_ID_id_SRBID:
6900             srbId = ulRrcMsg->protocolIEs.list.array[idx]->value.choice.SRBID;
6901             break;
6902          case ProtocolIE_ID_id_RRCContainer:
6903             {
6904                rrcContLen = ulRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.size;
6905                CU_ALLOC(rrcContainer, rrcContLen)
6906                   if(!rrcContainer)
6907                   {
6908                      DU_LOG("\nERROR  -->  F1AP : Failed to allocated memory in procUlRrcMsg");
6909                      return RFAILED;
6910                   }
6911                memcpy(rrcContainer, ulRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.buf,\
6912                      rrcContLen);
6913                break;
6914             }
6915
6916          default:
6917             DU_LOG("\nERROR  -->  F1AP : Invalid Event %ld", ulRrcMsg->protocolIEs.list.array[idx]->id);
6918             break;
6919       }
6920    }
6921    if(srbId == 1)
6922    {
6923       ueCb[duUeF1apId-1].f1apMsgDb.dlRrcMsgCount++;
6924       rrcMsgType = setDlRRCMsgType(duUeF1apId);
6925       if(rrcMsgType == REGISTRATION_ACCEPT)
6926       {
6927          DU_LOG("\nINFO  -->  F1AP: Sending DL RRC MSG for RRC Registration Accept");
6928          ret = BuildAndSendDLRRCMessageTransfer(duUeF1apId, srbId, rrcMsgType);
6929       }
6930       if(rrcMsgType == UE_CONTEXT_SETUP_REQ)
6931       {
6932          DU_LOG("\nINFO  -->  F1AP: Sending Ue Context Setup Req");
6933          ret = BuildAndSendUeContextSetupReq(cuUeF1apId, duUeF1apId,\
6934                rrcContLen, rrcContainer);
6935       }
6936       if(rrcMsgType == SECURITY_MODE_COMPLETE)
6937       {
6938          /* To trigger the DL RRC Msg for RRC Reconfig */
6939          ueCb[duUeF1apId-1].f1apMsgDb.dlRrcMsgCount++;
6940          rrcMsgType = setDlRRCMsgType(duUeF1apId);
6941          if(rrcMsgType == RRC_RECONFIG)
6942          {
6943             DU_LOG("\nINFO  -->  F1AP: Sending DL RRC MSG for RRC Reconfig");
6944             BuildAndSendDLRRCMessageTransfer(duUeF1apId, srbId, rrcMsgType);
6945          }
6946       }
6947       if(rrcMsgType == UE_CONTEXT_MOD_REQ)
6948       {
6949          DU_LOG("\nINFO  -->  F1AP: Sending UE Context Modification Request");
6950          BuildAndSendUeContextModificationReq(duUeF1apId);
6951       }
6952    }
6953    return ret;
6954 }
6955
6956 /****************************************************************
6957  * @brief Build And Send F1ResetAck
6958  *
6959  * @details
6960  *
6961  *    Function : FreeF1ResetAck
6962  *
6963  *    Functionality:
6964  *         - Build And Send  F1ResetRSP
6965  *
6966  *  @params[in]
6967  * @return ROK     - success
6968  *         RFAILED - failure
6969  *
6970  * ****************************************************************/
6971 void FreeF1ResetAck(F1AP_PDU_t *f1apMsg)
6972 {
6973    uint8_t idx;
6974    ResetAcknowledge_t *f1ResetAck;
6975
6976    if(f1apMsg)
6977    {
6978       if(f1apMsg->choice.successfulOutcome)
6979       {
6980          f1ResetAck= &f1apMsg->choice.successfulOutcome->value.choice.ResetAcknowledge;
6981
6982          if(f1ResetAck->protocolIEs.list.array)
6983          {
6984             for(idx=0; idx<f1ResetAck->protocolIEs.list.count ; idx++)
6985             {
6986                if(f1ResetAck->protocolIEs.list.array[idx])
6987                {
6988                   CU_FREE(f1ResetAck->protocolIEs.list.array[idx], sizeof(ResetAcknowledgeIEs_t));
6989                }
6990             }
6991             CU_FREE(f1ResetAck->protocolIEs.list.array, f1ResetAck->protocolIEs.list.size );
6992          }
6993          CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
6994       }
6995       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
6996    }
6997 }
6998
6999 /****************************************************************
7000  * @brief Build And Send F1ResetAck
7001  *
7002  * @details
7003  *
7004  *    Function : BuildAndSendF1ResetAck
7005  *
7006  *    Functionality:
7007  *         - Build And Send  F1ResetRSP
7008  *
7009  *  @params[in]
7010  * @return ROK     - success
7011  *         RFAILED - failure
7012  *
7013  * ****************************************************************/
7014
7015 uint8_t BuildAndSendF1ResetAck()
7016 {
7017    uint8_t                idx = 0;
7018    uint8_t                elementCnt = 0;
7019    uint8_t                ret = RFAILED;
7020    F1AP_PDU_t             *f1apMsg = NULL;
7021    ResetAcknowledge_t     *f1ResetAck = NULLP;
7022    asn_enc_rval_t         encRetVal;
7023    DU_LOG("\nINFO  -->  F1AP : Building F1 Reset Acknowledgment \n");
7024
7025    do{
7026       /* Allocate the memory for F1ResetRequest_t */
7027       CU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
7028       if(f1apMsg == NULLP)
7029       {
7030          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
7031          break;
7032       }
7033
7034       f1apMsg->present =  F1AP_PDU_PR_successfulOutcome;
7035
7036       CU_ALLOC(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
7037       if(f1apMsg->choice.successfulOutcome == NULLP)
7038       {
7039          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
7040          break;
7041       }
7042
7043       f1apMsg->choice.successfulOutcome->procedureCode = ProcedureCode_id_Reset;
7044       f1apMsg->choice.successfulOutcome->criticality   = Criticality_reject;
7045       f1apMsg->choice.successfulOutcome->value.present = SuccessfulOutcome__value_PR_ResetAcknowledge;
7046       f1ResetAck = &f1apMsg->choice.successfulOutcome->value.choice.ResetAcknowledge;
7047
7048       elementCnt = 1;
7049
7050       f1ResetAck->protocolIEs.list.count = elementCnt;
7051       f1ResetAck->protocolIEs.list.size = elementCnt*sizeof(ResetAcknowledgeIEs_t *);
7052
7053       CU_ALLOC(f1ResetAck->protocolIEs.list.array, f1ResetAck->protocolIEs.list.size );
7054       if(f1ResetAck->protocolIEs.list.array == NULLP)
7055       {
7056          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1ResetAckIEs failed");
7057          break;
7058       }
7059
7060       for(idx=0; idx<elementCnt; idx++)
7061       {
7062          CU_ALLOC(f1ResetAck->protocolIEs.list.array[idx], sizeof(ResetAcknowledgeIEs_t));
7063          if(f1ResetAck->protocolIEs.list.array[idx] == NULLP)
7064          {
7065             break;
7066          }
7067       }
7068       /*TransactionID*/
7069       idx = 0;
7070       f1ResetAck->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_TransactionID;
7071       f1ResetAck->protocolIEs.list.array[idx]->criticality = Criticality_reject;
7072       f1ResetAck->protocolIEs.list.array[idx]->value.present = ResetAcknowledgeIEs__value_PR_TransactionID;
7073       f1ResetAck->protocolIEs.list.array[idx]->value.choice.TransactionID = TRANS_ID;
7074
7075       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
7076
7077       /* Encode the F1SetupRequest type as UPER */
7078       memset(encBuf, 0, ENC_BUF_MAX_LEN);
7079       encBufSize = 0;
7080       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
7081
7082       /* Check encode results */
7083       if(encRetVal.encoded == ENCODE_FAIL)
7084       {
7085          DU_LOG("\nERROR  -->  F1AP : Could not encode F1ResetAck structure (at %s)\n",\
7086                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
7087          break;
7088       }
7089       else
7090       {
7091          DU_LOG("\nDEBUG  -->  F1AP : Created APER encodedbuffer for F1ResetAck \n");
7092          for(int i=0; i< encBufSize; i++)
7093          {
7094             DU_LOG("%x",encBuf[i]);
7095          }
7096       }
7097       /* Sending msg */
7098       if(SendF1APMsg(CU_APP_MEM_REG, CU_POOL) != ROK)
7099       {
7100          DU_LOG("\nERROR  -->  F1AP : Sending F1 Reset Response failed");
7101          break;
7102       }
7103
7104       ret = ROK;
7105       break;
7106    }while(true);
7107
7108    FreeF1ResetAck(f1apMsg);
7109    return ret;
7110 }
7111 void FreeUlTnlInfoforDrb2(ULUPTNLInformation_ToBeSetup_List_t *ulInfo)
7112 {
7113    uint8_t arrIdx =0;
7114
7115    if(ulInfo->list.array)
7116    {
7117       for(arrIdx=0; arrIdx<ulInfo->list.count ; arrIdx++)
7118       {
7119          if(ulInfo->list.array[arrIdx])
7120          {
7121             if(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel )
7122             {
7123                if(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf)
7124                {
7125                   if(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf)
7126                   {
7127                      CU_FREE(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
7128                      gTP_TEID.buf,ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.\
7129                      gTPTunnel->gTP_TEID.size);
7130                   }
7131                   CU_FREE(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
7132                   transportLayerAddress.buf,ulInfo->list.array[arrIdx]->\
7133                   uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.size);
7134                }
7135                CU_FREE(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel,\
7136                sizeof(GTPTunnel_t));
7137             }
7138             CU_FREE(ulInfo->list.array[arrIdx],sizeof(ULUPTNLInformation_ToBeSetup_Item_t));
7139          }
7140       }
7141       CU_FREE(ulInfo->list.array,ulInfo->list.size);
7142    }
7143 }
7144
7145 /*******************************************************************
7146 *
7147 * @brief Deletes the EGTP tunnel
7148 *
7149 * @details
7150 *
7151 *    Function : deleteEgtpTunnel
7152 *
7153 *    Functionality: Deletes the EGTP tunnel
7154 *
7155 * @params[in] uint8_t *buf
7156 *
7157 * @return ROK     - success
7158 *         RFAILED - failure
7159 *
7160 * ****************************************************************/
7161 uint8_t deleteEgtpTunnel(uint8_t *buf)
7162 {
7163    uint32_t teId = 0;
7164    EgtpTnlEvt tnlEvt;
7165
7166    teIdStringToInt(buf, &teId);
7167    if(teId > MAX_TEID || teId < MIN_TEID)
7168    {
7169       DU_LOG("\nERROR  -->  EGTP : TEID(%d) OUT Of Range", teId);
7170       return RFAILED;
7171    }
7172    memset(&tnlEvt, 0, sizeof(EgtpTnlEvt));
7173    tnlEvt.action = EGTP_TNL_MGMT_DEL;
7174    tnlEvt.lclTeid = teId;
7175    tnlEvt.remTeid = teId;
7176    if((cuEgtpTnlMgmtReq(tnlEvt)) != ROK)
7177    {
7178       DU_LOG("\nERROR  -->  EGTP : Failed to delete tunnel Id %d", teId);
7179    }
7180    return ROK;
7181 }
7182
7183 /*******************************************************************
7184 *
7185 * @brief Builds the Uplink Tunnel Info
7186 *
7187 * @details
7188 *
7189 *    Function : BuildUlTnlInfoforSetupMod
7190 *
7191 *    Functionality: Constructs the UL TnlInfo For DRB list
7192 *
7193 * @params[in] ULUPTNLInformation_ToBeSetup_List_t *ulInfo
7194 *
7195 * @return ROK     - success
7196 *         RFAILED - failure
7197 *
7198 * ****************************************************************/
7199 uint8_t BuildUlTnlInfoforSetupMod(uint8_t ueId, ULUPTNLInformation_ToBeSetup_List_t *ulInfo, uint8_t actionType)
7200 {
7201    uint8_t arrIdx;
7202    uint8_t ulCnt;
7203
7204    ulCnt = 1;
7205    ulInfo->list.count = ulCnt;
7206    ulInfo->list.size = ulCnt * sizeof(ULUPTNLInformation_ToBeSetup_Item_t *);
7207    CU_ALLOC(ulInfo->list.array,ulInfo->list.size);
7208    if(ulInfo->list.array == NULLP)
7209    {
7210       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildUlTnlInfoforSetupMod");
7211       return RFAILED;
7212    }
7213    for(arrIdx=0; arrIdx<ulCnt; arrIdx++)
7214    {
7215       CU_ALLOC(ulInfo->list.array[arrIdx],sizeof(ULUPTNLInformation_ToBeSetup_Item_t));
7216       if(ulInfo->list.array[arrIdx] == NULLP)
7217       {
7218          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildUlTnlInfoforSetupMod");
7219          return RFAILED;
7220       }
7221    }
7222
7223    arrIdx = 0;
7224    ulInfo->list.array[arrIdx]->uLUPTNLInformation.present = \
7225    UPTransportLayerInformation_PR_gTPTunnel;
7226
7227    /*GTP TUNNEL*/
7228    CU_ALLOC(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel,\
7229          sizeof(GTPTunnel_t));
7230    if(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel == NULLP)
7231    {
7232       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildUlTnlInfoforSetupMod");
7233       return RFAILED;
7234    }
7235    ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
7236       transportLayerAddress.size        = 4*sizeof(uint8_t);
7237    CU_ALLOC(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
7238          transportLayerAddress.buf,ulInfo->list.array[arrIdx]->\
7239          uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.size);
7240    if(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
7241          transportLayerAddress.buf == NULLP)
7242    {
7243       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildUlTnlInfoforSetupMod");
7244       return RFAILED;
7245    }
7246
7247    ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
7248       transportLayerAddress.buf[0] = 192;
7249    ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
7250       transportLayerAddress.buf[1] = 168;
7251    ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
7252       transportLayerAddress.buf[2] = 130;
7253    ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
7254       transportLayerAddress.buf[3] = 82;
7255    ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
7256       transportLayerAddress.bits_unused = 0;
7257
7258    /*GTP TEID*/
7259    ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.size\
7260       = 4 * sizeof(uint8_t);
7261    CU_ALLOC(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
7262          gTP_TEID.buf,ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.\
7263          gTPTunnel->gTP_TEID.size);
7264    if(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf\
7265          == NULLP)
7266    {
7267       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildUlTnlInfoforSetupMod");
7268       return RFAILED;
7269    }
7270    ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
7271       gTP_TEID.buf[0] = 0;
7272    ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
7273       gTP_TEID.buf[1] = 0;
7274    ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
7275       gTP_TEID.buf[2] = 0;
7276    if(actionType == ProtocolIE_ID_id_DRBs_ToBeModified_Item)
7277    {
7278      /*TODO: DRB context to be stored in CU STUB so that tunnel Id can be easily
7279       * fetched based on the Drb Id */
7280      if(ueId == 1)
7281      {
7282         /* Tunnel Id for DRB 2 of UE 1 is 2. Hence passing the same TeId */
7283         ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[3] = 2;
7284      }
7285      else if(ueId == 2)
7286      {
7287         /* Tunnel Id for DRB 2 of UE 2 is 5. Hence passing the same TeId */
7288         ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[3] = 5;
7289      }
7290      else if(ueId == 3)
7291      {
7292         /* Tunnel Id for DRB 2 of UE 3 is 8. Hence passing the same TeId */
7293         ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[3] = 8;
7294      }
7295
7296    }
7297    else
7298    {
7299       ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
7300         gTP_TEID.buf[3] = cuCfgParams.egtpParams.currTunnelId++;
7301    }
7302    return ROK;
7303 }/*End of BuildULTnlInfo*/
7304
7305 /*******************************************************************
7306 *
7307 * @brief freeing the DRB item
7308 *
7309 * @details
7310 *
7311 *    Function : FreeDrbItem
7312 *
7313 *    Functionality: freeing the DRB item
7314 *
7315 * @params[in] DRBs_ToBeSetupMod_Item_t *drbItem
7316 *
7317 * @return ROK     - success
7318 *         RFAILED - failure
7319 *
7320 * ****************************************************************/
7321
7322 void FreeDrbItem(DRBs_ToBeSetupMod_Item_t *drbItem)
7323 {
7324    uint8_t arrIdx =0;
7325    SNSSAI_t *snssai =NULLP;
7326    Flows_Mapped_To_DRB_List_t *flowMap = NULLP;
7327
7328    drbItem->qoSInformation.present = QoSInformation_PR_choice_extension;
7329    switch(drbItem->qoSInformation.present)
7330    {
7331       case QoSInformation_PR_NOTHING:
7332          break;
7333       case QoSInformation_PR_eUTRANQoS:
7334          {
7335             if(drbItem->qoSInformation.choice.eUTRANQoS)
7336             {
7337                CU_FREE(drbItem->qoSInformation.choice.eUTRANQoS, sizeof(EUTRANQoS_t));
7338             }
7339             break;
7340          }
7341       case QoSInformation_PR_choice_extension:
7342          {
7343             if(drbItem->qoSInformation.choice.choice_extension)
7344             {
7345                FreeQOSInfo(&drbItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS);
7346
7347                snssai = &drbItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI;
7348                if(snssai->sST.buf)
7349                {
7350                   CU_FREE(snssai->sST.buf,snssai->sST.size);
7351                }
7352                if(snssai->sD)
7353                {
7354                   if(snssai->sD->buf)
7355                   {
7356                      CU_FREE(snssai->sD->buf,snssai->sD->size);
7357                   }
7358                   CU_FREE(snssai->sD,sizeof(OCTET_STRING_t));
7359                }
7360
7361                flowMap = &drbItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.flows_Mapped_To_DRB_List;
7362                if(flowMap->list.array)
7363                {
7364                   for(arrIdx=0; arrIdx<flowMap->list.count; arrIdx++)
7365                   {
7366                      if(flowMap->list.array[arrIdx] )
7367                      {
7368                         FreeQOSInfo(&flowMap->list.array[arrIdx]->qoSFlowLevelQoSParameters);
7369                         CU_FREE(flowMap->list.array[arrIdx],sizeof(Flows_Mapped_To_DRB_Item_t));
7370                      }
7371                   }
7372                   CU_FREE(flowMap->list.array,flowMap->list.size);
7373                }
7374
7375                CU_FREE(drbItem->qoSInformation.choice.choice_extension,sizeof(QoSInformation_ExtIEs_t));
7376             }
7377             break;
7378          }
7379
7380    }
7381    FreeUlTnlInfoforDrb2(&drbItem->uLUPTNLInformation_ToBeSetup_List);
7382    if(drbItem->uLConfiguration)
7383    {
7384       CU_FREE(drbItem->uLConfiguration,sizeof(ULConfiguration_t));
7385    }
7386 }
7387
7388 /*******************************************************************
7389 *
7390 * @brief filling the DRB setup Mod item
7391 *
7392 * @details
7393 *
7394 *    Function : FillDrbItemToSetupMod
7395 *
7396 *    Functionality: filling the DRB setup Mod item
7397 *
7398 *
7399 * @params[in] DRBs_ToBeSetupMod_Item_t *drbItem
7400 *
7401 * @return ROK     - success
7402 *         RFAILED - failure
7403 *
7404 * ****************************************************************/
7405
7406 uint8_t FillDrbItemToSetupMod(uint8_t ueId, uint8_t arrIdx, DRBs_ToBeSetupMod_Item_t *drbItem)
7407 {
7408    uint8_t ret = ROK;
7409
7410    /*Drb Id */
7411    drbItem->dRBID = arrIdx + DRB3;
7412
7413    /*qoSInformation*/
7414    drbItem->qoSInformation.present = QoSInformation_PR_choice_extension;
7415
7416    switch(drbItem->qoSInformation.present)
7417    {
7418       case QoSInformation_PR_NOTHING:
7419       {
7420          break;
7421       }
7422       case QoSInformation_PR_eUTRANQoS:
7423       {
7424
7425          CU_ALLOC(drbItem->qoSInformation.choice.eUTRANQoS, sizeof(EUTRANQoS_t));
7426          if(drbItem->qoSInformation.choice.eUTRANQoS)
7427          {
7428             DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in FillDrbItemToSetupMod");
7429             return RFAILED;
7430          }
7431          drbItem->qoSInformation.choice.eUTRANQoS->qCI = QCI;
7432          drbItem->qoSInformation.choice.eUTRANQoS->allocationAndRetentionPriority.priorityLevel =
7433             PriorityLevel_no_priority;
7434
7435          drbItem->qoSInformation.choice.eUTRANQoS->allocationAndRetentionPriority.pre_emptionCapability =
7436             Pre_emptionCapability_may_trigger_pre_emption;
7437
7438          drbItem->qoSInformation.choice.eUTRANQoS->allocationAndRetentionPriority.pre_emptionVulnerability =
7439             Pre_emptionVulnerability_pre_emptable;
7440
7441          break;
7442       }
7443       case QoSInformation_PR_choice_extension:
7444       {
7445          CU_ALLOC(drbItem->qoSInformation.choice.choice_extension,sizeof(QoSInformation_ExtIEs_t));
7446          if(drbItem->qoSInformation.choice.choice_extension == NULLP)
7447          {
7448             DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in FillDrbItemToSetupMod");
7449             return RFAILED;
7450          }
7451
7452          drbItem->qoSInformation.choice.choice_extension->id = ProtocolIE_ID_id_DRB_Information;
7453          drbItem->qoSInformation.choice.choice_extension->criticality = Criticality_ignore;
7454          drbItem->qoSInformation.choice.choice_extension->value.present = QoSInformation_ExtIEs__value_PR_DRB_Information;
7455          ret =  BuildQOSInfo(&drbItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS,\
7456            ProtocolIE_ID_id_DRBs_ToBeSetupMod_Item, PDU_SESSION_ID_2);
7457          if(ret != ROK)
7458          {
7459             DU_LOG("\nERROR  -->  F1AP : BuildQOSInfo failed");
7460             return RFAILED;
7461          }
7462
7463          /*SNSSAI*/
7464          ret = BuildSNSSAI(&drbItem->qoSInformation.choice.\
7465                choice_extension->value.choice.DRB_Information.sNSSAI, cuCfgParams.snssaiList[1]);
7466          if(ret != ROK)
7467          {
7468             DU_LOG("\nERROR  -->  F1AP : BuildSNSSAI failed");
7469             return RFAILED;
7470          }
7471
7472          /*Flows mapped to DRB List*/
7473          ret = BuildFlowsMap(&drbItem->qoSInformation.choice.\
7474                choice_extension->value.choice.DRB_Information.flows_Mapped_To_DRB_List,\
7475           ProtocolIE_ID_id_DRBs_ToBeSetupMod_Item);
7476          if(ret != ROK)
7477          {
7478             DU_LOG("\nERROR  -->  F1AP : BuildFlowsMap failed");
7479             return RFAILED;
7480          }
7481       }
7482    }
7483
7484    /*ULUPTNLInformation To Be Setup List*/
7485    ret = BuildUlTnlInfoforSetupMod(ueId, &drbItem->uLUPTNLInformation_ToBeSetup_List, \
7486       ProtocolIE_ID_id_DRBs_ToBeSetupMod_Item);
7487    if(ret != ROK)
7488    {
7489       DU_LOG("\nERROR  -->  F1AP : BuildUlTnlInfoforSetupMod failed");
7490       return RFAILED;
7491    }
7492
7493    /*RLCMode*/
7494    drbItem->rLCMode = RLCMode_rlc_um_bidirectional;
7495    return ROK;
7496 }
7497
7498 /*******************************************************************
7499 *
7500 * @brief Builds the DRB to be Setup Mod ItemIes
7501 *
7502 * @details
7503 *
7504 *    Function : FillDrbItemList
7505 *
7506 *    Functionality: Constructs the DRB to be Setup Mod Item Ies
7507 *
7508 * @params[in] struct DRBs_ToBeSetupMod_ItemIEs *drbItemIe
7509 *
7510 * @return ROK     - success
7511 *         RFAILED - failure
7512 *
7513 * ****************************************************************/
7514
7515 uint8_t FillDrbItemList(uint8_t ueId, uint8_t arrIdx, struct DRBs_ToBeSetupMod_ItemIEs *drbItemIe)
7516 {
7517    drbItemIe->id = ProtocolIE_ID_id_DRBs_ToBeSetupMod_Item;
7518    drbItemIe->criticality = Criticality_reject;
7519    drbItemIe->value.present = DRBs_ToBeSetupMod_ItemIEs__value_PR_DRBs_ToBeSetupMod_Item;
7520
7521    if(FillDrbItemToSetupMod(ueId, arrIdx, (&(drbItemIe->value.choice.DRBs_ToBeSetupMod_Item))) != ROK)
7522    {
7523       DU_LOG("\nERROR  -->  F1AP : FillDrbItemToSetupMod failed");
7524       return RFAILED;
7525    }
7526    return ROK;
7527 }
7528 /*******************************************************************
7529 *
7530 * @brief free the DRB to be Setup Mod list
7531 *
7532 * @details
7533 *
7534 *    Function : FreeDrbToBeSetupModList
7535 *
7536 *    Functionality: free the DRB to be Setup Mod list
7537 *
7538 * @params[in] DRBs_ToBeSetupMod_List_t *drbSet
7539 *
7540 * @return ROK     - success
7541 *         RFAILED - failure
7542 *
7543 * ****************************************************************/
7544 void FreeDrbToBeSetupModList(DRBs_ToBeSetupMod_List_t *drbSet)
7545 {
7546    uint8_t arrIdx =0;
7547    struct DRBs_ToBeSetupMod_ItemIEs *drbItemIe;
7548
7549    if(drbSet->list.array)
7550    {
7551       for(arrIdx=0; arrIdx<drbSet->list.count ; arrIdx++)
7552       {
7553          if(drbSet->list.array[arrIdx] != NULLP)
7554          {
7555             if(arrIdx == 0)
7556             {
7557                drbItemIe = (DRBs_ToBeSetupMod_ItemIEs_t *)drbSet->list.array[arrIdx];
7558                FreeDrbItem(&(drbItemIe->value.choice.DRBs_ToBeSetupMod_Item));
7559             }
7560             CU_FREE(drbSet->list.array[arrIdx], sizeof(DRBs_ToBeSetupMod_ItemIEs_t));
7561          }
7562       }
7563       CU_FREE(drbSet->list.array, drbSet->list.size);
7564    }
7565
7566 }
7567
7568 /*******************************************************************
7569 *
7570 * @brief Builds the DRB to be Setup Mod list
7571 *
7572 * @details
7573 *
7574 *    Function : BuildDrbToBeSetupList
7575 *
7576 *    Functionality: Constructs the DRB to be Setup Mod list
7577 *
7578 * @params[in] DRBs_ToBeSetupMod_List_t *drbSet
7579 *
7580 * @return ROK     - success
7581 *         RFAILED - failure
7582 *
7583 * ****************************************************************/
7584
7585 uint8_t BuildDrbToBeSetupList(uint8_t ueId, DRBs_ToBeSetupMod_List_t *drbSet)
7586 {
7587    uint8_t ret = ROK;
7588    uint8_t arrIdx =0;
7589    uint8_t drbCnt =0;
7590
7591    drbCnt = MAX_DRB_SET_UE_CONTEXT_MOD_REQ;
7592    drbSet->list.count = drbCnt;
7593    drbSet->list.size = drbCnt * sizeof(DRBs_ToBeSetupMod_ItemIEs_t *);
7594    CU_ALLOC(drbSet->list.array, drbSet->list.size);
7595    if(drbSet->list.array == NULLP)
7596    {
7597       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDrbToBeSetupList");
7598       return  RFAILED;
7599    }
7600
7601    for(arrIdx=0; arrIdx<drbCnt; arrIdx++)
7602    {
7603       CU_ALLOC(drbSet->list.array[arrIdx], sizeof(DRBs_ToBeSetupMod_ItemIEs_t));
7604       if(drbSet->list.array[arrIdx] == NULLP)
7605       {
7606          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDrbToBeSetupList for array idx [%d]", arrIdx);
7607          return  RFAILED;
7608       }
7609    }
7610
7611    arrIdx = 0;
7612    ret = FillDrbItemList(ueId, arrIdx, (DRBs_ToBeSetupMod_ItemIEs_t *)drbSet->list.array[arrIdx]);
7613    if(ret != ROK)
7614    {
7615       DU_LOG("\nERROR  -->  F1AP : FillDrbItemList failed");
7616    }
7617
7618    return ret;
7619 }
7620
7621 /*******************************************************************
7622 *
7623 * @brief Filling the DRB to be modified item
7624 *
7625 * @details
7626 *
7627 *    Function : FillDrbToBeModItem
7628 *
7629 *    Functionality: filling the DRB to be modified item
7630 *
7631 * @params[in] DRBs_ToBeModified_Item_t *drbItem
7632 *
7633 * @return ROK     - success
7634 *         RFAILED - failure
7635 *
7636 * ****************************************************************/
7637
7638 uint8_t FillDrbToBeModItem(uint8_t ueId, DRBs_ToBeModified_Item_t *drbItem)
7639 {
7640    uint8_t ret = ROK;
7641
7642    /*Drb Id */
7643    drbItem->dRBID = DRB2;
7644
7645    /*qoSInformation*/
7646    drbItem->qoSInformation = NULLP;
7647    CU_ALLOC(drbItem->qoSInformation, sizeof(QoSInformation_t));
7648    if(drbItem->qoSInformation != NULLP)
7649    {
7650       drbItem->qoSInformation->present = QoSInformation_PR_choice_extension;
7651
7652       switch(drbItem->qoSInformation->present)
7653       {
7654          case QoSInformation_PR_NOTHING:
7655             {
7656                break;
7657             }
7658          case QoSInformation_PR_eUTRANQoS:
7659             {
7660
7661                CU_ALLOC(drbItem->qoSInformation->choice.eUTRANQoS, sizeof(EUTRANQoS_t));
7662                if(drbItem->qoSInformation->choice.eUTRANQoS)
7663                {
7664                   DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in FillDrbToBeModItem");
7665                   return RFAILED;
7666                }
7667                drbItem->qoSInformation->choice.eUTRANQoS->qCI = QCI;
7668                drbItem->qoSInformation->choice.eUTRANQoS->allocationAndRetentionPriority.priorityLevel =
7669                   PriorityLevel_no_priority;
7670
7671                drbItem->qoSInformation->choice.eUTRANQoS->allocationAndRetentionPriority.pre_emptionCapability =
7672                   Pre_emptionCapability_may_trigger_pre_emption;
7673
7674                drbItem->qoSInformation->choice.eUTRANQoS->allocationAndRetentionPriority.pre_emptionVulnerability =
7675                   Pre_emptionVulnerability_pre_emptable;
7676
7677                break;
7678             }
7679          case QoSInformation_PR_choice_extension:
7680             {
7681                CU_ALLOC(drbItem->qoSInformation->choice.choice_extension,sizeof(QoSInformation_ExtIEs_t));
7682                if(drbItem->qoSInformation->choice.choice_extension == NULLP)
7683                {
7684                   DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in FillDrbItemToSetupMod");
7685                   return RFAILED;
7686                }
7687
7688                drbItem->qoSInformation->choice.choice_extension->id = ProtocolIE_ID_id_DRB_Information;
7689                drbItem->qoSInformation->choice.choice_extension->criticality = Criticality_ignore;
7690                drbItem->qoSInformation->choice.choice_extension->value.present = QoSInformation_ExtIEs__value_PR_DRB_Information;
7691                ret =  BuildQOSInfo(&drbItem->qoSInformation->choice.choice_extension->value.choice.DRB_Information.dRB_QoS,\
7692                      ProtocolIE_ID_id_DRBs_ToBeModified_Item, INVALID_PDU_SESSION_ID);
7693                if(ret != ROK)
7694                {
7695                   DU_LOG("\nERROR  -->  F1AP : BuildQOSInfo failed");
7696                   return RFAILED;
7697                }
7698
7699                /*SNSSAI*/
7700                ret = BuildSNSSAI(&drbItem->qoSInformation->choice.\
7701                      choice_extension->value.choice.DRB_Information.sNSSAI,cuCfgParams.snssaiList[0]);
7702                if(ret != ROK)
7703                {
7704                   DU_LOG("\nERROR  -->  F1AP : BuildSNSSAI failed");
7705                   return RFAILED;
7706                }
7707
7708                /*Flows mapped to DRB List*/
7709                ret = BuildFlowsMap(&drbItem->qoSInformation->choice.\
7710                      choice_extension->value.choice.DRB_Information.flows_Mapped_To_DRB_List,\
7711                      ProtocolIE_ID_id_DRBs_ToBeModified_Item);
7712                if(ret != ROK)
7713                {
7714                   DU_LOG("\nERROR  -->  F1AP : BuildFlowsMap failed");
7715                   return RFAILED;
7716                }
7717             }
7718       }
7719    }/* End of QoS */
7720
7721    /*ULUPTNLInformation To Be Setup List*/
7722    ret = BuildUlTnlInfoforSetupMod(ueId, &drbItem->uLUPTNLInformation_ToBeSetup_List,\
7723             ProtocolIE_ID_id_DRBs_ToBeModified_Item);
7724    if(ret != ROK)
7725    {
7726       DU_LOG("\nERROR  -->  F1AP : BuildUlTnlInfoforSetupMod failed");
7727       return RFAILED;
7728    }
7729    return ROK;
7730 }
7731
7732 /*******************************************************************
7733 *
7734 * @brief Builds the DRB to be modified Item IE
7735 *
7736 * @details
7737 *
7738 *    Function : FillDrbToBeModItemList
7739 *
7740 *    Functionality: Constructs the DRB to be modified Mod Item Ies
7741 *
7742 * @params[in] struct DRBs_ToBeModified_ItemIEs *drbItemIe
7743 *
7744 * @return ROK     - success
7745 *         RFAILED - failure
7746 *
7747 * ****************************************************************/
7748
7749 uint8_t FillDrbToBeModItemList(uint8_t ueId, struct DRBs_ToBeModified_ItemIEs *drbItemIe)
7750 {
7751    drbItemIe->id = ProtocolIE_ID_id_DRBs_ToBeModified_Item;
7752    drbItemIe->criticality = Criticality_reject;
7753    drbItemIe->value.present = DRBs_ToBeModified_ItemIEs__value_PR_DRBs_ToBeModified_Item;
7754    if(FillDrbToBeModItem(ueId, &(drbItemIe->value.choice.DRBs_ToBeModified_Item)) != ROK)
7755    {
7756       DU_LOG("\nERROR  -->  F1AP : FillDrbToBeModItem failed");
7757       return RFAILED;
7758    }
7759
7760    return ROK;
7761 }
7762
7763 /*******************************************************************
7764 *
7765 * @brief Builds the DRB to be modified list
7766 *
7767 * @details
7768 *
7769 *    Function : BuildDrbToBeModList
7770 *
7771 *    Functionality: Constructs the DRB to be modified list
7772 *
7773 * @params[in] DRBs_ToBeModified_List_t *drbSet
7774 *
7775 * @return ROK     - success
7776 *         RFAILED - failure
7777 *
7778 * ****************************************************************/
7779
7780 uint8_t BuildDrbToBeModifiedList(uint8_t ueId, DRBs_ToBeModified_List_t *drbSet)
7781 {
7782    uint8_t ret = ROK;
7783    uint8_t arrIdx =0;
7784    uint8_t drbCnt =0;
7785
7786    drbCnt = 1;
7787    drbSet->list.count = drbCnt;
7788    drbSet->list.size = drbCnt * sizeof(DRBs_ToBeModified_ItemIEs_t *);
7789    CU_ALLOC(drbSet->list.array, drbSet->list.size);
7790    if(drbSet->list.array == NULLP)
7791    {
7792       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDrbToBeModifiedList");
7793       return  RFAILED;
7794    }
7795    for(arrIdx=0; arrIdx<drbCnt; arrIdx++)
7796    {
7797       CU_ALLOC(drbSet->list.array[arrIdx], sizeof(DRBs_ToBeModified_ItemIEs_t));
7798       if(drbSet->list.array[arrIdx] == NULLP)
7799       {
7800          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDrbToBeSetupList");
7801          return  RFAILED;
7802       }
7803    }
7804
7805    arrIdx=0;
7806    ret = FillDrbToBeModItemList(ueId, (DRBs_ToBeModified_ItemIEs_t *)drbSet->list.array[arrIdx]);
7807    if(ret != ROK)
7808    {
7809       DU_LOG("\nERROR  -->  F1AP : FillDrbToBeModItemList failed");
7810    }
7811
7812    return ret;
7813 }
7814
7815 /*******************************************************************
7816 *
7817 * @brief freeing the DRB  item
7818 *
7819 * @details
7820 *
7821 *    Function : FreeModifiedDrbItem
7822 *
7823 *    Functionality: freeing the DRB 2 item
7824 *
7825 * @params[in] DRBs_ToBeSetupMod_Item_t *drbItem
7826 *
7827 * @return ROK     - success
7828 *         RFAILED - failure
7829 *
7830 * ****************************************************************/
7831
7832 void FreeModifiedDrbItem(DRBs_ToBeModified_Item_t *drbItem)
7833 {
7834    uint8_t arrIdx =0;
7835    SNSSAI_t *snssai =NULLP;
7836    Flows_Mapped_To_DRB_List_t *flowMap = NULLP;
7837
7838    if(drbItem->qoSInformation != NULLP)
7839    {
7840       switch(drbItem->qoSInformation->present)
7841       {
7842          case QoSInformation_PR_NOTHING:
7843             break;
7844          case QoSInformation_PR_eUTRANQoS:
7845             {
7846                if(drbItem->qoSInformation->choice.eUTRANQoS)
7847                {
7848                   CU_FREE(drbItem->qoSInformation->choice.eUTRANQoS, sizeof(EUTRANQoS_t));
7849                }
7850                break;
7851             }
7852          case QoSInformation_PR_choice_extension:
7853             {
7854                if(drbItem->qoSInformation->choice.choice_extension)
7855                {
7856                   FreeQOSInfo(&drbItem->qoSInformation->choice.choice_extension->value.choice.DRB_Information.dRB_QoS);
7857
7858                   snssai = &drbItem->qoSInformation->choice.choice_extension->value.choice.DRB_Information.sNSSAI;
7859                   if(snssai->sST.buf)
7860                   {
7861                      CU_FREE(snssai->sST.buf,snssai->sST.size);
7862                   }
7863                   if(snssai->sD)
7864                   {
7865                      if(snssai->sD->buf)
7866                      {
7867                         CU_FREE(snssai->sD->buf,snssai->sD->size);
7868                      }
7869                      CU_FREE(snssai->sD,sizeof(OCTET_STRING_t));
7870                   }
7871
7872                   flowMap = &drbItem->qoSInformation->choice.choice_extension->value.choice.DRB_Information.flows_Mapped_To_DRB_List;
7873                   if(flowMap->list.array)
7874                   {
7875                      for(arrIdx=0; arrIdx<flowMap->list.count; arrIdx++)
7876                      {
7877                         if(flowMap->list.array[arrIdx] )
7878                         {
7879                            FreeQOSInfo(&flowMap->list.array[arrIdx]->qoSFlowLevelQoSParameters);
7880                            CU_FREE(flowMap->list.array[arrIdx],sizeof(Flows_Mapped_To_DRB_Item_t));
7881                         }
7882                      }
7883                      CU_FREE(flowMap->list.array,flowMap->list.size);
7884                   }
7885
7886                   CU_FREE(drbItem->qoSInformation->choice.choice_extension,sizeof(QoSInformation_ExtIEs_t));
7887                }
7888                break;
7889             }
7890       }
7891    }
7892    FreeUlTnlInfoforDrb2(&drbItem->uLUPTNLInformation_ToBeSetup_List);
7893    if(drbItem->uLConfiguration)
7894    {
7895       CU_FREE(drbItem->uLConfiguration,sizeof(ULConfiguration_t));
7896    }
7897 }
7898
7899 /*******************************************************************
7900 *
7901 * @brief free the DRB to be modfified list
7902 *
7903 * @details
7904 *
7905 *    Function : FreeDrbToBeModifiedList
7906 *
7907 *    Functionality: free the DRB to be Setup Mod list
7908 *
7909 * @params[in] FreeDrbToBeModifiedList_t *drbSet
7910 *
7911 * @return ROK     - success
7912 *         RFAILED - failure
7913 *
7914 * ****************************************************************/
7915 void FreeDrbToBeModifiedList(DRBs_ToBeModified_List_t *drbSet)
7916 {
7917    uint8_t arrIdx =0;
7918    struct DRBs_ToBeModified_ItemIEs *drbItemIe;
7919
7920    if(drbSet->list.array)
7921    {
7922       for(arrIdx=0; arrIdx<drbSet->list.count ; arrIdx++)
7923       {
7924          if(drbSet->list.array[arrIdx] != NULLP)
7925          {
7926             drbItemIe = (struct DRBs_ToBeModified_ItemIEs *)drbSet->list.array[arrIdx];
7927             FreeModifiedDrbItem(&(drbItemIe->value.choice.DRBs_ToBeModified_Item));
7928             CU_FREE(drbSet->list.array[arrIdx], sizeof(DRBs_ToBeModified_ItemIEs_t));
7929          }
7930       }
7931       CU_FREE(drbSet->list.array, drbSet->list.size);
7932    }
7933
7934 }
7935
7936 /*******************************************************************
7937  *
7938  * @brief  free the UeContextModification Request
7939  *
7940  * @details
7941  *
7942  *    Function : FreeUeContextModicationRequest
7943  *
7944  *    Functionality : deallocation of memory allocated in UeContextModiification
7945  request
7946  *
7947  * @params[in] F1AP_PDU_t *f1apMsg
7948  *
7949  * @return void
7950 *
7951 * ****************************************************************/
7952 void FreeUeContextModicationRequest(F1AP_PDU_t *f1apMsg)
7953 {
7954    uint8_t arrIdx =0 , ieId=0;
7955    UEContextModificationRequest_t *UeContextModifyReq = NULLP;
7956
7957    if(f1apMsg)
7958    {
7959       if(f1apMsg->choice.initiatingMessage)
7960       {
7961          UeContextModifyReq =&f1apMsg->choice.initiatingMessage->value.choice.UEContextModificationRequest;
7962          if(UeContextModifyReq->protocolIEs.list.array)
7963          {
7964             for( arrIdx = 0 ; arrIdx<UeContextModifyReq->protocolIEs.list.count ; arrIdx++)
7965             {
7966                if(UeContextModifyReq->protocolIEs.list.array[arrIdx])
7967                {
7968                   ieId = UeContextModifyReq->protocolIEs.list.array[arrIdx]->id;
7969                   switch(ieId)
7970                   {
7971                      case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
7972                         break;
7973                      case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
7974                         break;
7975                      case ProtocolIE_ID_id_DRBs_ToBeSetupMod_List:
7976                         {
7977                            FreeDrbToBeSetupModList(&UeContextModifyReq->protocolIEs.list.array[arrIdx]->value.\
7978                                  choice.DRBs_ToBeSetupMod_List);
7979                            break;
7980                         }
7981                      case ProtocolIE_ID_id_DRBs_ToBeModified_List:
7982                         {
7983                            FreeDrbToBeModifiedList(&UeContextModifyReq->protocolIEs.list.array[arrIdx]->value.\
7984                                  choice.DRBs_ToBeSetupMod_List);
7985                            break;
7986                         }
7987
7988                   }
7989                   CU_FREE(UeContextModifyReq->protocolIEs.list.array[arrIdx], sizeof(UEContextModificationRequest_t));
7990                }
7991             }
7992             CU_FREE(UeContextModifyReq->protocolIEs.list.array, UeContextModifyReq->protocolIEs.list.size);
7993          }
7994          CU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
7995       }
7996       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
7997    }
7998 }
7999 /*******************************************************************
8000  *
8001  * @brief Builds the Ue Context Modification Req
8002  *
8003  * @details
8004  *
8005  *    Function : BuildAndSendUeContextModificationReq
8006  *
8007  *    Functionality: Constructs the Ue Context Modification Req
8008  *
8009  * @params[in]
8010  *
8011  * @return ROK     - success
8012  *         RFAILED - failure
8013  *
8014  * ****************************************************************/
8015 uint8_t BuildAndSendUeContextModificationReq(uint8_t ueId)
8016 {
8017    uint8_t    ieIdx = 0;
8018    uint8_t    elementCnt = 0;
8019    uint8_t    ret = RFAILED;
8020    F1AP_PDU_t *f1apMsg = NULLP;
8021    UEContextModificationRequest_t *ueContextModifyReq = NULLP;
8022
8023    asn_enc_rval_t         encRetVal;
8024    DU_LOG("\nINFO  -->  F1AP : Building Ue context modification request\n");
8025
8026    while(1)
8027    {
8028       CU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
8029       if(f1apMsg == NULLP)
8030       {
8031          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed Ue context modification");
8032          break;
8033       }
8034
8035       f1apMsg->present =  F1AP_PDU_PR_initiatingMessage;
8036
8037       CU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
8038       if(f1apMsg->choice.initiatingMessage == NULLP)
8039       {
8040          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed Ue context modification");
8041          break;
8042       }
8043       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_UEContextModification;
8044       f1apMsg->choice.initiatingMessage->criticality = Criticality_reject;
8045       f1apMsg->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_UEContextModificationRequest;
8046
8047       ueContextModifyReq =&f1apMsg->choice.initiatingMessage->value.choice.UEContextModificationRequest;
8048
8049       elementCnt = 4;
8050       ueContextModifyReq->protocolIEs.list.count = elementCnt;
8051       ueContextModifyReq->protocolIEs.list.size = elementCnt*sizeof(UEContextModificationRequest_t *);
8052
8053       /* Initialize the UE context modification members */
8054       CU_ALLOC(ueContextModifyReq->protocolIEs.list.array, ueContextModifyReq->protocolIEs.list.size);
8055       if(ueContextModifyReq->protocolIEs.list.array == NULLP)
8056       {
8057          DU_LOG("\nERROR  -->  F1AP : Memory allocation for UE context modifcation Request failed");
8058          break;
8059       }
8060
8061       for(ieIdx=0 ; ieIdx<elementCnt; ieIdx++)
8062       {
8063          CU_ALLOC(ueContextModifyReq->protocolIEs.list.array[ieIdx], sizeof(UEContextModificationRequest_t));
8064          if(ueContextModifyReq->protocolIEs.list.array[ieIdx] == NULLP)
8065          {
8066             DU_LOG("\nERROR  -->  F1AP : Memory allocation for UE context modifcation Request failed");
8067             break;
8068          }
8069       }
8070
8071
8072       ieIdx=0;
8073       ueContextModifyReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
8074       ueContextModifyReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
8075       ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present = \
8076                                                                          UEContextModificationRequestIEs__value_PR_GNB_CU_UE_F1AP_ID;
8077       ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID = ueId;
8078
8079       ieIdx++;
8080       ueContextModifyReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
8081       ueContextModifyReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
8082       ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present=\
8083                                                                        UEContextModificationRequestIEs__value_PR_GNB_DU_UE_F1AP_ID;
8084       ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID = ueId;
8085
8086       /* DRB to be setup list */
8087       ieIdx++;
8088       ueContextModifyReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_DRBs_ToBeSetupMod_List;
8089       ueContextModifyReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
8090       ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present =\
8091          UEContextModificationRequestIEs__value_PR_DRBs_ToBeSetupMod_List;
8092       ret = BuildDrbToBeSetupList(ueId, &(ueContextModifyReq->protocolIEs.list.array[ieIdx]->\
8093          value.choice.DRBs_ToBeSetupMod_List));
8094
8095       /* DRB to be modified list */
8096       ieIdx++;
8097       ueContextModifyReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_DRBs_ToBeModified_List;
8098       ueContextModifyReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
8099       ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present =\
8100          UEContextModificationRequestIEs__value_PR_DRBs_ToBeModified_List;
8101       ret = BuildDrbToBeModifiedList(ueId, &(ueContextModifyReq->protocolIEs.list.array[ieIdx]->\
8102          value.choice.DRBs_ToBeModified_List));
8103
8104       /* TODO: DRB to be release list */
8105
8106       if(ret != ROK)
8107       {
8108          break;
8109       }
8110       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
8111
8112       /* Encode the F1SetupRequest type as APER */
8113       memset(encBuf, 0, ENC_BUF_MAX_LEN);
8114       encBufSize = 0;
8115       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
8116             encBuf);
8117
8118       /* Encode results */
8119       if(encRetVal.encoded == ENCODE_FAIL)
8120       {
8121          DU_LOG("\nERROR  -->  F1AP : Could not encode ueContextModifyReq structure (at %s)\n",\
8122                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
8123          break;
8124       }
8125       else
8126       {
8127          DU_LOG("\nDEBUG  -->  F1AP : Created APER encodedbuffer for ueContextModifyReq\n");
8128          for(ieIdx=0; ieIdx< encBufSize; ieIdx++)
8129          {
8130             DU_LOG("%x",encBuf[ieIdx]);
8131          }
8132       }
8133
8134       if(SendF1APMsg(CU_APP_MEM_REG, CU_POOL) != ROK)
8135       {
8136          DU_LOG("\nERROR  -->  F1AP : Sending Ue context modification request  failed");
8137          break;
8138       }
8139
8140       ret = ROK;
8141       break;
8142
8143    }
8144    FreeUeContextModicationRequest(f1apMsg);
8145    return ret;
8146 }
8147 /*****************************************************************i
8148 *
8149 * @brief Free memory allocated for UE Context Release Command
8150 *
8151 * @details
8152 *
8153 *    Function : FreeUeContextReleaseCommand
8154 *
8155 *    Functionality:
8156 *         - Free memory allocated for UE Context Release Command
8157 *
8158 * @params[in] F1AP_PDU_t *f1apMsg
8159 * @return void
8160 *
8161 * *************************************************************/
8162 void FreeUeContextReleaseCommand(F1AP_PDU_t *f1apMsg)
8163 {
8164    uint8_t ieIdx;
8165    UEContextReleaseCommand_t *ueReleaseCommand = NULLP;
8166
8167    if(f1apMsg)
8168    {
8169       if(f1apMsg->choice.initiatingMessage)
8170       {
8171          ueReleaseCommand =&f1apMsg->choice.initiatingMessage->value.choice.UEContextReleaseCommand;
8172          if(ueReleaseCommand->protocolIEs.list.array)
8173          {
8174             for(ieIdx=0 ; ieIdx<ueReleaseCommand->protocolIEs.list.count; ieIdx++)
8175             {
8176                CU_FREE(ueReleaseCommand->protocolIEs.list.array[ieIdx], sizeof(UEContextReleaseCommand_t));
8177             }
8178             CU_FREE(ueReleaseCommand->protocolIEs.list.array, ueReleaseCommand->protocolIEs.list.size);
8179          }
8180          CU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
8181       }
8182       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
8183    }
8184 }
8185 /*******************************************************************
8186  *
8187  * @brief Builds the Ue Context Release Command
8188  *
8189  * @details
8190 *
8191 *    Function : BuildAndSendUeContextReleaseCommand
8192 *
8193 *    Functionality: Constructs the Ue Context Release Command
8194 *
8195 * @params[in]
8196 *
8197 * @return ROK     - success
8198 *         RFAILED - failure
8199 *
8200 * ****************************************************************/
8201 uint8_t BuildAndSendUeContextReleaseCommand(uint8_t cuUeF1apId, uint8_t duUeF1apId)
8202 {
8203    bool       memAllocFailed = false;
8204    uint8_t    ieIdx = 0,elementCnt = 0, ret = RFAILED, bufLen=0;
8205    F1AP_PDU_t *f1apMsg = NULLP;
8206    UEContextReleaseCommand_t *ueContextReleaseCommand = NULLP;
8207
8208    asn_enc_rval_t         encRetVal;
8209    DU_LOG("\nINFO  -->  F1AP : Building Ue context release command\n");
8210
8211    while(true)
8212    {
8213       CU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
8214       if(f1apMsg == NULLP)
8215       {
8216          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseCommand(): Memory allocation for F1AP-PDU");
8217          break;
8218       }
8219
8220       f1apMsg->present =  F1AP_PDU_PR_initiatingMessage;
8221
8222       CU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
8223       if(f1apMsg->choice.initiatingMessage == NULLP)
8224       {
8225          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseCommand(): Memory allocation for F1AP-PDU failed ");
8226          break;
8227       }
8228       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_UEContextRelease;
8229       f1apMsg->choice.initiatingMessage->criticality = Criticality_reject;
8230       f1apMsg->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_UEContextReleaseCommand;
8231
8232       ueContextReleaseCommand =&f1apMsg->choice.initiatingMessage->value.choice.UEContextReleaseCommand;
8233
8234       elementCnt = 4;
8235       ueContextReleaseCommand->protocolIEs.list.count = elementCnt;
8236       ueContextReleaseCommand->protocolIEs.list.size = elementCnt*sizeof(UEContextReleaseCommand_t*);
8237
8238       /* Initialize the UE context modification members */
8239       CU_ALLOC(ueContextReleaseCommand->protocolIEs.list.array, ueContextReleaseCommand->protocolIEs.list.size);
8240       if(ueContextReleaseCommand->protocolIEs.list.array == NULLP)
8241       {
8242          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseCommand():Memory allocation failed");
8243          break;
8244       }
8245
8246       for(ieIdx=0 ; ieIdx<elementCnt; ieIdx++)
8247       {
8248          CU_ALLOC(ueContextReleaseCommand->protocolIEs.list.array[ieIdx], sizeof(UEContextReleaseCommand_t));
8249          if(ueContextReleaseCommand->protocolIEs.list.array[ieIdx] == NULLP)
8250          {
8251             DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseCommand(): Memory allocation failed ");
8252             memAllocFailed = true;
8253             break;
8254          }
8255       }
8256
8257       if(memAllocFailed == true)
8258       {
8259          break;
8260       }
8261       ieIdx=0;
8262       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
8263       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
8264       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.present = \
8265       UEContextReleaseCommandIEs__value_PR_GNB_CU_UE_F1AP_ID;
8266       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID =cuUeF1apId;
8267
8268       ieIdx++;
8269       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
8270       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
8271       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.present=\
8272       UEContextReleaseCommandIEs__value_PR_GNB_DU_UE_F1AP_ID;
8273       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID =duUeF1apId;
8274
8275       ieIdx++;
8276       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_Cause;
8277       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->criticality = Criticality_ignore;
8278       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.present=\
8279       UEContextReleaseCommandIEs__value_PR_Cause;
8280       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.Cause.present = Cause_PR_radioNetwork;
8281       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.Cause.choice.radioNetwork=\
8282       CauseRadioNetwork_normal_release;
8283
8284       /* RRC Container for RRC release */
8285       ieIdx++;
8286       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_RRCContainer;
8287       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->criticality = Criticality_ignore;
8288       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.present = \
8289       UEContextReleaseCommandIEs__value_PR_RRCContainer;
8290       char secModeBuf[7]={ 0x00, 0x05, 0x13, 0x00, 0x00, 0x00, 0x00};
8291       bufLen =7;
8292       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.size = bufLen;
8293       CU_ALLOC(ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf,
8294       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.size);
8295       if(!ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf)
8296       {
8297       DU_LOG("\nERROR  -->  F1AP : Memory allocation for BuildAndSendUeContextReleaseCommand failed");
8298       break;
8299       }
8300       memset(ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf, 0, bufLen);
8301       memcpy(ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf, secModeBuf, bufLen);
8302
8303       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
8304
8305       /* Encode the UE Context Release Command type as APER */
8306       memset(encBuf, 0, ENC_BUF_MAX_LEN);
8307       encBufSize = 0;
8308       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
8309             encBuf);
8310
8311       /* Encode results */
8312       if(encRetVal.encoded == ENCODE_FAIL)
8313       {
8314          DU_LOG("\nERROR  -->  F1AP : Could not encode Release Command structure (at %s)\n",\
8315                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
8316          break;
8317       }
8318       else
8319       {
8320          DU_LOG("\nDEBUG  -->  F1AP : Created APER encoded buffer for Ue Context Release Command\n");
8321          for(ieIdx=0; ieIdx< encBufSize; ieIdx++)
8322          {
8323             DU_LOG("%x",encBuf[ieIdx]);
8324          }
8325       }
8326
8327       if(SendF1APMsg(CU_APP_MEM_REG, CU_POOL) != ROK)
8328       {
8329          DU_LOG("\nERROR  -->  F1AP : Sending Ue context Release Command failed");
8330          break;
8331       }
8332
8333       ret = ROK;
8334       break;
8335
8336    }
8337    FreeUeContextReleaseCommand(f1apMsg);
8338    return ret;
8339 }
8340 /*******************************************************************
8341 *
8342 * @brief process Ue context release request
8343 *
8344 * @details
8345 *
8346 *    Function : procUeContextReleaseReq
8347 *
8348 *    Functionality:
8349 *         - process Ue context release request
8350 *
8351 * @params[in] F1AP_PDU_t *f1apMsg
8352 * @return ROK     - success
8353 *         RFAILED - failure
8354 *
8355 * ****************************************************************/
8356 uint8_t procUeContextReleaseReq(F1AP_PDU_t *f1apMsg)
8357 {
8358    uint8_t ieIdx=0, duUeF1apId=0,cuUeF1apId=0;
8359
8360    UEContextReleaseRequest_t *ueReleaseReq = NULLP;
8361    ueReleaseReq = &f1apMsg->choice.initiatingMessage->value.choice.UEContextReleaseRequest;
8362
8363    for(ieIdx=0; ieIdx < ueReleaseReq->protocolIEs.list.count; ieIdx++)
8364    {
8365       switch(ueReleaseReq->protocolIEs.list.array[ieIdx]->id)
8366       {
8367          case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
8368             {
8369                cuUeF1apId = ueReleaseReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID;
8370                break;
8371             }
8372          case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
8373             {
8374                duUeF1apId = ueReleaseReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID;
8375                break;
8376             }
8377          default:
8378               break;
8379       }
8380    }
8381    if(BuildAndSendUeContextReleaseCommand(cuUeF1apId, duUeF1apId) != ROK)
8382    {
8383       DU_LOG("\nERROR  -->  F1AP : procUeContextReleaseReq(): Failed to build Ue Context Release Command ");
8384       return RFAILED;
8385    }
8386    return ROK;
8387 }
8388 /*******************************************************************
8389 *
8390 * @brief processing of Gnb-DU config update
8391 *
8392 * @details
8393 *
8394 *    Function : procGnbDuUpdate
8395 *
8396 *    Functionality:
8397 *         - processing of Gnb-DU config update
8398 *
8399 * @params[in] F1AP_PDU_t *f1apMsg
8400 * @return ROK     - success
8401 *         RFAILED - failure
8402 *
8403 * ****************************************************************/
8404 uint8_t procGnbDuUpdate(F1AP_PDU_t *f1apMsg)
8405 {
8406    bool cellToBeDelete = false;
8407    uint8_t ieIdx = 0, ueIdx = 0;
8408    GNBDUConfigurationUpdate_t *duCfgUpdate = NULLP;
8409
8410    duCfgUpdate = &f1apMsg->choice.initiatingMessage->value.choice.GNBDUConfigurationUpdate;
8411    for(ieIdx=0; ieIdx < duCfgUpdate->protocolIEs.list.count; ieIdx++)
8412    {
8413       switch(duCfgUpdate->protocolIEs.list.array[ieIdx]->id)
8414       {
8415          case ProtocolIE_ID_id_TransactionID:
8416             break;
8417          case ProtocolIE_ID_id_Served_Cells_To_Modify_List:
8418             break;
8419          case ProtocolIE_ID_id_Served_Cells_To_Delete_List:
8420             {
8421                cellToBeDelete = true;
8422                break;
8423             }
8424          case ProtocolIE_ID_id_gNB_DU_ID:
8425             break;
8426       }
8427    }
8428    if(BuildAndSendDUUpdateAck() != ROK)
8429    {
8430       DU_LOG("ERROR  -->  F1AP : Failed to build and send DUUpdateAck");
8431       return RFAILED;
8432    }
8433
8434    if(cellToBeDelete == false)
8435    {
8436       DU_LOG("\nINFO  -->  F1AP : Sending F1 reset request");
8437       if(BuildAndSendF1ResetReq() != ROK)
8438       {
8439          DU_LOG("ERROR  -->  F1AP : Failed to build and send F1 reset request");
8440          return RFAILED;
8441       }
8442    }
8443    else
8444    {
8445       for(ueIdx = 0; ueIdx < MAX_NUM_UE; ueIdx++)
8446       {
8447          CU_FREE(ueCb[ueIdx].f1apMsgDb.duToCuContainer.buf, ueCb[ueIdx].f1apMsgDb.duToCuContainer.size);
8448          memset(&ueCb[ueIdx], 0, sizeof(UeCb));
8449       }
8450    }
8451
8452    return ROK;
8453 }
8454
8455 /*******************************************************************
8456 *
8457 * @brief storing slice list in CU database
8458 *
8459 * @details
8460 *
8461 *    Function : buildSliceList
8462 *
8463 *    Functionality:
8464 *         - storing slice list in CU database
8465 *
8466 * @params[in] SliceSupportList_t *sliceSupportList
8467 * @return ROK     - success
8468 *         RFAILED - failure
8469 *
8470 * ****************************************************************/
8471 uint8_t buildSliceList(SliceSupportList_t *sliceSupportList)
8472 {
8473    uint8_t sliceListIdx = 0;
8474
8475    if(sliceSupportList)
8476    {
8477       if(sliceSupportList->list.array)
8478       {
8479          cuCfgParams.numSnssaiSupported = sliceSupportList->list.count;
8480          for(sliceListIdx=0; sliceListIdx<sliceSupportList->list.count; sliceListIdx++)
8481          {
8482             if(sliceSupportList->list.array[sliceListIdx])
8483             {
8484                CU_ALLOC(cuCfgParams.snssaiList[sliceListIdx], sizeof(Snssai));
8485                if(cuCfgParams.snssaiList[sliceListIdx] == NULLP)
8486                {
8487                    DU_LOG("\nERROR  --> CU_STUB: buildSliceList(): Memory allocation failed");
8488                    return RFAILED;
8489                }
8490                if(sliceSupportList->list.array[sliceListIdx]->sNSSAI.sST.buf)
8491                {
8492                   memcpy(&cuCfgParams.snssaiList[sliceListIdx]->sst, sliceSupportList->list.array[sliceListIdx]->\
8493                   sNSSAI.sST.buf, sliceSupportList->list.array[sliceListIdx]->sNSSAI.sST.size);
8494                }
8495                if(sliceSupportList->list.array[sliceListIdx]->sNSSAI.sD->size)
8496                {
8497                   memcpy(&cuCfgParams.snssaiList[sliceListIdx]->sd,\
8498                   sliceSupportList->list.array[sliceListIdx]->sNSSAI.sD->buf,\
8499                   sliceSupportList->list.array[sliceListIdx]->sNSSAI.sD->size);
8500                }
8501             }
8502          }
8503       }
8504    }
8505    return ROK;
8506 }
8507
8508 /****************************************************************
8509  * @brief Function to process Drb Setup Mod List
8510  *
8511  * @details
8512  *
8513  *    Function : procDrbSetupModList
8514  *
8515  *    Functionality:
8516  *         - Function to process DRB Setup Mod List
8517  *
8518  * @params[in]
8519  * @return ROK     - success
8520  *         RFAILED - failure
8521  *
8522  * ****************************************************************/
8523 uint8_t procDrbSetupModList(DRBs_SetupMod_List_t *drbSetupList)
8524 {
8525    uint8_t arrIdx = 0;
8526    uint32_t teId = 0;
8527    struct DRBs_SetupMod_ItemIEs *drbItemIe = NULLP;
8528
8529    if(drbSetupList != NULLP)
8530    {
8531       for(arrIdx = 0; arrIdx < drbSetupList->list.count; arrIdx++)
8532       {
8533          drbItemIe = ((struct DRBs_SetupMod_ItemIEs *)drbSetupList->list.array[arrIdx]);
8534          if(drbItemIe->value.present == DRBs_SetupMod_ItemIEs__value_PR_DRBs_SetupMod_Item)
8535          {
8536             /* extracting teId */
8537             teId  = extractTeId(&drbItemIe->value.choice.DRBs_SetupMod_Item.dLUPTNLInformation_ToBeSetup_List);
8538             if(teId > 0)
8539             {
8540               if(addDrbTunnels(teId)== ROK)
8541               {
8542                 DU_LOG("\nDEBUG  --> EGTP: Tunnel Added for TeId %d", teId);
8543               }
8544             }
8545             else
8546                return RFAILED;
8547          }
8548       }
8549    }
8550    return ROK;
8551 }
8552
8553 /*******************************************************************
8554 *
8555 * @brief processing of GNB_DU_Served_Cells Plmn list  information
8556 *
8557 * @details
8558 *
8559 *    Function : procServedCellPlmnList
8560 *
8561 *    Functionality:
8562 *         - processing of GNB_DU_Served_Cells Plmn list information for storing
8563 *         SNSSAI list
8564 *
8565 * @params[in] F1AP_PDU_t *f1apMsg
8566 * @return ROK     - success
8567 *         RFAILED - failure
8568 *
8569 * ****************************************************************/
8570 uint8_t procServedCellPlmnList(ServedPLMNs_List_t *srvPlmn)
8571 {
8572    uint8_t srvPlmnIdx=0, ieExtensionsLstIdx=0;
8573    ProtocolExtensionContainer_4624P3_t **ieExtend;
8574
8575    if(srvPlmn->list.array)
8576    {
8577       for(srvPlmnIdx=0; srvPlmnIdx<srvPlmn->list.count; srvPlmnIdx++)
8578       {
8579          if(srvPlmn->list.array[srvPlmnIdx])
8580          {
8581             ieExtend =  &srvPlmn->list.array[srvPlmnIdx]->iE_Extensions;
8582             if(*ieExtend)
8583             {
8584                if((*ieExtend)->list.array)
8585                {
8586                   for(ieExtensionsLstIdx = 0; ieExtensionsLstIdx<(*ieExtend)->list.count; ieExtensionsLstIdx++)
8587                   {
8588                      if((*ieExtend)->list.array[ieExtensionsLstIdx])
8589                      {
8590                         switch((*ieExtend)->list.array[ieExtensionsLstIdx]->id )
8591                         {
8592                            case ProtocolIE_ID_id_TAISliceSupportList:
8593                               {
8594                                  if(buildSliceList(&(*ieExtend)->list.array[ieExtensionsLstIdx]->\
8595                                           extensionValue.choice.SliceSupportList) != ROK)
8596                                  {
8597                                     DU_LOG("\nERROR  --> CU_STUB: procServedCellPlmnList(): Failed to build slice List");
8598                                     return RFAILED;
8599                                  }
8600                               }
8601                         }
8602                      }
8603                   }
8604                }
8605             }
8606          }
8607       }
8608    }
8609    return ROK;
8610 }
8611
8612 /****************************************************************
8613  * @brief Function to process Ue Context Modification Response
8614  *
8615  * @details
8616  *
8617  *    Function : procUeContextModificationResponse
8618  *
8619  *    Functionality:
8620  *         - Function to process Ue Context Modification Response
8621  *
8622  * @params[in]
8623  * @return ROK     - success
8624  *         RFAILED - failure
8625  *
8626  * ****************************************************************/
8627 uint8_t procUeContextModificationResponse(F1AP_PDU_t *f1apMsg)
8628 {
8629    uint8_t idx, duUeF1apId;
8630         UEContextModificationResponse_t *ueCtxtModRsp = NULLP;
8631    ueCtxtModRsp = &f1apMsg->choice.successfulOutcome->value.choice.UEContextModificationResponse;
8632
8633    for(idx=0; idx < ueCtxtModRsp->protocolIEs.list.count; idx++)
8634    {
8635       switch(ueCtxtModRsp->protocolIEs.list.array[idx]->id)
8636       {
8637           case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
8638              {
8639                 duUeF1apId = ueCtxtModRsp->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID;
8640                 break;
8641              }
8642           case ProtocolIE_ID_id_DRBs_SetupMod_List:
8643              {
8644                 /* Adding Tunnels for successful DRB */
8645                 procDrbSetupModList(&ueCtxtModRsp->protocolIEs.list.array[idx]->value.choice.DRBs_SetupMod_List);
8646                 break;
8647
8648              }
8649       }
8650    }
8651    return ROK;
8652 }
8653
8654 /*******************************************************************
8655 *
8656 * @brief processing of F1 setup request
8657 *
8658 * @details
8659 *
8660 *    Function : procF1SetupReq
8661 *
8662 *    Functionality:
8663 *         - processing of  F1 setup request
8664 *
8665 * @params[in] F1AP_PDU_t *f1apMsg
8666 * @return ROK     - success
8667 *         RFAILED - failure
8668 *
8669 * ****************************************************************/
8670 void procF1SetupReq(F1AP_PDU_t *f1apMsg)
8671 {
8672    uint8_t ieIdx = 0, plmnidx=0, ret=ROK;
8673    F1SetupRequest_t *f1SetupReq = NULLP;
8674    GNB_DU_Served_Cells_Item_t *srvCellItem = NULLP;
8675    GNB_DU_Served_Cells_List_t *duServedCell = NULLP;
8676
8677    f1SetupReq = &f1apMsg->choice.initiatingMessage->value.choice.F1SetupRequest;
8678    for(ieIdx=0; ieIdx < f1SetupReq->protocolIEs.list.count; ieIdx++)
8679    {
8680       switch(f1SetupReq->protocolIEs.list.array[ieIdx]->id)
8681       {
8682          case ProtocolIE_ID_id_gNB_DU_Served_Cells_List:
8683            {
8684                duServedCell = &f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_Served_Cells_List;
8685                if(duServedCell->list.array)
8686                {
8687                   for(plmnidx=0; plmnidx<duServedCell->list.count; plmnidx++)
8688                   {
8689                      if(duServedCell->list.array[plmnidx])
8690                      {
8691                         switch(duServedCell->list.array[plmnidx]->id)
8692                         {
8693                            case ProtocolIE_ID_id_GNB_DU_Served_Cells_Item:
8694                            {
8695                               srvCellItem =  &duServedCell->list.array[plmnidx]->value.choice.GNB_DU_Served_Cells_Item;
8696                               ret = procServedCellPlmnList(&srvCellItem->served_Cell_Information.servedPLMNs);
8697                            }
8698                         }
8699                      }
8700                   }
8701                }
8702            }
8703       }
8704    }
8705    if(ret == ROK)
8706    {
8707       BuildAndSendF1SetupRsp();
8708    }
8709    else
8710    {
8711        DU_LOG("\nERROR  --> CU_STUB: procF1SetupReq(): Failed to process F1 setup request");
8712    }
8713 }
8714
8715 /*******************************************************************
8716  *
8717  * @brief Handles received F1AP message and sends back response
8718  *
8719  * @details
8720  *
8721  *    Function : F1APMsgHdlr
8722  *
8723  *    Functionality:
8724  *         - Decodes received F1AP control message
8725  *         - Prepares response message, encodes and sends to SCTP
8726  *
8727  * @params[in]
8728  * @return ROK     - success
8729  *         RFAILED - failure
8730  *
8731  * ****************************************************************/
8732 void F1APMsgHdlr(Buffer *mBuf)
8733 {
8734    int i;
8735    char *recvBuf;
8736    MsgLen copyCnt;
8737    MsgLen recvBufLen;
8738    F1AP_PDU_t *f1apMsg = NULLP;
8739    asn_dec_rval_t rval; /* Decoder return value */
8740    F1AP_PDU_t f1apasnmsg ;
8741
8742    DU_LOG("\nINFO  -->  F1AP : Received F1AP message buffer");
8743    ODU_PRINT_MSG(mBuf, 0,0);
8744
8745    /* Copy mBuf into char array to decode it */
8746    ODU_GET_MSG_LEN(mBuf, &recvBufLen);
8747    CU_ALLOC(recvBuf, (Size)recvBufLen);
8748
8749    if(recvBuf == NULLP)
8750    {
8751       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed");
8752       return;
8753    }
8754    if(ODU_COPY_MSG_TO_FIX_BUF(mBuf, 0, recvBufLen, (Data *)recvBuf, &copyCnt) != ROK)
8755    {
8756       DU_LOG("\nERROR  -->  F1AP : Failed while copying %d", copyCnt);
8757       return;
8758    }
8759
8760    DU_LOG("\nDEBUG  -->  F1AP : Received flat buffer to be decoded : ");
8761    for(i=0; i< recvBufLen; i++)
8762    {
8763       DU_LOG("%x",recvBuf[i]);
8764    }
8765
8766    /* Decoding flat buffer into F1AP messsage */
8767    f1apMsg = &f1apasnmsg;
8768    memset(f1apMsg, 0, sizeof(F1AP_PDU_t));
8769
8770    rval = aper_decode(0, &asn_DEF_F1AP_PDU, (void **)&f1apMsg, recvBuf, recvBufLen, 0, 0);
8771    CU_FREE(recvBuf, (Size)recvBufLen);
8772
8773    if(rval.code == RC_FAIL || rval.code == RC_WMORE)
8774    {
8775       DU_LOG("\nERROR  -->  F1AP : ASN decode failed");
8776       return;
8777    }
8778    DU_LOG("\n");
8779    xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
8780
8781    switch(f1apMsg->present)
8782    {
8783       case F1AP_PDU_PR_initiatingMessage:
8784          {
8785             switch(f1apMsg->choice.initiatingMessage->value.present)
8786             {
8787                case InitiatingMessage__value_PR_Reset:
8788                   {
8789                      DU_LOG("\nINFO  -->  F1AP : F1 reset request received ");
8790                      BuildAndSendF1ResetAck();
8791                      break;
8792                   }
8793
8794                case InitiatingMessage__value_PR_F1SetupRequest:
8795                   {
8796                      DU_LOG("\nINFO  -->  F1AP : F1 setup request received");
8797                      procF1SetupReq(f1apMsg);
8798                      break;
8799                   }
8800
8801                case InitiatingMessage__value_PR_GNBDUConfigurationUpdate:
8802                   {
8803                      DU_LOG("\nINFO  -->  F1AP : GNB-DU config update received");
8804                      procGnbDuUpdate(f1apMsg);
8805                      break;
8806                   }
8807                case InitiatingMessage__value_PR_InitialULRRCMessageTransfer:
8808                   {
8809                      DU_LOG("\nINFO  -->  F1AP : Received InitialULRRCMessageTransfer");
8810                      procInitULRRCMsg(f1apMsg);
8811                      break;
8812                   }
8813                case InitiatingMessage__value_PR_ULRRCMessageTransfer:
8814                   {
8815                      DU_LOG("\nINFO  -->  F1AP : Received ULRRCMessageTransfer");
8816                      procUlRrcMsg(f1apMsg);
8817                      break;
8818                   }
8819
8820                case InitiatingMessage__value_PR_RRCDeliveryReport:
8821                   {
8822                      DU_LOG("\nINFO  -->  F1AP : Received RRC delivery report");
8823                      break;
8824                   }
8825                case InitiatingMessage__value_PR_UEContextReleaseRequest:
8826                   {
8827                      DU_LOG("\nINFO  -->  F1AP : Received UE Context Release Request");
8828                      procUeContextReleaseReq(f1apMsg);
8829                      break;
8830                   }
8831                default:
8832                   {
8833                      DU_LOG("\nERROR  -->  F1AP : Invalid type of intiating message [%d]",\
8834                            f1apMsg->choice.initiatingMessage->value.present);
8835                      return;
8836                   }
8837             }/* End of switch(initiatingMessage) */
8838             break;
8839          }
8840
8841       case F1AP_PDU_PR_successfulOutcome:
8842          {
8843             switch(f1apMsg->choice.successfulOutcome->value.present)
8844             {
8845                case SuccessfulOutcome__value_PR_ResetAcknowledge:
8846                   {
8847                      DU_LOG("\nINFO  -->  F1Reset Acknowledgement is received successfully ");
8848                      break;
8849                   }
8850                case SuccessfulOutcome__value_PR_UEContextSetupResponse:
8851                   {
8852                      DU_LOG("\nINFO  -->  F1AP : UE ContextSetupResponse received");
8853                      procUeContextSetupResponse(f1apMsg);
8854                      break;
8855                   }
8856                case SuccessfulOutcome__value_PR_UEContextModificationResponse:
8857                   {
8858                      DU_LOG("\nINFO  -->  F1AP : UE Context Modification Response received");
8859                      procUeContextModificationResponse(f1apMsg);
8860                      break;
8861                   }
8862                case SuccessfulOutcome__value_PR_UEContextReleaseComplete:
8863                   {
8864                       DU_LOG("\nINFO  -->  F1AP : UE Context release complete received");
8865                       break;
8866                   }
8867                default:
8868                   {
8869                      DU_LOG("\nERROR  -->  F1AP : Invalid type of successful outcome message [%d]",\
8870                            f1apMsg->choice.successfulOutcome->value.present);
8871                      return;
8872                   }
8873             }/* End of switch(successfulOutcome) */
8874             break;
8875          }
8876       default:
8877          {
8878             DU_LOG("\nERROR  -->  F1AP : Invalid type of f1apMsg->present [%d]",f1apMsg->present);
8879             return;
8880          }
8881    }/* End of switch(f1apMsg->present) */
8882
8883 } /* End of F1APMsgHdlr */
8884
8885 /**********************************************************************
8886   End of file
8887  **********************************************************************/