src/cu_stub/cu_f1ap_msg_hdl.c

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