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