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