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