src/cu_stub/cu_f1ap_msg_hdl.c

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