src/cu_stub/cu_f1ap_msg_hdl.c

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