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