src/cu_stub/cu_f1ap_msg_hdl.c

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