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