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(OCTET_STRING_t *masterCellGroup)
1025 {
1026    uint8_t ret = ROK;
1027    masterCellGroup->buf = NULLP;
1028    if(f1apMsgDb.duToCuContainer.buf)
1029    {
1030       masterCellGroup->size = f1apMsgDb.duToCuContainer.size;
1031       CU_ALLOC(masterCellGroup->buf, masterCellGroup->size);
1032       if(masterCellGroup->buf != NULLP)
1033       {
1034          memcpy(masterCellGroup->buf, 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(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(&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(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(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 rrcMsgType, RRCContainer_t *rrcContainer)
1533 {
1534    uint8_t ret, bufLen;
1535
1536    ret =ROK;
1537    if(rrcMsgType == RRC_SETUP)
1538    {
1539       ret = fillDlCcchRrcMsg(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 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 = CU_ID;
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 = DU_ID;
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(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()
1754 {
1755    uint8_t rrcMsgType = 0;
1756    switch(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;
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             break;
1814          case ProtocolIE_ID_id_NRCGI:
1815             break;
1816          case ProtocolIE_ID_id_C_RNTI:
1817             break;
1818          case ProtocolIE_ID_id_RRCContainer:
1819             break;
1820          case ProtocolIE_ID_id_DUtoCURRCContainer:
1821             {
1822                if((initULRRCMsg->protocolIEs.list.array[idx]->value.choice\
1823                         .DUtoCURRCContainer.size > 0) && (initULRRCMsg->protocolIEs\
1824                            .list.array[idx]->value.choice.DUtoCURRCContainer.buf != NULLP))
1825                {
1826                   DU_LOG("\nINFO  -->  Received Du to Cu RRC Container ");
1827                   f1apMsgDb.duToCuContainer.size = initULRRCMsg->protocolIEs\
1828                                                    .list.array[idx]->value.choice.DUtoCURRCContainer.size;
1829                   CU_ALLOC(f1apMsgDb.duToCuContainer.buf, \
1830                         f1apMsgDb.duToCuContainer.size);
1831                   if(f1apMsgDb.duToCuContainer.buf != NULLP)
1832                   {
1833                      memcpy(f1apMsgDb.duToCuContainer.buf, initULRRCMsg->protocolIEs\
1834                            .list.array[idx]->value.choice.DUtoCURRCContainer.buf, f1apMsgDb\
1835                            .duToCuContainer.size);
1836                   }
1837                }
1838                else
1839                {
1840                   DU_LOG("\nERROR  -->  Failed to receive Du to Cu RRC Container ");
1841                   ret = RFAILED;
1842                }
1843                break;
1844             }
1845          default:
1846             DU_LOG("\nERROR  -->  Invalid Event %ld", initULRRCMsg->protocolIEs.list.array[idx]->id);
1847             break;
1848       }
1849    }
1850    if(ret == ROK)
1851    {
1852       f1apMsgDb.dlRrcMsgCount++;
1853       rrcMsgType = setDlRRCMsgType();
1854       ret = BuildAndSendDLRRCMessageTransfer(SRB0, rrcMsgType);
1855    }
1856    return ret;
1857 }
1858
1859 /*******************************************************************
1860  *
1861  * @brief Builds Nrcgi
1862  *
1863  * @details
1864  *
1865  *    Function : BuildNrcgi
1866  *
1867  *    Functionality: Building the PLMN ID and NR Cell id
1868  *
1869  * @params[in] NRCGI_t *nrcgi
1870  * @return ROK     - success
1871  *         RFAILED - failure
1872  *
1873  * ****************************************************************/
1874 uint8_t BuildNrcgi(NRCGI_t *nrcgi)
1875 {
1876    uint8_t ret;
1877    uint8_t unused_bits = 4;
1878    uint8_t byteSize = 5;
1879    uint8_t val = 1;
1880    /* Allocate Buffer Memory */
1881    nrcgi->pLMN_Identity.size = 3 * sizeof(uint8_t);
1882    CU_ALLOC(nrcgi->pLMN_Identity.buf, nrcgi->pLMN_Identity.size);
1883    if(nrcgi->pLMN_Identity.buf == NULLP)
1884    {
1885       return RFAILED;
1886    }
1887    ret = buildPlmnId(cuCfgParams.plmn , nrcgi->pLMN_Identity.buf);
1888
1889    if(ret != ROK)
1890    {
1891       return RFAILED;
1892    }
1893    nrcgi->nRCellIdentity.size = byteSize * sizeof(uint8_t);
1894    CU_ALLOC(nrcgi->nRCellIdentity.buf, nrcgi->nRCellIdentity.size);
1895    if(nrcgi->nRCellIdentity.buf == NULLP)
1896    {
1897       return RFAILED;
1898    }
1899 #if 0
1900    ret = fillBitString(&nrcgi->nRCellIdentity, unused, byteSize, val);
1901    if(ret != ROK)
1902    {
1903       return RFAILED;
1904    }
1905 #endif
1906    memset(nrcgi->nRCellIdentity.buf, 0, nrcgi->nRCellIdentity.size);
1907    nrcgi->nRCellIdentity.buf[0] |= val;
1908    nrcgi->nRCellIdentity.bits_unused = unused_bits;
1909
1910    return ROK;
1911 }
1912 /*******************************************************************
1913  *
1914  * @brief Builds Special cell list for UE Setup Request
1915  *
1916  * @details
1917  *
1918  *    Function : BuildSplCellList
1919  *
1920  *    Functionality: Constructs the Special Cell list for UESetReq
1921  *
1922  * @params[in] SCell_ToBeSetup_List_t *spCellLst
1923  *
1924  * @return ROK     - success
1925  *         RFAILED - failure
1926  *
1927  * ****************************************************************/
1928 uint8_t BuildSplCellList(SCell_ToBeSetup_List_t *spCellLst)
1929 {
1930    uint8_t  cellCnt;
1931    uint8_t  idx;
1932    uint8_t  ret;
1933    cellCnt = 1;
1934    spCellLst->list.count = cellCnt;
1935    spCellLst->list.size = cellCnt * sizeof(SCell_ToBeSetup_ItemIEs_t *);
1936    CU_ALLOC(spCellLst->list.array,spCellLst->list.size);
1937    if(spCellLst->list.array == NULLP)
1938    {
1939       return RFAILED;
1940    }
1941    for(idx=0; idx<cellCnt; idx++)
1942    {
1943       CU_ALLOC(spCellLst->list.array[idx],sizeof(SCell_ToBeSetup_ItemIEs_t));
1944       if(spCellLst->list.array[idx] == NULLP)
1945       {
1946          return RFAILED;
1947       }
1948    }
1949    idx = 0;
1950    spCellLst->list.array[idx]->id = ProtocolIE_ID_id_SCell_ToBeSetup_Item;
1951    spCellLst->list.array[idx]->criticality = Criticality_ignore;
1952    spCellLst->list.array[idx]->value.present =\
1953                                               SCell_ToBeSetup_ItemIEs__value_PR_SCell_ToBeSetup_Item;
1954    /* Special Cell ID -NRCGI */
1955    ret = BuildNrcgi(&spCellLst->list.array[idx]->value.choice.SCell_ToBeSetup_Item.sCell_ID);
1956    if(ret != ROK)
1957    {
1958       return RFAILED;
1959    }
1960    /*Special Cell Index*/
1961    spCellLst->list.array[idx]->value.choice.SCell_ToBeSetup_Item.sCellIndex = 1;
1962    return ROK;
1963 }/* End of BuildSplCellList*/
1964
1965 /*******************************************************************
1966  *
1967  * @brief Builds SRBS to be setup
1968  *
1969  * @details
1970  *
1971  *    Function : BuildSRBSetup
1972  *
1973  *    Functionality: Constructs the SRB's for UESetReq
1974  *
1975  * @params[in] SRBs_ToBeSetup_List_t *srbSet
1976  *
1977  * @return ROK     - success
1978  *         RFAILED - failure
1979  *
1980  * ****************************************************************/
1981 uint8_t BuildSRBSetup(SRBs_ToBeSetup_List_t *srbSet)
1982 {
1983    uint8_t idx;
1984    uint8_t srbCnt;
1985    srbCnt = 1;
1986    srbSet->list.count = srbCnt;
1987    srbSet->list.size = srbCnt*sizeof(SRBs_ToBeSetup_ItemIEs_t *);
1988    CU_ALLOC(srbSet->list.array,srbSet->list.size);
1989    if(srbSet->list.array == NULLP)
1990    {
1991       return RFAILED;
1992    }
1993    for(idx=0; idx<srbCnt; idx++)
1994    {
1995       CU_ALLOC(srbSet->list.array[idx],sizeof(SRBs_ToBeSetup_ItemIEs_t));
1996       if(srbSet->list.array[idx] == NULLP)
1997       {
1998          return RFAILED;
1999       }
2000    }
2001    idx = 0;
2002    srbSet->list.array[idx]->id = ProtocolIE_ID_id_SRBs_ToBeSetup_Item;
2003    srbSet->list.array[idx]->criticality = Criticality_ignore;
2004    srbSet->list.array[idx]->value.present = \
2005                                             SRBs_ToBeSetup_ItemIEs__value_PR_SRBs_ToBeSetup_Item;
2006    srbSet->list.array[idx]->value.choice.SRBs_ToBeSetup_Item.sRBID = 2;
2007    return ROK;
2008 }/* End of BuildSRBSetup*/
2009
2010 /*******************************************************************
2011  *
2012  * @brief Builds QOS Info for DRB Setum Item
2013  *
2014  * @details
2015  *
2016  *    Function : BuildQOSInfo
2017  *
2018  *    Functionality: Constructs the QOS Info for DRB Setup Item
2019  *
2020  * @params[in] QoSInformation_t *qosinfo
2021  *
2022  * @return ROK     - success
2023  *         RFAILED - failure
2024  *
2025  * ****************************************************************/
2026 uint8_t BuildQOSInfo(QoSFlowLevelQoSParameters_t *drbQos)
2027 {
2028    /* NonDynamic5QIDescriptor */
2029    drbQos->qoS_Characteristics.present = QoS_Characteristics_PR_non_Dynamic_5QI;
2030    CU_ALLOC(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI,sizeof(NonDynamic5QIDescriptor_t));
2031    if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI == NULLP)
2032    {
2033       return RFAILED;
2034    }
2035    /*FiveQI*/
2036    drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->fiveQI = FIVE_QI_VALUE;
2037    /*AveragingWindow*/
2038    CU_ALLOC(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow,\
2039          sizeof(AveragingWindow_t));
2040    if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow == \
2041          NULLP)
2042    {
2043       return RFAILED;
2044    }
2045    *(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow) = 0;
2046    /*MaxDataBurstVolume*/
2047    CU_ALLOC(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume,\
2048          sizeof(MaxDataBurstVolume_t));
2049    if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume == \
2050          NULLP)
2051    {
2052       return RFAILED;
2053    }
2054    *(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume) = 0;
2055
2056    /*nRGRAN Allocation Retention Priority*/
2057    drbQos->nGRANallocationRetentionPriority.priorityLevel = PriorityLevel_lowest;
2058    drbQos->nGRANallocationRetentionPriority.pre_emptionCapability = Pre_emptionCapability_may_trigger_pre_emption;
2059    drbQos->nGRANallocationRetentionPriority.pre_emptionVulnerability = Pre_emptionVulnerability_not_pre_emptable;
2060
2061    return ROK;
2062 }/*End of BuildQOSInfo*/
2063
2064 /*******************************************************************
2065  *
2066  * @brief Builds SNSSAI
2067  *
2068  * @details
2069  *
2070  *    Function : BuildSNSSAI
2071  *
2072  *    Functionality: Constructs the SNSSAI For DRB list
2073  *
2074  * @params[in] SNSSAI_t *snssai
2075  *
2076  * @return ROK     - success
2077  *         RFAILED - failure
2078  *
2079  * ****************************************************************/
2080 uint8_t BuildSNSSAI(SNSSAI_t *snssai)
2081 {
2082    /*SNSSAI*/
2083    /*ssT*/
2084    snssai->sST.size = sizeof(uint8_t);
2085    CU_ALLOC(snssai->sST.buf,snssai->sST.size);
2086    if(snssai->sST.buf == NULLP)
2087    {
2088       return RFAILED;
2089    }
2090    snssai->sST.buf[0] = 3;
2091    /*sD*/
2092    CU_ALLOC(snssai->sD,sizeof(OCTET_STRING_t));
2093    if(snssai->sD == NULLP)
2094    {
2095       return RFAILED;
2096    }
2097    snssai->sD->size = 3*sizeof(uint8_t);
2098    CU_ALLOC(snssai->sD->buf,snssai->sD->size);
2099    if(snssai->sD->buf == NULLP)
2100    {
2101       return RFAILED;
2102    }
2103    snssai->sD->buf[0] = 3;
2104    snssai->sD->buf[1] = 6;
2105    snssai->sD->buf[2] = 9;
2106    return ROK;
2107 }/*End of BuildSNSSAI*/
2108
2109 /*******************************************************************
2110  *
2111  * @brief Builds the flow map.
2112  *
2113  * @details
2114  *
2115  *    Function : BuildFlowsMap
2116  *
2117  *    Functionality: Constructs the flowmap For DRB list
2118  *
2119  * @params[in] Flows_Mapped_To_DRB_List_t *flowMap
2120  *
2121  * @return ROK     - success
2122  *         RFAILED - failure
2123  *
2124  * ****************************************************************/
2125 uint8_t BuildFlowsMap(Flows_Mapped_To_DRB_List_t *flowMap)
2126 {
2127    uint8_t  ret;
2128    uint8_t  idx;
2129    uint8_t  flowCnt;
2130    flowCnt = 1;
2131    flowMap->list.count = flowCnt;
2132    flowMap->list.size = flowCnt * sizeof(Flows_Mapped_To_DRB_Item_t *);
2133    CU_ALLOC(flowMap->list.array,flowMap->list.size);
2134    if(flowMap->list.array == NULLP)
2135    {
2136       return RFAILED;
2137    }
2138    for(idx=0; idx<flowCnt; idx++)
2139    {
2140       CU_ALLOC(flowMap->list.array[idx],sizeof(Flows_Mapped_To_DRB_Item_t));
2141       if(flowMap->list.array[idx] == NULLP)
2142       {
2143          return RFAILED;
2144       }
2145    }
2146    idx = 0;
2147    flowMap->list.array[idx]->qoSFlowIdentifier = 0;
2148    ret = BuildQOSInfo(&flowMap->list.array[idx]->qoSFlowLevelQoSParameters);
2149    if(ret != ROK)
2150    {
2151       return RFAILED;
2152    }
2153    return ROK;
2154 }/*End of BuildFlowsMap*/
2155
2156 /*******************************************************************
2157  *
2158  * @brief Builds the Uplink Tunnel Info
2159  *
2160  * @details
2161  *
2162  *    Function : BuildULTnlInfo
2163  *
2164  *    Functionality: Constructs the UL TnlInfo For DRB list
2165  *
2166  * @params[in] ULUPTNLInformation_ToBeSetup_List_t *ulInfo
2167  *
2168  * @return ROK     - success
2169  *         RFAILED - failure
2170  *
2171  * ****************************************************************/
2172 uint8_t BuildULTnlInfo(ULUPTNLInformation_ToBeSetup_List_t *ulInfo)
2173 {
2174    uint8_t idx;
2175    uint8_t ulCnt;
2176    ulCnt = 1;
2177    ulInfo->list.count = ulCnt;
2178    ulInfo->list.size = ulCnt * sizeof(ULUPTNLInformation_ToBeSetup_Item_t *);
2179    CU_ALLOC(ulInfo->list.array,ulInfo->list.size);
2180    if(ulInfo->list.array == NULLP)
2181    {
2182       return RFAILED;
2183    }
2184    for(idx=0; idx<ulCnt; idx++)
2185    {
2186       CU_ALLOC(ulInfo->list.array[idx],sizeof(ULUPTNLInformation_ToBeSetup_Item_t));
2187       if(ulInfo->list.array[idx] == NULLP)
2188       {
2189          return RFAILED;
2190       }
2191    }
2192    idx = 0;
2193    ulInfo->list.array[idx]->uLUPTNLInformation.present = \
2194                                                          UPTransportLayerInformation_PR_gTPTunnel;
2195    /*GTP TUNNEL*/
2196    CU_ALLOC(ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel,\
2197          sizeof(GTPTunnel_t));
2198    if(ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel == NULLP)
2199    {
2200       return RFAILED;
2201    }
2202    ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->\
2203       transportLayerAddress.size        = 4*sizeof(uint8_t);
2204    CU_ALLOC(ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->\
2205          transportLayerAddress.buf,ulInfo->list.array[idx]->\
2206          uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.size);
2207    if(ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->\
2208          transportLayerAddress.buf == NULLP)
2209    {
2210       return RFAILED;
2211    }
2212    /* NOTE: Below IP address must be changed if running on different IP configuration */
2213    ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->\
2214       transportLayerAddress.buf[0] = 192;
2215    ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->\
2216       transportLayerAddress.buf[1] = 168;
2217    ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->\
2218       transportLayerAddress.buf[2] = 130;
2219    ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->\
2220       transportLayerAddress.buf[3] = 82;
2221    ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->\
2222       transportLayerAddress.bits_unused = 0;
2223    /*GTP TEID*/
2224    ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.size\
2225       = 4 * sizeof(uint8_t);
2226    CU_ALLOC(ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->\
2227          gTP_TEID.buf,ulInfo->list.array[idx]->uLUPTNLInformation.choice.\
2228          gTPTunnel->gTP_TEID.size);
2229    if(ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf\
2230          == NULLP)
2231    {
2232       return RFAILED;
2233    }
2234    ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->\
2235      gTP_TEID.buf[0] = 0;
2236    ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->\
2237       gTP_TEID.buf[1] = 0;
2238    ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->\
2239       gTP_TEID.buf[2] = 0;
2240    ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->\
2241       gTP_TEID.buf[3] = 1;
2242
2243    return ROK;
2244 }/*End of BuildULTnlInfo*/
2245
2246 /*******************************************************************
2247  *
2248  * @brief Builds DRBS to be setup
2249  *
2250  * @details
2251  *
2252  *    Function : BuildDRBSetup
2253  *
2254  *    Functionality: Constructs the DRB's for UESetReq
2255  *
2256  * @params[in] DRBs_ToBeSetup_List_t *drbSet
2257  *
2258  * @return ROK     - success
2259  *         RFAILED - failure
2260  *
2261  * ****************************************************************/
2262 uint8_t BuildDRBSetup(DRBs_ToBeSetup_List_t *drbSet)
2263 {
2264    uint8_t BuildQOSInforet;
2265    uint8_t BuildSNSSAIret;
2266    uint8_t BuildFlowsMapret;
2267    uint8_t BuildULTnlInforet;
2268    uint8_t idx;
2269    uint8_t drbCnt;
2270    DRBs_ToBeSetup_Item_t *drbSetItem;
2271    drbCnt = 1;
2272    drbSet->list.count = drbCnt;
2273    drbSet->list.size = drbCnt*sizeof(DRBs_ToBeSetup_ItemIEs_t *);
2274    CU_ALLOC(drbSet->list.array,drbSet->list.size);
2275    if(drbSet->list.array == NULLP)
2276    {
2277       return RFAILED;
2278    }
2279    for(idx=0; idx<drbCnt; idx++)
2280    {
2281       CU_ALLOC(drbSet->list.array[idx],sizeof(DRBs_ToBeSetup_ItemIEs_t));
2282       if(drbSet->list.array[idx] == NULLP)
2283       {
2284          return RFAILED;
2285       }
2286    }
2287    idx = 0;
2288    drbSet->list.array[idx]->id = ProtocolIE_ID_id_DRBs_ToBeSetup_Item;
2289    drbSet->list.array[idx]->criticality = Criticality_ignore;
2290    drbSet->list.array[idx]->value.present = \
2291                                             DRBs_ToBeSetup_ItemIEs__value_PR_DRBs_ToBeSetup_Item;
2292    drbSetItem = &drbSet->list.array[idx]->value.choice.DRBs_ToBeSetup_Item;
2293    /*dRBID*/
2294    drbSetItem->dRBID = 1;
2295    /*qoSInformation*/
2296    drbSetItem->qoSInformation.present = QoSInformation_PR_choice_extension;
2297    CU_ALLOC(drbSetItem->qoSInformation.choice.choice_extension,sizeof(QoSInformation_ExtIEs_t));
2298    if(drbSetItem->qoSInformation.choice.choice_extension == NULLP)
2299    {
2300       return RFAILED;
2301    }
2302    drbSetItem->qoSInformation.choice.choice_extension->id = \
2303                                                             ProtocolIE_ID_id_DRB_Information;
2304    drbSetItem->qoSInformation.choice.choice_extension->criticality = \
2305                                                                      Criticality_ignore;
2306    drbSetItem->qoSInformation.choice.choice_extension->value.present = \
2307                                                                        QoSInformation_ExtIEs__value_PR_DRB_Information;
2308    BuildQOSInforet =  BuildQOSInfo(&drbSetItem->qoSInformation.choice.\
2309          choice_extension->value.choice.DRB_Information.dRB_QoS);
2310    if(BuildQOSInforet != ROK)
2311    {
2312       return RFAILED;
2313    }
2314    /*SNSSAI*/
2315    BuildSNSSAIret = BuildSNSSAI(&drbSetItem->qoSInformation.choice.\
2316          choice_extension->value.choice.DRB_Information.sNSSAI);
2317    if(BuildSNSSAIret != ROK)
2318    {
2319       return RFAILED;
2320    }
2321    /*Flows mapped to DRB List*/
2322    BuildFlowsMapret = BuildFlowsMap(&drbSetItem->qoSInformation.choice.\
2323          choice_extension->value.choice.DRB_Information.flows_Mapped_To_DRB_List);
2324    if(BuildFlowsMapret != ROK)
2325    {
2326       return RFAILED;
2327    }
2328    /*ULUPTNLInformation To Be Setup List*/
2329    BuildULTnlInforet = BuildULTnlInfo(&drbSetItem->uLUPTNLInformation_ToBeSetup_List);
2330    if(BuildULTnlInforet != ROK)
2331    {
2332       return RFAILED;
2333    }
2334    /*RLCMode*/
2335    drbSetItem->rLCMode = RLCMode_rlc_um_bidirectional;
2336
2337    /*UL Configuration*/
2338    CU_ALLOC(drbSetItem->uLConfiguration,sizeof(ULConfiguration_t));
2339    if(drbSetItem->uLConfiguration == NULLP)
2340    {
2341       return RFAILED;
2342    }
2343    drbSetItem->uLConfiguration->uLUEConfiguration = ULUEConfiguration_no_data;
2344    return ROK;
2345 }/* End of BuildDRBSetup*/
2346
2347 /*******************************************************************
2348  *
2349  * @brief Deallocating memory of function BuildAndSendUESetReq
2350  *
2351  * @details
2352  *
2353  *    Function : FreeNrcgi
2354  *
2355  *    Functionality: Deallocating memory for function BuildNrcgi
2356  *
2357  * @params[in] NRCGI_t *nrcgi
2358  *
2359  * @return void
2360  *
2361  *******************************************************************/
2362 void FreeNrcgi(NRCGI_t *nrcgi)
2363 {
2364    if(nrcgi->pLMN_Identity.buf != NULLP)
2365    {
2366       if(nrcgi->nRCellIdentity.buf != NULLP)
2367       {
2368          CU_FREE(nrcgi->nRCellIdentity.buf, nrcgi->nRCellIdentity.size);
2369       }
2370       CU_FREE(nrcgi->pLMN_Identity.buf, nrcgi->pLMN_Identity.size);
2371    }
2372 }
2373 /*******************************************************************
2374  *
2375  * @brief  Deallocating memory of function BuildAndSendUESetReq
2376  *
2377  * @details
2378  *
2379  *    Function : FreeSplCellList
2380  *
2381  *    Functionality: Deallocating memory for function BuildSplCellList
2382  *
2383  * @params[in] SCell_ToBeSetup_List_t *spCellLst
2384  *
2385  * @return void
2386  *
2387  *
2388  * *****************************************************************/
2389 void FreeSplCellList(SCell_ToBeSetup_List_t *spCellLst)
2390 {
2391    uint8_t  cellidx;
2392    if(spCellLst->list.array != NULLP)
2393    {
2394       for(cellidx=0; cellidx<spCellLst->list.count; cellidx++)
2395       {
2396          if(cellidx==0&&spCellLst->list.array[cellidx]!=NULLP)
2397          {
2398             FreeNrcgi(&spCellLst->list.array[cellidx]->value.choice.SCell_ToBeSetup_Item.sCell_ID);
2399          }
2400          if(spCellLst->list.array[cellidx]!=NULLP)
2401          {
2402             CU_FREE(spCellLst->list.array[cellidx],sizeof(SCell_ToBeSetup_ItemIEs_t));
2403          }
2404       }
2405       CU_FREE(spCellLst->list.array,spCellLst->list.size);
2406    }
2407 }
2408 /*******************************************************************
2409  *
2410  * @brief Deallocating memory of function BuildAndSendUESetReq
2411  *
2412  * @details
2413  *
2414  *    Function : FreeSRBSetup
2415  *
2416  *    Functionality: Deallocating memory for function BuildSRBSetup
2417  *
2418  * @params[in] SRBs_ToBeSetup_List_t *srbSet
2419  *
2420  * @return void
2421  *
2422  *
2423  * ******************************************************************/
2424 void FreeSRBSetup(SRBs_ToBeSetup_List_t *srbSet)
2425 {
2426    uint8_t srbidx;
2427    if(srbSet->list.array != NULLP)
2428    {
2429       for(srbidx=0; srbidx<srbSet->list.count; srbidx++)
2430       {
2431          if(srbSet->list.array[srbidx]!=NULLP)
2432          {
2433             CU_FREE(srbSet->list.array[srbidx],sizeof(SRBs_ToBeSetup_ItemIEs_t));
2434          }
2435       }
2436       CU_FREE(srbSet->list.array,srbSet->list.size);
2437    }
2438 }
2439 /*******************************************************************
2440  *
2441  * @brief Deallocating memory of function BuildAndSendUESetReq
2442  *
2443  * @details
2444  *
2445  *    Function : FreeQOSInfo
2446  *
2447  *    Functionality:  Deallocating memory for function BuildQOSInfo
2448  *
2449  * @params[in] QoSFlowLevelQoSParameters_t *drbQos
2450  *
2451  * @return void
2452  *
2453  * ****************************************************************/
2454 void FreeQOSInfo(QoSFlowLevelQoSParameters_t *drbQos)
2455 {
2456    if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI != NULLP)
2457    {
2458       if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow!=NULLP)
2459       {
2460          if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume!=NULLP)
2461          {
2462             CU_FREE(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume,\
2463                   sizeof(MaxDataBurstVolume_t));
2464          }
2465          CU_FREE(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow,\
2466                sizeof(AveragingWindow_t));
2467       }
2468       CU_FREE(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI,\
2469             sizeof(NonDynamic5QIDescriptor_t));
2470    }
2471 }
2472 /*******************************************************************
2473  *
2474  * @brief Deallocating memory of function BuildAndSendUESetReq
2475  *
2476  * @details
2477  *
2478  *    Function : FreeULTnlInfo
2479  *
2480  *    Functionality:  Deallocating memory for function BuildULTnlInfo
2481  *
2482  * @params[in] ULUPTNLInformation_ToBeSetup_List_t *ulInfo
2483  *
2484  * @return void
2485  *
2486
2487  * ****************************************************************/
2488 void FreeULTnlInfo(ULUPTNLInformation_ToBeSetup_List_t *ulInfo)
2489 {
2490    uint8_t ulidx=0;
2491    if(ulInfo->list.array != NULLP)
2492    {
2493       for(ulidx=0; ulidx<ulInfo->list.count; ulidx++)
2494       {
2495          if(ulidx==0&&ulInfo->list.array[ulidx]!=NULLP)
2496          {
2497             if(ulInfo->list.array[ulidx]->uLUPTNLInformation.choice.gTPTunnel!=NULLP)
2498             {
2499                if(ulInfo->list.array[ulidx]->uLUPTNLInformation.choice.gTPTunnel->\
2500                      transportLayerAddress.buf != NULLP)
2501                {
2502                   if(ulInfo->list.array[ulidx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf\
2503                         !=NULLP)
2504                   {
2505                      CU_FREE(ulInfo->list.array[ulidx]->uLUPTNLInformation.choice.gTPTunnel->\
2506                            gTP_TEID.buf,ulInfo->list.array[ulidx]->uLUPTNLInformation.choice.\
2507                            gTPTunnel->gTP_TEID.size);
2508                   }
2509                   CU_FREE(ulInfo->list.array[ulidx]->uLUPTNLInformation.choice.gTPTunnel->\
2510                         transportLayerAddress.buf,ulInfo->list.array[ulidx]->\
2511                         uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.size);
2512                }
2513                CU_FREE(ulInfo->list.array[ulidx]->uLUPTNLInformation.choice.gTPTunnel,\
2514                      sizeof(GTPTunnel_t));
2515             }
2516          }
2517          if(ulInfo->list.array[ulidx]!=NULLP)
2518          {
2519             CU_FREE(ulInfo->list.array[ulidx],sizeof(ULUPTNLInformation_ToBeSetup_Item_t));
2520          }
2521       }
2522       CU_FREE(ulInfo->list.array,ulInfo->list.size);
2523    }
2524 }
2525 /*******************************************************************
2526  *
2527  * @brief Deallocating memory for BuildAndSendUESetReq
2528  *
2529  * @details
2530  *
2531  *    Function : FreeDRBSetup
2532  *
2533  *    Functionality:  Deallocating memory for BuildDRBSetup
2534  *
2535  * @params[in] DRBs_ToBeSetup_List_t *drbSet
2536  *
2537  * @return void
2538  *
2539  * ****************************************************************/
2540 void FreeDRBSetup(DRBs_ToBeSetup_List_t *drbSet)
2541 {
2542    DRBs_ToBeSetup_Item_t *drbSetItem;
2543    uint8_t  flowidx;
2544    uint8_t  drbidx;
2545    if(drbSet->list.array == NULLP)
2546    {
2547       for(drbidx=0; drbidx<drbSet->list.count; drbidx++)
2548       {
2549          if(drbidx==0&&drbSet->list.array[drbidx] != NULLP)
2550          {
2551             drbSetItem =&drbSet->list.array[drbidx]->value.choice.DRBs_ToBeSetup_Item;
2552             if(drbSetItem->qoSInformation.choice.choice_extension != NULLP)
2553             {
2554                if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
2555                      qoS_Characteristics.choice.non_Dynamic_5QI !=NULLP)
2556                {
2557                   if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
2558                         qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow!=NULLP)
2559                   {
2560                      if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
2561                            qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume!=NULLP)
2562                      {
2563                         if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sST.buf!=NULLP)
2564                         {
2565                            if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD!=NULLP)
2566                            {
2567                               if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD->buf!=NULLP)
2568                               {
2569                                  if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.\
2570                                        flows_Mapped_To_DRB_List.list.array != NULLP)
2571                                  {
2572                                     for(flowidx=0;flowidx<drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.\
2573                                           flows_Mapped_To_DRB_List.list.count; flowidx++)
2574                                     {
2575                                        if(flowidx==0&&drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
2576                                              DRB_Information.flows_Mapped_To_DRB_List.list.array[flowidx]!=NULLP)
2577                                        {
2578                                           if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
2579                                                 DRB_Information.flows_Mapped_To_DRB_List.list.array[flowidx]->qoSFlowLevelQoSParameters.\
2580                                                 qoS_Characteristics.choice.non_Dynamic_5QI!=NULLP)
2581                                           {
2582                                              if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
2583                                                    DRB_Information.flows_Mapped_To_DRB_List.list.array[flowidx]->qoSFlowLevelQoSParameters.\
2584                                                    qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow!=NULLP)
2585                                              {
2586                                                 if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
2587                                                       DRB_Information.flows_Mapped_To_DRB_List.list.array[flowidx]->qoSFlowLevelQoSParameters.\
2588                                                       qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume!=NULLP)
2589                                                 {
2590                                                    FreeULTnlInfo(&drbSetItem->uLUPTNLInformation_ToBeSetup_List);
2591                                                    CU_FREE(drbSetItem->uLConfiguration,sizeof(ULConfiguration_t));
2592
2593                                                    CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
2594                                                          DRB_Information.flows_Mapped_To_DRB_List.list.array[flowidx]->qoSFlowLevelQoSParameters.\
2595                                                          qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume,\
2596                                                          sizeof(MaxDataBurstVolume_t));
2597                                                 }
2598                                                 CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
2599                                                       DRB_Information.flows_Mapped_To_DRB_List.list.array[flowidx]->qoSFlowLevelQoSParameters.\
2600                                                       qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow,sizeof(AveragingWindow_t));
2601                                              }
2602                                              CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
2603                                                    DRB_Information.flows_Mapped_To_DRB_List.list.array[flowidx]->qoSFlowLevelQoSParameters.\
2604                                                    qoS_Characteristics.choice.non_Dynamic_5QI,sizeof(NonDynamic5QIDescriptor_t));
2605                                           }
2606                                        }
2607                                        if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
2608                                              DRB_Information.flows_Mapped_To_DRB_List.list.array[flowidx]!=NULLP)
2609                                        {
2610                                           CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
2611                                                 DRB_Information.flows_Mapped_To_DRB_List.list.array[flowidx],sizeof(Flows_Mapped_To_DRB_Item_t));
2612                                        }
2613                                     }
2614                                     CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.\
2615                                           flows_Mapped_To_DRB_List.list.array,drbSetItem->qoSInformation.choice.choice_extension->value.\
2616                                           choice.DRB_Information.flows_Mapped_To_DRB_List.list.size);
2617                                  }
2618                                  CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD->buf,\
2619                                        drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD->size);
2620                               }
2621                               CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD,\
2622                                     sizeof(OCTET_STRING_t));
2623                            }
2624                            CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sST.buf,\
2625                                  drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sST.size);
2626                         }
2627                         CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
2628                               qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume,sizeof(MaxDataBurstVolume_t));
2629                      }
2630                      CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
2631                            qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow,sizeof(AveragingWindow_t));
2632                   }
2633                   CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
2634                         qoS_Characteristics.choice.non_Dynamic_5QI, sizeof(NonDynamic5QIDescriptor_t));
2635                }
2636                CU_FREE(drbSetItem->qoSInformation.choice.choice_extension,sizeof(QoSInformation_ExtIEs_t));
2637             }
2638          }
2639          if(drbSet->list.array[drbidx]!=NULLP)
2640          {
2641             CU_FREE(drbSet->list.array[drbidx],sizeof(DRBs_ToBeSetup_ItemIEs_t));
2642          }
2643       }
2644       CU_FREE(drbSet->list.array,drbSet->list.size);
2645    }
2646 }
2647
2648
2649 /*******************************************************************
2650  *
2651  * @brief Free the UE Setup Request
2652  *
2653  * @details
2654  *
2655  *    Function : FreeUeContextSetupReq
2656  *
2657  *    Functionality: Deallocate the memory of BuildUESetReq
2658  *
2659  * @params[in]  F1AP_PDU_t  *f1apMsg
2660  *
2661  * @return void
2662  *
2663  *
2664  * ****************************************************************/
2665 void FreeUeContextSetupReq(F1AP_PDU_t  *f1apMsg)
2666 {
2667    uint8_t idx, ieId;
2668    UEContextSetupRequest_t  *ueSetReq = NULLP;
2669
2670    if(f1apMsg != NULLP)
2671    {
2672       if(f1apMsg->choice.initiatingMessage != NULLP)
2673       {
2674          ueSetReq = &f1apMsg->choice.initiatingMessage->value.choice.UEContextSetupRequest;
2675          if(ueSetReq->protocolIEs.list.array != NULLP)
2676          {
2677             for(idx = 0; idx < ueSetReq->protocolIEs.list.count; idx++)
2678             {
2679                if(ueSetReq->protocolIEs.list.array[idx])
2680                {
2681                   switch(ueSetReq->protocolIEs.list.array[idx]->id)
2682                   {
2683                      case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
2684                         break;
2685                      case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
2686                         break;
2687                      case ProtocolIE_ID_id_SpCell_ID:
2688                         FreeNrcgi(&ueSetReq->protocolIEs.list.array[idx]->value.choice.NRCGI);
2689                         break;
2690                      case ProtocolIE_ID_id_ServCellIndex:
2691                         break;
2692                      case ProtocolIE_ID_id_SpCellULConfigured:
2693                         break;
2694                      case ProtocolIE_ID_id_CUtoDURRCInformation:
2695                         FreeCuToDuInfo(&ueSetReq->protocolIEs.list.array[idx]->value.choice.CUtoDURRCInformation);
2696                         break;
2697                      case ProtocolIE_ID_id_SCell_ToBeSetup_List:
2698                         FreeSplCellList(&ueSetReq->protocolIEs.list.array[idx]->value.choice.SCell_ToBeSetup_List);
2699                         break;
2700                      case ProtocolIE_ID_id_SRBs_ToBeSetup_List:
2701                         FreeSRBSetup(&ueSetReq->protocolIEs.list.array[idx]->value.choice.SRBs_ToBeSetup_List);
2702                         break;
2703                      case ProtocolIE_ID_id_DRBs_ToBeSetup_List:
2704                         FreeDRBSetup(&ueSetReq->protocolIEs.list.array[idx]->value.choice.DRBs_ToBeSetup_List);
2705                         break;
2706                      case ProtocolIE_ID_id_RRCContainer:
2707                         if(ueSetReq->protocolIEs.list.array[idx]->value.choice.RRCContainer.buf != NULLP)
2708                         {
2709                           CU_FREE(ueSetReq->protocolIEs.list.array[idx]->value.choice.RRCContainer.buf, \
2710                           ueSetReq->protocolIEs.list.array[idx]->value.choice.RRCContainer.size);
2711                         }
2712                         break;
2713                      default:
2714                         DU_LOG("\nERROR  -->  F1AP: Invalid event type %ld", ueSetReq->protocolIEs.list.array[idx]->id);
2715                   }
2716                }
2717                break;
2718             }
2719             for(ieId=0; ieId<idx; ieId++)
2720             {
2721                if(ueSetReq->protocolIEs.list.array[ieId] != NULLP)
2722                {
2723                   CU_FREE(ueSetReq->protocolIEs.list.array[ieId],sizeof(UEContextSetupRequestIEs_t));
2724                }
2725             }
2726             CU_FREE(ueSetReq->protocolIEs.list.array,ueSetReq->protocolIEs.list.size);
2727          }
2728          CU_FREE(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
2729       }
2730       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
2731    }
2732 }
2733
2734 /**Filling cell group info **/
2735 /*******************************************************************
2736  *
2737  * @brief Build Control resource set to add/modify list
2738  *
2739  * @details
2740  *
2741  *    Function : BuildControlRSetToAddModList
2742  *
2743  *    Functionality: Build Control resource set to add/modify list
2744  *
2745  * @params[in]
2746  * struct PDCCH_Config__controlResourceSetToAddModList *controlRSetList
2747  *
2748  * @return ROK     - success
2749  *         RFAILED - failure
2750  *
2751  * ****************************************************************/
2752    uint8_t BuildControlRSetToAddModList
2753 (
2754  struct PDCCH_Config__controlResourceSetToAddModList *controlRSetList
2755  )
2756 {
2757    uint8_t idx;
2758    uint8_t elementCnt;
2759    uint8_t numBytes, bitsUnused;
2760    struct ControlResourceSet *controlRSet;
2761    uint8_t freqDomainResource[FREQ_DOM_RSRC_SIZE] = {0};
2762    uint8_t coreset0EndPrb, coreset1StartPrb, coreset1NumPrb;
2763
2764    elementCnt = 1;
2765    controlRSetList->list.count = elementCnt;
2766    controlRSetList->list.size = \
2767                                 elementCnt * sizeof(struct ControlResourceSet *);
2768
2769    controlRSetList->list.array = NULLP;
2770    CU_ALLOC(controlRSetList->list.array, controlRSetList->list.size);
2771    if(!controlRSetList->list.array)
2772    {
2773       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
2774       return RFAILED;
2775    }
2776
2777    for(idx = 0; idx < elementCnt; idx++)
2778    {
2779       controlRSetList->list.array[idx] = NULLP;
2780       CU_ALLOC(controlRSetList->list.array[idx], sizeof(struct ControlResourceSet));
2781       if(!controlRSetList->list.array[idx])
2782       {
2783          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
2784          return RFAILED;
2785       }
2786    }
2787
2788    idx=0;
2789    controlRSet = controlRSetList->list.array[idx];
2790    controlRSet->controlResourceSetId = PDCCH_CTRL_RSRC_SET_ONE_ID;
2791
2792    /* Values harcoded according to our design:
2793     * size 6 bytes
2794     * 3 LSBs unsued
2795     * Bit string stored ff0000000000
2796     */
2797    numBytes = 6;
2798    bitsUnused = 3;
2799    controlRSet->frequencyDomainResources.size = numBytes * sizeof(uint8_t);
2800    controlRSet->frequencyDomainResources.buf = NULLP;
2801    CU_ALLOC(controlRSet->frequencyDomainResources.buf, \
2802          controlRSet->frequencyDomainResources.size);
2803    if(!controlRSet->frequencyDomainResources.buf)
2804    {
2805       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
2806       return RFAILED;
2807    }
2808
2809    memset(controlRSet->frequencyDomainResources.buf, 0, FREQ_DOM_RSRC_SIZE);
2810    coreset0EndPrb = CORESET0_END_PRB;
2811    coreset1StartPrb = coreset0EndPrb + 6;
2812    coreset1NumPrb = CORESET1_NUM_PRB;
2813    /* calculate the PRBs */
2814    freqDomRscAllocType0(((coreset1StartPrb)/6), (coreset1NumPrb/6), freqDomainResource);
2815    memcpy(controlRSet->frequencyDomainResources.buf, freqDomainResource, FREQ_DOM_RSRC_SIZE);
2816    controlRSet->frequencyDomainResources.bits_unused = bitsUnused;
2817
2818    controlRSet->duration = PDCCH_CTRL_RSRC_SET_ONE_DURATION;
2819    controlRSet->cce_REG_MappingType.present = \
2820                                               ControlResourceSet__cce_REG_MappingType_PR_nonInterleaved;
2821
2822    controlRSet->precoderGranularity = PDCCH_CTRL_RSRC_SET_ONE_PRECOD_GRANULARITY;
2823    controlRSet->tci_StatesPDCCH_ToAddList = NULLP;
2824    controlRSet->tci_StatesPDCCH_ToReleaseList = NULLP;
2825    controlRSet->tci_PresentInDCI = NULLP;
2826 #if 0
2827    uint8_t tciStateIdx;
2828
2829    CU_ALLOC(controlRset->tci_StatesPDCCH_ToAddList, \
2830          sizeof(struct ControlResourceSet__tci_StatesPDCCH_ToAddList));
2831    if(!controlRset->tci_StatesPDCCH_ToAddList)
2832    {
2833       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
2834       return RFAILED;
2835    }
2836
2837    elementCnt = 1;
2838    controlRset->tci_StatesPDCCH_ToAddList->list.count = elementCnt;
2839    controlRset->tci_StatesPDCCH_ToAddList->list.size = elementCnt * sizeof(TCI_StateId_t *);
2840    CU_ALLOC(controlRset->tci_StatesPDCCH_ToAddList->list.array, \
2841          controlRset->tci_StatesPDCCH_ToAddList->list.size)
2842       if(!controlRset->tci_StatesPDCCH_ToAddList->list.array)
2843       {
2844          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
2845          return RFAILED;
2846       }
2847
2848    for(tciStateIdx = 0; tciStateIdx <elementCntl; tciStateIdx++)
2849    {
2850       CU_ALLOC(controlRset->tci_StatesPDCCH_ToAddList->list.array[tciStateIdx], sizeof(TCI_StateId_t));
2851       if(!controlRset->tci_StatesPDCCH_ToAddList->list.array[tciStateIdx])
2852       {
2853          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
2854          return RFAILED;
2855       }
2856    }
2857
2858    tciStateIdx = 0;
2859    /* TODO */
2860    *(controlRset->tci_StatesPDCCH_ToAddList->list.array[tciStateIdx]);
2861
2862    CU_ALLOC(controlRset->tci_PresentInDCI, sizeof(long));
2863    if(!controlRset->tci_PresentInDCI)
2864    {
2865       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
2866       return RFAILED;
2867    }
2868    /* TODO */
2869    *(controlRset->tci_PresentInDCI);
2870 #endif
2871
2872    controlRSet->pdcch_DMRS_ScramblingID = NULLP;
2873    CU_ALLOC(controlRSet->pdcch_DMRS_ScramblingID, sizeof(long));
2874    if(!controlRSet->pdcch_DMRS_ScramblingID)
2875    {
2876       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
2877       return RFAILED;
2878    }
2879    *(controlRSet->pdcch_DMRS_ScramblingID) = SCRAMBLING_ID;
2880
2881    return ROK;
2882 } /* End BuildControlRSetToAddModList */
2883
2884 /*******************************************************************
2885  *
2886  * @brief Build search space to add/modify list
2887  *
2888  * @details
2889  *
2890  *    Function : BuildSearchSpcToAddModList
2891  *
2892  *    Functionality: Build search space to add/modify list
2893  *
2894  * @params[in]
2895  * @return ROK     - success
2896  *         RFAILED - failure
2897  *
2898  * ****************************************************************/
2899    uint8_t BuildSearchSpcToAddModList
2900 (
2901  struct PDCCH_Config__searchSpacesToAddModList *searchSpcList
2902  )
2903 {
2904    uint8_t idx;
2905    uint8_t numBytes;
2906    uint8_t byteIdx;
2907    uint8_t bitsUnused;
2908    uint8_t elementCnt;
2909    struct SearchSpace *searchSpc;
2910
2911    elementCnt = 1;
2912    searchSpcList->list.count = elementCnt;
2913    searchSpcList->list.size = elementCnt * sizeof(struct SearchSpace *);
2914
2915    searchSpcList->list.array = NULLP;
2916    CU_ALLOC(searchSpcList->list.array, searchSpcList->list.size);
2917    if(!searchSpcList->list.array)
2918    {
2919       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
2920       return RFAILED;
2921    }
2922
2923    for(idx = 0; idx < elementCnt; idx++)
2924    {
2925       searchSpcList->list.array[idx] = NULLP;
2926       CU_ALLOC(searchSpcList->list.array[idx], sizeof(struct SearchSpace));
2927       if(!searchSpcList->list.array[idx])
2928       {
2929          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
2930          return RFAILED;
2931       }
2932    }
2933
2934    idx = 0;
2935    searchSpc = searchSpcList->list.array[idx];
2936
2937    searchSpc->searchSpaceId = PDCCH_SRCH_SPC_TWO_ID;
2938
2939    searchSpc->controlResourceSetId = NULLP;
2940    CU_ALLOC(searchSpc->controlResourceSetId, sizeof(ControlResourceSetId_t));
2941    if(!searchSpc->controlResourceSetId)
2942    {
2943       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
2944       return RFAILED;
2945    }
2946    *(searchSpc->controlResourceSetId) = PDCCH_CTRL_RSRC_SET_ONE_ID;
2947
2948    searchSpc->monitoringSlotPeriodicityAndOffset = NULLP;
2949    CU_ALLOC(searchSpc->monitoringSlotPeriodicityAndOffset, \
2950          sizeof(struct SearchSpace__monitoringSlotPeriodicityAndOffset));
2951    if(!searchSpc->monitoringSlotPeriodicityAndOffset)
2952    {
2953       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
2954       return RFAILED;
2955    }
2956    searchSpc->monitoringSlotPeriodicityAndOffset->present = \
2957                                                             SearchSpace__monitoringSlotPeriodicityAndOffset_PR_sl1;
2958
2959    searchSpc->duration = NULLP;
2960    searchSpc->monitoringSymbolsWithinSlot = NULLP;
2961    CU_ALLOC(searchSpc->monitoringSymbolsWithinSlot, sizeof(BIT_STRING_t));
2962    if(!searchSpc->monitoringSymbolsWithinSlot)
2963    {
2964       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
2965       return RFAILED;
2966    }
2967
2968    /* Values taken from reference logs :
2969     * size 2 bytes
2970     * 2 LSBs unsued
2971     * Bit string stores 8000
2972     */
2973    numBytes = 2;
2974    bitsUnused = 2;
2975
2976    searchSpc->monitoringSymbolsWithinSlot->size = numBytes * sizeof(uint8_t);
2977    searchSpc->monitoringSymbolsWithinSlot->buf = NULLP;
2978    CU_ALLOC(searchSpc->monitoringSymbolsWithinSlot->buf, \
2979          searchSpc->monitoringSymbolsWithinSlot->size);
2980    if(!searchSpc->monitoringSymbolsWithinSlot->buf)
2981    {
2982       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
2983       return RFAILED;
2984    }
2985
2986    byteIdx = 0;
2987    searchSpc->monitoringSymbolsWithinSlot->buf[byteIdx++] = \
2988                                                             PDCCH_SYMBOL_WITHIN_SLOT /* setting MSB to 128 i.e. 0x80 */;
2989    searchSpc->monitoringSymbolsWithinSlot->buf[byteIdx++] = 0;
2990    searchSpc->monitoringSymbolsWithinSlot->bits_unused = bitsUnused;
2991
2992    searchSpc->nrofCandidates = NULLP;
2993    CU_ALLOC(searchSpc->nrofCandidates, sizeof(struct SearchSpace__nrofCandidates));
2994    if(!searchSpc->nrofCandidates)
2995    {
2996       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
2997       return RFAILED;
2998    }
2999
3000    searchSpc->nrofCandidates->aggregationLevel1 = \
3001                                                   PDCCH_SRCH_SPC_TWO_AGG_LVL1_CANDIDATE;
3002    searchSpc->nrofCandidates->aggregationLevel2 = \
3003                                                   PDCCH_SRCH_SPC_TWO_AGG_LVL2_CANDIDATE;
3004    searchSpc->nrofCandidates->aggregationLevel4 = \
3005                                                   PDCCH_SRCH_SPC_TWO_AGG_LVL4_CANDIDATE;
3006    searchSpc->nrofCandidates->aggregationLevel8 = \
3007                                                   PDCCH_SRCH_SPC_TWO_AGG_LVL8_CANDIDATE;
3008    searchSpc->nrofCandidates->aggregationLevel16 = \
3009                                                    PDCCH_SRCH_SPC_TWO_AGG_LVL16_CANDIDATE;
3010
3011    searchSpc->searchSpaceType = NULLP;
3012    CU_ALLOC(searchSpc->searchSpaceType, sizeof(struct SearchSpace__searchSpaceType));
3013    if(!searchSpc->searchSpaceType)
3014    {
3015       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3016       return RFAILED;
3017    }
3018
3019    searchSpc->searchSpaceType->present = SearchSpace__searchSpaceType_PR_ue_Specific;
3020
3021    searchSpc->searchSpaceType->choice.ue_Specific = NULLP;
3022    CU_ALLOC(searchSpc->searchSpaceType->choice.ue_Specific, \
3023          sizeof(struct SearchSpace__searchSpaceType__ue_Specific));
3024    if(!searchSpc->searchSpaceType->choice.ue_Specific)
3025    {
3026       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3027       return RFAILED;
3028    }
3029    searchSpc->searchSpaceType->choice.ue_Specific->dci_Formats = \
3030                                                                  PDCCH_SRCH_SPC_TWO_UE_SPEC_DCI_FORMAT;
3031
3032    return ROK;
3033 }/* End BuildSearchSpcToAddModList */
3034
3035 /*******************************************************************
3036  *
3037  * @brief Builds BWP DL dedicated PDCCH config
3038  *
3039  * @details
3040  *
3041  *    Function : BuildBWPDlDedPdcchCfg
3042  *
3043  *    Functionality: Builds BWP DL dedicated PDCCH config
3044  *
3045  * @params[in] struct PDCCH_Config *pdcchCfg
3046  *
3047  * @return ROK     - success
3048  *         RFAILED - failure
3049  *
3050  * ****************************************************************/
3051 uint8_t BuildBWPDlDedPdcchCfg(struct PDCCH_Config *pdcchCfg)
3052 {
3053    pdcchCfg->controlResourceSetToAddModList = NULLP;
3054    CU_ALLOC(pdcchCfg->controlResourceSetToAddModList, \
3055          sizeof(struct PDCCH_Config__controlResourceSetToAddModList));
3056    if(!pdcchCfg->controlResourceSetToAddModList)
3057    {
3058       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdcchCfg");
3059       return RFAILED;
3060    }
3061
3062    if(BuildControlRSetToAddModList(pdcchCfg->controlResourceSetToAddModList) != ROK)
3063    {
3064       return RFAILED;
3065    }
3066
3067    pdcchCfg->controlResourceSetToReleaseList = NULLP;
3068
3069    pdcchCfg->searchSpacesToAddModList = NULLP;
3070    CU_ALLOC(pdcchCfg->searchSpacesToAddModList, \
3071          sizeof(struct PDCCH_Config__searchSpacesToAddModList));
3072    if(!pdcchCfg->searchSpacesToAddModList)
3073    {
3074       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdcchCfg");
3075       return RFAILED;
3076    }
3077
3078    if(BuildSearchSpcToAddModList(pdcchCfg->searchSpacesToAddModList) != ROK)
3079    {
3080       return RFAILED;
3081    }
3082
3083    pdcchCfg->searchSpacesToReleaseList = NULLP;
3084    pdcchCfg->downlinkPreemption = NULLP;
3085    pdcchCfg->tpc_PUSCH = NULLP;
3086    pdcchCfg->tpc_PUCCH = NULLP;
3087    pdcchCfg->tpc_SRS = NULLP;
3088
3089    return ROK;
3090 }
3091
3092 /*******************************************************************
3093  *
3094  * @brief Builds DMRS DL PDSCH Mapping type A
3095  *
3096  * @details
3097  *
3098  *    Function : BuildDMRSDLPdschMapTypeA
3099  *
3100  *    Functionality: Builds DMRS DL PDSCH Mapping type A
3101  *
3102  * @params[in]
3103  * struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA *dmrsDlCfg
3104  * @return ROK     - success
3105  *         RFAILED - failure
3106  *
3107  * ****************************************************************/
3108    uint8_t BuildDMRSDLPdschMapTypeA
3109 (
3110  struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA *dmrsDlCfg
3111  )
3112 {
3113    dmrsDlCfg->present = PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA_PR_setup;
3114    dmrsDlCfg->choice.setup = NULLP;
3115    CU_ALLOC(dmrsDlCfg->choice.setup, sizeof(struct DMRS_DownlinkConfig));
3116    if(!dmrsDlCfg->choice.setup)
3117    {
3118       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
3119       return RFAILED;
3120    }
3121
3122    dmrsDlCfg->choice.setup->dmrs_Type = NULLP;
3123    dmrsDlCfg->choice.setup->dmrs_AdditionalPosition = NULLP;
3124    CU_ALLOC(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition, sizeof(long));
3125    if(!dmrsDlCfg->choice.setup->dmrs_AdditionalPosition)
3126    {
3127       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSDLPdschMapTypeA");
3128       return RFAILED;
3129    }
3130    *(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition) = DMRS_ADDITIONAL_POS;
3131
3132    dmrsDlCfg->choice.setup->maxLength = NULLP;
3133    dmrsDlCfg->choice.setup->scramblingID0 = NULLP;
3134    dmrsDlCfg->choice.setup->scramblingID1 = NULLP;
3135    dmrsDlCfg->choice.setup->phaseTrackingRS = NULLP;
3136
3137    return ROK;
3138 }
3139
3140 /*******************************************************************
3141  *
3142  * @brief Builds TCI states to add/modify list
3143  *
3144  * @details
3145  *
3146  *    Function : BuildTCIStatesToAddModList
3147  *
3148  *    Functionality:Builds TCI states to add/modify list
3149  *
3150  * @params[in]
3151  * struct PDSCH_Config__tci_StatesToAddModList *tciStatesList
3152  *
3153  * @return ROK     - success
3154  *         RFAILED - failure
3155  *
3156  * ****************************************************************/
3157 uint8_t BuildTCIStatesToAddModList(struct PDSCH_Config__tci_StatesToAddModList *tciStatesList)
3158 {
3159    return ROK;
3160 }
3161
3162 /*******************************************************************
3163  *
3164  * @brief Builds PDSCH time domain allocation list
3165  *
3166  * @details
3167  *
3168  *    Function : BuildPdschTimeDomAllocList
3169  *
3170  *    Functionality: Builds PDSCH time domain allocation list
3171  *
3172  * @params[in]
3173  * struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList
3174  *
3175  * @return ROK     - success
3176  *         RFAILED - failure
3177  *
3178  * ****************************************************************/
3179    uint8_t BuildPdschTimeDomAllocList
3180 (
3181  struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList
3182  )
3183 {
3184    uint8_t idx;
3185    uint8_t elementCnt;
3186    struct PDSCH_TimeDomainResourceAllocation *timeDomAlloc;
3187
3188    timeDomAllocList->present = \
3189                                PDSCH_Config__pdsch_TimeDomainAllocationList_PR_setup;
3190
3191    timeDomAllocList->choice.setup = NULLP;
3192    CU_ALLOC(timeDomAllocList->choice.setup, \
3193          sizeof(struct PDSCH_TimeDomainResourceAllocationList));
3194    if(!timeDomAllocList->choice.setup)
3195    {
3196       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
3197       return RFAILED;
3198    }
3199
3200    elementCnt = 2;
3201    timeDomAllocList->choice.setup->list.count = elementCnt;
3202    timeDomAllocList->choice.setup->list.size = \
3203                                                elementCnt * sizeof(struct PDSCH_TimeDomainResourceAllocation *);
3204
3205    timeDomAllocList->choice.setup->list.array = NULLP;
3206    CU_ALLOC(timeDomAllocList->choice.setup->list.array, \
3207          timeDomAllocList->choice.setup->list.size);
3208    if(!timeDomAllocList->choice.setup->list.array)
3209    {
3210       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
3211       return RFAILED;
3212    }
3213
3214    for(idx = 0; idx < elementCnt; idx++)
3215    {
3216       timeDomAllocList->choice.setup->list.array[idx] = NULLP;
3217       CU_ALLOC(timeDomAllocList->choice.setup->list.array[idx], \
3218             sizeof(struct PDSCH_TimeDomainResourceAllocation));
3219       if(!timeDomAllocList->choice.setup->list.array[idx])
3220       {
3221          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
3222          return RFAILED;
3223       }
3224    }
3225
3226    idx = 0;
3227    timeDomAlloc = timeDomAllocList->choice.setup->list.array[idx];
3228    CU_ALLOC(timeDomAlloc->k0, sizeof(long));
3229    if(!timeDomAlloc->k0)
3230    {
3231        DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
3232        return RFAILED;
3233    }
3234    *(timeDomAlloc->k0) = 0;
3235    timeDomAlloc->mappingType = PDSCH_MAPPING_TYPE_A;
3236    timeDomAlloc->startSymbolAndLength = 66;
3237
3238    idx++;
3239    timeDomAlloc = timeDomAllocList->choice.setup->list.array[idx];
3240    CU_ALLOC(timeDomAlloc->k0, sizeof(long));
3241    if(!timeDomAlloc->k0)
3242    {
3243       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
3244       return RFAILED;
3245    }
3246    *(timeDomAlloc->k0) = 1;
3247    timeDomAlloc->mappingType = PDSCH_MAPPING_TYPE_A;
3248    timeDomAlloc->startSymbolAndLength = 66;
3249
3250    return ROK;
3251 }
3252
3253 /*******************************************************************
3254  *
3255  * @brief Builds PDSCH PRB Bundling type
3256  *
3257  * @details
3258  *
3259  *    Function : BuildPdschPrbBundlingType
3260  *
3261  *    Functionality: Builds PDSCH PRB Bundling type
3262  *
3263  * @params[in]
3264  * struct PDSCH_Config__prb_BundlingType *prbBndlType
3265  *
3266  * @return ROK     - success
3267  *         RFAILED - failure
3268  *
3269  * ****************************************************************/
3270    uint8_t BuildPdschPrbBundlingType
3271 (
3272  struct PDSCH_Config__prb_BundlingType *prbBndlType
3273  )
3274 {
3275    prbBndlType->present = PDSCH_Config__prb_BundlingType_PR_staticBundling;
3276
3277    prbBndlType->choice.staticBundling = NULLP;
3278    CU_ALLOC(prbBndlType->choice.staticBundling, \
3279          sizeof(struct PDSCH_Config__prb_BundlingType__staticBundling));
3280    if(!prbBndlType->choice.staticBundling)
3281    {
3282       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschPrbBundlingType");
3283       return RFAILED;
3284    }
3285    prbBndlType->choice.staticBundling->bundleSize = NULLP;
3286
3287    return ROK;
3288 }
3289
3290 /*******************************************************************
3291  *
3292  * @brief Builds BWP DL dedicated PDSCH config
3293  *
3294  * @details
3295  *
3296  *    Function : BuildBWPDlDedPdschCfg
3297  *
3298  *    Functionality: Builds BWP DL dedicated PDSCH config
3299  *
3300  * @params[in] struct PDSCH_Config *pdschCfg
3301  *
3302  * @return ROK     - success
3303  *         RFAILED - failure
3304  *
3305  * ****************************************************************/
3306 uint8_t BuildBWPDlDedPdschCfg(struct PDSCH_Config *pdschCfg)
3307 {
3308    pdschCfg->dataScramblingIdentityPDSCH = NULLP;
3309
3310    pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA = NULLP;
3311    CU_ALLOC(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA, \
3312          sizeof(struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA));
3313    if(!pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA)
3314    {
3315       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
3316       return RFAILED;
3317    }
3318
3319    if(BuildDMRSDLPdschMapTypeA(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA) != ROK)
3320    {
3321       return RFAILED;
3322    }
3323
3324    pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeB = NULLP;
3325    pdschCfg->tci_StatesToAddModList = NULLP;
3326    pdschCfg->tci_StatesToReleaseList = NULLP;
3327    pdschCfg->vrb_ToPRB_Interleaver = NULLP;
3328 #if 0
3329    CU_ALLOC(pdschCfg->tci_StatesToAddModList, sizeof(struct PDSCH_Config__tci_StatesToAddModList));
3330    if(!pdschCfg->tci_StatesToAddModList)
3331    {
3332       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
3333       return RFAILED;
3334    }
3335    if(BuildTCIStatesToAddModList(pdschCfg->tci_StatesToAddModList) != ROK)
3336    {
3337       return RFAILED;
3338    }
3339 #endif
3340
3341    pdschCfg->resourceAllocation = RES_ALLOC_TYPE;
3342
3343    pdschCfg->pdsch_TimeDomainAllocationList = NULLP;
3344    CU_ALLOC(pdschCfg->pdsch_TimeDomainAllocationList, \
3345          sizeof(struct PDSCH_Config__pdsch_TimeDomainAllocationList));
3346    if(!pdschCfg->pdsch_TimeDomainAllocationList)
3347    {
3348       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
3349       return RFAILED;
3350    }
3351    if(BuildPdschTimeDomAllocList(pdschCfg->pdsch_TimeDomainAllocationList) != ROK)
3352    {
3353       return RFAILED;
3354    }
3355    pdschCfg->pdsch_AggregationFactor = NULLP;
3356    pdschCfg->rateMatchPatternToAddModList = NULLP;
3357    pdschCfg->rateMatchPatternToReleaseList = NULLP;
3358    pdschCfg->rateMatchPatternGroup1 = NULLP;
3359    pdschCfg->rateMatchPatternGroup2 = NULLP;
3360    pdschCfg->rbg_Size = PDSCH_RBG_SIZE;
3361    pdschCfg->mcs_Table = NULLP;
3362
3363    pdschCfg->maxNrofCodeWordsScheduledByDCI = NULLP;
3364    CU_ALLOC(pdschCfg->maxNrofCodeWordsScheduledByDCI, sizeof(long));
3365    if(!pdschCfg->maxNrofCodeWordsScheduledByDCI)
3366    {
3367       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
3368       return RFAILED;
3369    }
3370    *(pdschCfg->maxNrofCodeWordsScheduledByDCI) = PDSCH_MAX_CODEWORD_SCH_BY_DCI;
3371
3372    if(BuildPdschPrbBundlingType(&pdschCfg->prb_BundlingType) != ROK)
3373    {
3374       return RFAILED;
3375    }
3376
3377    pdschCfg->zp_CSI_RS_ResourceToAddModList = NULLP;
3378    pdschCfg->zp_CSI_RS_ResourceToReleaseList = NULLP;
3379    pdschCfg->aperiodic_ZP_CSI_RS_ResourceSetsToAddModList = NULLP;
3380    pdschCfg->aperiodic_ZP_CSI_RS_ResourceSetsToReleaseList = NULLP;
3381    pdschCfg->sp_ZP_CSI_RS_ResourceSetsToAddModList = NULLP;
3382    pdschCfg->sp_ZP_CSI_RS_ResourceSetsToReleaseList = NULLP;
3383    pdschCfg->p_ZP_CSI_RS_ResourceSet = NULLP;
3384
3385    return ROK;
3386 }
3387
3388 /*******************************************************************
3389  *
3390  * @brief Builds intitial DL BWP
3391  * @details
3392  *
3393  *    Function : BuildInitialDlBWP
3394  *
3395  *    Functionality: Builds intitial DL BWP in spCellCfgDed
3396  *
3397  * @params[in] BWP_DownlinkDedicated_t *dlBwp
3398  *
3399  * @return ROK     - success
3400  *         RFAILED - failure
3401  *
3402  * ****************************************************************/
3403 uint8_t BuildInitialDlBWP(BWP_DownlinkDedicated_t *dlBwp)
3404 {
3405    dlBwp->pdcch_Config = NULLP;
3406    CU_ALLOC(dlBwp->pdcch_Config, sizeof(struct BWP_DownlinkDedicated__pdcch_Config));
3407    if(!dlBwp->pdcch_Config)
3408    {
3409       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failure in BuildInitialDlBWP");
3410       return RFAILED;
3411    }
3412    dlBwp->pdcch_Config->present = BWP_DownlinkDedicated__pdcch_Config_PR_setup;
3413
3414    dlBwp->pdcch_Config->choice.setup = NULLP;
3415    CU_ALLOC(dlBwp->pdcch_Config->choice.setup, sizeof(struct PDCCH_Config));
3416    if(!dlBwp->pdcch_Config->choice.setup)
3417    {
3418       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failure in BuildInitialDlBWP");
3419       return RFAILED;
3420    }
3421    if(BuildBWPDlDedPdcchCfg(dlBwp->pdcch_Config->choice.setup) != ROK)
3422    {
3423       return RFAILED;
3424    }
3425
3426    dlBwp->pdsch_Config = NULLP;
3427    CU_ALLOC(dlBwp->pdsch_Config, sizeof(struct BWP_DownlinkDedicated__pdsch_Config));
3428    if(!dlBwp->pdsch_Config)
3429    {
3430       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failure in BuildInitialDlBWP");
3431       return RFAILED;
3432    }
3433    dlBwp->pdsch_Config->present = BWP_DownlinkDedicated__pdsch_Config_PR_setup;
3434
3435    dlBwp->pdsch_Config->choice.setup = NULLP;
3436    CU_ALLOC(dlBwp->pdsch_Config->choice.setup, sizeof(struct PDSCH_Config));
3437    if(!dlBwp->pdsch_Config->choice.setup)
3438    {
3439       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failure in BuildInitialDlBWP");
3440       return RFAILED;
3441    }
3442
3443    if(BuildBWPDlDedPdschCfg(dlBwp->pdsch_Config->choice.setup) != ROK)
3444    {
3445       return RFAILED;
3446    }
3447
3448    dlBwp->sps_Config = NULLP;
3449    dlBwp->radioLinkMonitoringConfig = NULLP;
3450    return ROK;
3451 }
3452
3453 /*******************************************************************
3454  *
3455  * @brief Builds DMRS UL Pusch Mapping type A
3456  *
3457  * @details
3458  *
3459  *    Function : BuildDMRSULPuschMapTypeA
3460  *
3461  *    Functionality: Builds DMRS UL Pusch Mapping type A
3462  *
3463  * @params[in]
3464  *    struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA *dmrsUlCfg
3465  * @return ROK     - success
3466  *         RFAILED - failure
3467  *
3468  * ****************************************************************/
3469    uint8_t BuildDMRSULPuschMapTypeA
3470 (
3471  struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA *dmrsUlCfg
3472  )
3473 {
3474    dmrsUlCfg->present = PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA_PR_setup;
3475    dmrsUlCfg->choice.setup= NULLP;
3476    CU_ALLOC(dmrsUlCfg->choice.setup, sizeof(DMRS_UplinkConfig_t));
3477    if(!dmrsUlCfg->choice.setup)
3478    {
3479       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
3480       return RFAILED;
3481    }
3482
3483    dmrsUlCfg->choice.setup->dmrs_Type = NULLP;
3484    dmrsUlCfg->choice.setup->dmrs_AdditionalPosition = NULLP;
3485    CU_ALLOC(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition, sizeof(long));
3486    if(!dmrsUlCfg->choice.setup->dmrs_AdditionalPosition)
3487    {
3488       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
3489       return RFAILED;
3490    }
3491    *(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition) = DMRS_ADDITIONAL_POS;
3492
3493    dmrsUlCfg->choice.setup->phaseTrackingRS = NULLP;
3494    dmrsUlCfg->choice.setup->maxLength = NULLP;
3495    dmrsUlCfg->choice.setup->transformPrecodingDisabled = NULLP;
3496    CU_ALLOC(dmrsUlCfg->choice.setup->transformPrecodingDisabled, \
3497          sizeof(struct DMRS_UplinkConfig__transformPrecodingDisabled));
3498    if(!dmrsUlCfg->choice.setup->transformPrecodingDisabled)
3499    {
3500       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
3501       return RFAILED;
3502    }
3503
3504    dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0 = NULLP;
3505    CU_ALLOC(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0,\
3506          sizeof(long));
3507    if(!dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0)
3508    {
3509       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
3510       return RFAILED;
3511    }
3512    *(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0) = SCRAMBLING_ID;
3513
3514    dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID1 = NULLP;
3515    dmrsUlCfg->choice.setup->transformPrecodingEnabled = NULLP;
3516    return ROK;
3517 }
3518
3519 /*******************************************************************
3520  *
3521  * @brief Build PUSCH time domain allocation list
3522  *
3523  * @details
3524  *
3525  *    Function : BuildPuschTimeDomAllocList
3526  *
3527  *    Functionality: Build PUSCH time domain allocation list
3528  *
3529  * @params[in]
3530  * struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList
3531  *
3532  * @return ROK     - success
3533  *         RFAILED - failure
3534  *
3535  * ****************************************************************/
3536    uint8_t BuildPuschTimeDomAllocList
3537 (
3538  struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList
3539  )
3540 {
3541    uint8_t idx;
3542    uint8_t elementCnt;
3543    PUSCH_TimeDomainResourceAllocation_t  *timeDomAlloc;
3544
3545    timeDomAllocList->present = PUSCH_Config__pusch_TimeDomainAllocationList_PR_setup;
3546    timeDomAllocList->choice.setup = NULLP;
3547    CU_ALLOC(timeDomAllocList->choice.setup, \
3548          sizeof(struct PUSCH_TimeDomainResourceAllocationList));
3549    if(!timeDomAllocList->choice.setup)
3550    {
3551       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
3552       return RFAILED;
3553    }
3554
3555    elementCnt = 2;
3556    timeDomAllocList->choice.setup->list.count = elementCnt;
3557    timeDomAllocList->choice.setup->list.size = \
3558                                                elementCnt * sizeof(PUSCH_TimeDomainResourceAllocation_t *);
3559    timeDomAllocList->choice.setup->list.array = NULLP;
3560    CU_ALLOC(timeDomAllocList->choice.setup->list.array, \
3561          timeDomAllocList->choice.setup->list.size);
3562    if(!timeDomAllocList->choice.setup->list.array)
3563    {
3564       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
3565       return RFAILED;
3566    }
3567
3568    for(idx = 0; idx < elementCnt; idx++)
3569    {
3570       timeDomAllocList->choice.setup->list.array[idx] = NULLP;
3571       CU_ALLOC(timeDomAllocList->choice.setup->list.array[idx],\
3572             sizeof(PUSCH_TimeDomainResourceAllocation_t));
3573       if(!timeDomAllocList->choice.setup->list.array[idx])
3574       {
3575          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
3576          return RFAILED;
3577       }
3578    }
3579
3580    idx = 0;
3581    timeDomAlloc = timeDomAllocList->choice.setup->list.array[idx];
3582    CU_ALLOC(timeDomAlloc->k2, sizeof(long));
3583    if(!timeDomAlloc->k2)
3584    {
3585       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
3586       return RFAILED;
3587    }
3588    *(timeDomAlloc->k2) = PUSCH_K2_CFG1;
3589    timeDomAlloc->mappingType = PUSCH_MAPPING_TYPE_A;
3590    timeDomAlloc->startSymbolAndLength = 66;
3591
3592    idx++;
3593    timeDomAlloc = timeDomAllocList->choice.setup->list.array[idx];
3594    CU_ALLOC(timeDomAlloc->k2, sizeof(long));
3595    if(!timeDomAlloc->k2)
3596    {
3597        DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
3598        return RFAILED;
3599    }
3600    *(timeDomAlloc->k2) = PUSCH_K2_CFG2;
3601    timeDomAlloc->mappingType = PUSCH_MAPPING_TYPE_A;
3602    timeDomAlloc->startSymbolAndLength = 66;
3603
3604    return ROK;
3605 }
3606
3607 /*******************************************************************
3608  *
3609  * @brief Builds BWP UL dedicated PUSCH Config
3610  *
3611  * @details
3612  *
3613  *    Function : BuildBWPUlDedPuschCfg
3614  *
3615  *    Functionality:
3616  *      Builds BWP UL dedicated PUSCH Config
3617  *
3618  * @params[in] : PUSCH_Config_t *puschCfg
3619  *
3620  * @return ROK     - success
3621  *         RFAILED - failure
3622  *
3623  * ****************************************************************/
3624 uint8_t BuildBWPUlDedPuschCfg(PUSCH_Config_t *puschCfg)
3625 {
3626    puschCfg->dataScramblingIdentityPUSCH = NULLP;
3627    CU_ALLOC(puschCfg->dataScramblingIdentityPUSCH, sizeof(long));
3628    if(!puschCfg->dataScramblingIdentityPUSCH)
3629    {
3630       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
3631       return RFAILED;
3632    }
3633    *(puschCfg->dataScramblingIdentityPUSCH) = SCRAMBLING_ID;
3634
3635    puschCfg->txConfig = NULLP;
3636    puschCfg->dmrs_UplinkForPUSCH_MappingTypeA = NULLP;
3637    CU_ALLOC(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA, \
3638          sizeof(struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA));
3639    if(!puschCfg->dmrs_UplinkForPUSCH_MappingTypeA)
3640    {
3641       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
3642       return RFAILED;
3643    }
3644
3645    if(BuildDMRSULPuschMapTypeA(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA) != ROK)
3646    {
3647       return RFAILED;
3648    }
3649
3650    puschCfg->dmrs_UplinkForPUSCH_MappingTypeB = NULLP;
3651    puschCfg->pusch_PowerControl = NULLP;
3652    puschCfg->frequencyHopping = NULLP;
3653    puschCfg->frequencyHoppingOffsetLists = NULLP;
3654    puschCfg->resourceAllocation = RES_ALLOC_TYPE;
3655
3656    puschCfg->pusch_TimeDomainAllocationList = NULLP;
3657    CU_ALLOC(puschCfg->pusch_TimeDomainAllocationList, \
3658          sizeof(struct PUSCH_Config__pusch_TimeDomainAllocationList));
3659    if(!puschCfg->pusch_TimeDomainAllocationList)
3660    {
3661       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
3662       return RFAILED;
3663    }
3664
3665    if(BuildPuschTimeDomAllocList(puschCfg->pusch_TimeDomainAllocationList) != ROK)
3666    {
3667       return RFAILED;
3668    }
3669
3670    puschCfg->pusch_AggregationFactor = NULLP;
3671    puschCfg->mcs_Table = NULLP;
3672    puschCfg->mcs_TableTransformPrecoder = NULLP;
3673    puschCfg->transformPrecoder = NULLP;
3674    CU_ALLOC(puschCfg->transformPrecoder, sizeof(long));
3675    if(!puschCfg->transformPrecoder)
3676    {
3677       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
3678       return RFAILED;
3679    }
3680    *(puschCfg->transformPrecoder) = PUSCH_TRANSFORM_PRECODER;
3681
3682    puschCfg->codebookSubset = NULLP;
3683    puschCfg->maxRank = NULLP;
3684    puschCfg->rbg_Size = NULLP;
3685    puschCfg->uci_OnPUSCH = NULLP;
3686    puschCfg->tp_pi2BPSK = NULLP;
3687
3688    return ROK;
3689 }
3690
3691 /*******************************************************************
3692  *
3693  * @brief Builds BWP UL dedicated PUCCH Config
3694  *
3695  * @details
3696  *
3697  *    Function : BuildBWPUlDedPucchCfg
3698  *
3699  *    Functionality:
3700  *      Builds BWP UL dedicated PUCCH Config
3701  *
3702  * @params[in] : PUCCH_Config_t *pucchCfg
3703  *
3704  * @return ROK     - success
3705  *         RFAILED - failure
3706  *
3707  * ****************************************************************/
3708 uint8_t BuildBWPUlDedPucchCfg(PUCCH_Config_t *pucchCfg)
3709 {
3710    uint8_t arrIdx, elementCnt;
3711
3712    CU_ALLOC(pucchCfg->dl_DataToUL_ACK, sizeof(struct PUCCH_Config__dl_DataToUL_ACK));
3713    if(pucchCfg->dl_DataToUL_ACK == NULLP)
3714    {
3715       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
3716       return RFAILED;
3717    }
3718
3719    elementCnt = 2;
3720    pucchCfg->dl_DataToUL_ACK->list.count = elementCnt;
3721    pucchCfg->dl_DataToUL_ACK->list.size = elementCnt * sizeof(long *);
3722    CU_ALLOC(pucchCfg->dl_DataToUL_ACK->list.array, pucchCfg->dl_DataToUL_ACK->list.size);
3723    if(pucchCfg->dl_DataToUL_ACK->list.array == NULLP)
3724    {
3725       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
3726       return RFAILED;
3727    }
3728
3729    for(arrIdx = 0; arrIdx <  pucchCfg->dl_DataToUL_ACK->list.count; arrIdx++)
3730    {
3731       CU_ALLOC(pucchCfg->dl_DataToUL_ACK->list.array[arrIdx], sizeof(long));
3732       if(pucchCfg->dl_DataToUL_ACK->list.array[arrIdx] == NULLP)
3733       {
3734           DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
3735           return RFAILED;
3736       }
3737    }
3738
3739    arrIdx = 0;
3740    *(pucchCfg->dl_DataToUL_ACK->list.array[arrIdx++]) = 1;
3741    *(pucchCfg->dl_DataToUL_ACK->list.array[arrIdx]) = 2;
3742
3743    return ROK;
3744 }
3745
3746 /*******************************************************************
3747  *
3748  * @brief Fills SRS resource to add/modify list
3749  *
3750  * @details
3751  *
3752  *    Function : BuildSrsRsrcAddModList
3753  *
3754  *    Functionality: Fills SRS resource to add/modify list
3755  *
3756  * @params[in]
3757  * @return ROK     - success
3758  *         RFAILED - failure
3759  *
3760  * ****************************************************************/
3761 uint8_t BuildSrsRsrcAddModList(struct SRS_Config__srs_ResourceToAddModList *resourceList)
3762 {
3763    uint8_t   elementCnt;
3764    uint8_t   rsrcIdx;
3765
3766    elementCnt = 1;
3767    resourceList->list.count = elementCnt;
3768    resourceList->list.size = elementCnt * sizeof(SRS_Resource_t *);
3769    resourceList->list.array = NULLP;
3770    CU_ALLOC(resourceList->list.array, resourceList->list.size);
3771    if(!resourceList->list.array)
3772    {
3773       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed in BuildSrsRsrcAddModList");
3774       return RFAILED;
3775    }
3776
3777    for(rsrcIdx = 0; rsrcIdx < resourceList->list.count; rsrcIdx++)
3778    {
3779       CU_ALLOC(resourceList->list.array[rsrcIdx], sizeof(SRS_Resource_t));
3780       if(!resourceList->list.array[rsrcIdx])
3781       {
3782          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed in BuildSrsRsrcAddModList");
3783          return RFAILED;
3784       }
3785    }
3786
3787    rsrcIdx = 0;
3788    resourceList->list.array[rsrcIdx]->srs_ResourceId = SRS_RSRC_ID;
3789    resourceList->list.array[rsrcIdx]->nrofSRS_Ports = SRS_Resource__nrofSRS_Ports_port1;
3790    resourceList->list.array[rsrcIdx]->transmissionComb.present = SRS_Resource__transmissionComb_PR_n2;
3791
3792    resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2 = NULLP;
3793    CU_ALLOC(resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2, \
3794          sizeof(struct SRS_Resource__transmissionComb__n2));
3795    if(!resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2)
3796    {
3797       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed in BuildSrsRsrcAddModList");
3798       return RFAILED;
3799    }
3800    resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2->combOffset_n2\
3801       = SRS_COMB_OFFSET_N2;
3802    resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2->cyclicShift_n2\
3803       = SRS_CYCLIC_SHIFT_N2;
3804
3805    resourceList->list.array[rsrcIdx]->resourceMapping.startPosition = \
3806                                                                       0;
3807    resourceList->list.array[rsrcIdx]->resourceMapping.nrofSymbols =  \
3808                                                                      SRS_Resource__resourceMapping__nrofSymbols_n1;
3809    resourceList->list.array[rsrcIdx]->resourceMapping.repetitionFactor = \
3810                                                                          SRS_Resource__resourceMapping__repetitionFactor_n1;
3811
3812    resourceList->list.array[rsrcIdx]->freqDomainPosition = SRS_FREQ_DOM_POS;
3813    resourceList->list.array[rsrcIdx]->freqDomainShift = SRS_FREQ_DOM_SHIFT;
3814    resourceList->list.array[rsrcIdx]->freqHopping.c_SRS = C_SRS;
3815    resourceList->list.array[rsrcIdx]->freqHopping.b_SRS = B_SRS;
3816    resourceList->list.array[rsrcIdx]->freqHopping.b_hop = B_HOP;
3817    resourceList->list.array[rsrcIdx]->groupOrSequenceHopping = \
3818                                                                SRS_Resource__groupOrSequenceHopping_neither;
3819
3820    /* Setting resource type to aperiodic for intergration purposes */
3821    resourceList->list.array[rsrcIdx]->resourceType.present = \
3822                                                              SRS_Resource__resourceType_PR_aperiodic;
3823    resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic = NULLP;
3824    CU_ALLOC(resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic,
3825          sizeof(struct SRS_Resource__resourceType__aperiodic));
3826    if(!resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic)
3827    {
3828       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed in BuildSrsRsrcAddModList");
3829       return RFAILED;
3830    }
3831    resourceList->list.array[rsrcIdx]->sequenceId = SRS_SEQ_ID;
3832
3833    return ROK;
3834 }
3835
3836 /*******************************************************************
3837  *
3838  * @brief Build SRS resource set Add/mod list
3839  *
3840  * @details
3841  *
3842  *    Function : BuildSrsRsrcSetAddModList
3843  *
3844  *    Functionality: Build SRS resource set Add/mod list
3845  *
3846  * @params[in]
3847  * @return ROK     - success
3848  *         RFAILED - failure
3849  *
3850  * ****************************************************************/
3851    uint8_t BuildSrsRsrcSetAddModList
3852 (
3853  struct SRS_Config__srs_ResourceSetToAddModList *rsrcSetList
3854  )
3855 {
3856    uint8_t  elementCnt;
3857    uint8_t  rSetIdx;
3858    uint8_t  rsrcIdx;
3859    struct SRS_ResourceSet__srs_ResourceIdList *rsrcIdList;
3860
3861    elementCnt = 1;
3862    rsrcSetList->list.count = elementCnt;
3863    rsrcSetList->list.size = elementCnt * sizeof(SRS_ResourceSet_t *);
3864    rsrcSetList->list.array = NULLP;
3865    CU_ALLOC(rsrcSetList->list.array, rsrcSetList->list.size);
3866    if(!rsrcSetList->list.array)
3867    {
3868       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed in BuildSrsRsrcSetAddModList");
3869       return RFAILED;
3870    }
3871
3872    for(rSetIdx = 0; rSetIdx < rsrcSetList->list.count; rSetIdx++)
3873    {
3874       CU_ALLOC(rsrcSetList->list.array[rSetIdx], sizeof(SRS_ResourceSet_t));
3875       if(!rsrcSetList->list.array[rSetIdx])
3876       {
3877          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed in BuildSrsRsrcSetAddModList");
3878          return RFAILED;
3879       }
3880    }
3881
3882    rSetIdx = 0;
3883    rsrcSetList->list.array[rSetIdx]->srs_ResourceSetId = SRS_RSET_ID;
3884
3885    /* Fill Resource Id list in resource set */
3886    rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList = NULLP;
3887    CU_ALLOC(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList,\
3888          sizeof(struct SRS_ResourceSet__srs_ResourceIdList));
3889    if(!rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList)
3890    {
3891       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
3892       return RFAILED;
3893    }
3894
3895    elementCnt = 1;
3896    rsrcIdList = rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList;
3897    rsrcIdList->list.count = elementCnt;
3898    rsrcIdList->list.size = elementCnt * sizeof(SRS_ResourceId_t *);
3899    rsrcIdList->list.array = NULLP;
3900    CU_ALLOC(rsrcIdList->list.array, rsrcIdList->list.size);
3901    if(!rsrcIdList->list.array)
3902    {
3903       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed in BuildSrsRsrcSetAddModList");
3904       return RFAILED;
3905    }
3906
3907    for(rsrcIdx = 0; rsrcIdx < rsrcIdList->list.count; rsrcIdx++)
3908    {
3909       CU_ALLOC(rsrcIdList->list.array[rsrcIdx], sizeof(SRS_ResourceId_t));
3910       if(!rsrcIdList->list.array[rsrcIdx])
3911       {
3912          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed in BuildSrsRsrcSetAddModList");
3913          return RFAILED;
3914       }
3915    }
3916
3917    rsrcIdx = 0;
3918    *rsrcIdList->list.array[rsrcIdx] = SRS_RSRC_ID;
3919
3920    /* Fill resource type */
3921    rsrcSetList->list.array[rSetIdx]->resourceType.present = \
3922                                                             SRS_ResourceSet__resourceType_PR_aperiodic;
3923
3924    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic = NULLP;
3925    CU_ALLOC(rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic, \
3926          sizeof(struct SRS_ResourceSet__resourceType__aperiodic));
3927    if(!rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic)
3928    {
3929       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed in BuildSrsRsrcSetAddModList");
3930       return RFAILED;
3931    }
3932    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic->aperiodicSRS_ResourceTrigger \
3933       = APERIODIC_SRS_RESRC_TRIGGER;
3934
3935    /* TODO : Fill values for below IEs as expected by Viavi */
3936    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic->csi_RS = NULLP;
3937    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic->slotOffset = NULLP;
3938
3939
3940    rsrcSetList->list.array[rSetIdx]->usage = SRS_ResourceSet__usage_codebook;
3941    rsrcSetList->list.array[rSetIdx]->alpha = NULLP;
3942    rsrcSetList->list.array[rSetIdx]->p0 = NULLP;
3943    rsrcSetList->list.array[rSetIdx]->pathlossReferenceRS = NULLP;
3944    rsrcSetList->list.array[rSetIdx]->srs_PowerControlAdjustmentStates = NULLP;
3945
3946    return ROK;
3947 }
3948
3949 /*******************************************************************
3950  *
3951  * @brief Builds BWP UL dedicated SRS Config
3952  *
3953  * @details
3954  *
3955  *    Function : BuildBWPUlDedSrsCfg
3956  *
3957  *    Functionality: Builds BWP UL dedicated SRS Config
3958  *
3959  * @params[in] SRS Config
3960  * @return ROK     - success
3961  *         RFAILED - failure
3962  *
3963  * ****************************************************************/
3964 uint8_t BuildBWPUlDedSrsCfg(SRS_Config_t *srsCfg)
3965 {
3966    srsCfg->srs_ResourceSetToReleaseList = NULLP;
3967    srsCfg->srs_ResourceSetToAddModList = NULLP;
3968    CU_ALLOC(srsCfg->srs_ResourceSetToAddModList, \
3969          sizeof(struct SRS_Config__srs_ResourceSetToAddModList));
3970    if(!srsCfg->srs_ResourceSetToAddModList)
3971    {
3972       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed in BuildBWPUlDedSrsCfg");
3973       return RFAILED;
3974    }
3975    if(BuildSrsRsrcSetAddModList(srsCfg->srs_ResourceSetToAddModList) != ROK)
3976    {
3977       return RFAILED;
3978    }
3979
3980    srsCfg->srs_ResourceToReleaseList = NULLP;
3981
3982    /* Resource to Add/Modify list */
3983    srsCfg->srs_ResourceToAddModList = NULLP;
3984    CU_ALLOC(srsCfg->srs_ResourceToAddModList, \
3985          sizeof(struct SRS_Config__srs_ResourceToAddModList));
3986    if(!srsCfg->srs_ResourceToAddModList)
3987    {
3988       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed in BuildBWPUlDedSrsCfg");
3989       return RFAILED;
3990    }
3991
3992    if(BuildSrsRsrcAddModList(srsCfg->srs_ResourceToAddModList) != ROK)
3993    {
3994       return RFAILED;
3995    }
3996
3997    srsCfg->tpc_Accumulation = NULLP;
3998
3999    return ROK;
4000 }
4001
4002 /*******************************************************************
4003  *
4004  * @brief Builds inital UL BWP
4005  *
4006  * @details
4007  *
4008  *    Function : BuildInitialUlBWP
4009  *
4010  *    Functionality: Builds initial UL BWP
4011  *
4012  * @params[in] BWP_UplinkDedicated_t *ulBwp
4013  * @return ROK     - success
4014  *         RFAILED - failure
4015  *
4016  * ****************************************************************/
4017 uint8_t BuildInitialUlBWP(BWP_UplinkDedicated_t *ulBwp)
4018 {
4019    ulBwp->pucch_Config = NULLP;
4020    ulBwp->pucch_Config = NULLP;
4021    CU_ALLOC(ulBwp->pucch_Config, sizeof(struct BWP_UplinkDedicated__pucch_Config));
4022    if(!ulBwp->pucch_Config)
4023    {
4024       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
4025       return RFAILED;
4026    }
4027
4028    ulBwp->pucch_Config->present = BWP_UplinkDedicated__pucch_Config_PR_setup;
4029    ulBwp->pucch_Config->choice.setup = NULLP;
4030    CU_ALLOC(ulBwp->pucch_Config->choice.setup, sizeof(PUCCH_Config_t));
4031    if(!ulBwp->pucch_Config->choice.setup)
4032    {
4033       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
4034       return RFAILED;
4035    }
4036
4037    if(BuildBWPUlDedPucchCfg(ulBwp->pucch_Config->choice.setup) != ROK)
4038    {
4039       return RFAILED;
4040    }
4041
4042    /* Fill BWP UL dedicated PUSCH config */
4043    ulBwp->pusch_Config = NULLP;
4044    CU_ALLOC(ulBwp->pusch_Config, sizeof(struct BWP_UplinkDedicated__pusch_Config));
4045    if(!ulBwp->pusch_Config)
4046    {
4047       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
4048       return RFAILED;
4049    }
4050
4051    ulBwp->pusch_Config->present = BWP_UplinkDedicated__pusch_Config_PR_setup;
4052    ulBwp->pusch_Config->choice.setup = NULLP;
4053    CU_ALLOC(ulBwp->pusch_Config->choice.setup, sizeof(PUSCH_Config_t));
4054    if(!ulBwp->pusch_Config->choice.setup)
4055    {
4056       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
4057       return RFAILED;
4058    }
4059
4060    if(BuildBWPUlDedPuschCfg(ulBwp->pusch_Config->choice.setup) != ROK)
4061    {
4062       return RFAILED;
4063    }
4064
4065    ulBwp->configuredGrantConfig = NULLP;
4066
4067    /* Fill BPW UL dedicated SRS config */
4068    ulBwp->srs_Config = NULLP;
4069    CU_ALLOC(ulBwp->srs_Config, sizeof(struct BWP_UplinkDedicated__srs_Config));
4070    if(!ulBwp->srs_Config)
4071    {
4072       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
4073       return RFAILED;
4074    }
4075
4076    ulBwp->srs_Config->present = BWP_UplinkDedicated__srs_Config_PR_setup;
4077    ulBwp->srs_Config->choice.setup = NULLP;
4078    CU_ALLOC(ulBwp->srs_Config->choice.setup, sizeof(SRS_Config_t));
4079    if(!ulBwp->srs_Config->choice.setup)
4080    {
4081       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
4082       return RFAILED;
4083    }
4084
4085    if(BuildBWPUlDedSrsCfg(ulBwp->srs_Config->choice.setup) != ROK)
4086    {
4087       return RFAILED;
4088    }
4089
4090    ulBwp->beamFailureRecoveryConfig = NULLP;
4091
4092    return ROK;
4093 }
4094
4095 /*******************************************************************
4096  *
4097  * @brief Builds Pusch Serving cell Config
4098  *
4099  * @details
4100  *
4101  *    Function : BuildPuschSrvCellCfg
4102  *
4103  *    Functionality: Builds Pusch Serving cell Config
4104  *
4105  * @params[in] struct UplinkConfig__pusch_ServingCellConfig *puschCfg
4106  *
4107  * @return ROK     - success
4108  *         RFAILED - failure
4109  *
4110  * ****************************************************************/
4111 uint8_t BuildPuschSrvCellCfg(struct UplinkConfig__pusch_ServingCellConfig *puschCfg)
4112 {
4113    puschCfg->present = UplinkConfig__pusch_ServingCellConfig_PR_setup;
4114    puschCfg->choice.setup = NULLP;
4115    CU_ALLOC(puschCfg->choice.setup, sizeof(struct PUSCH_ServingCellConfig));
4116    if(!puschCfg->choice.setup)
4117    {
4118       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
4119       return RFAILED;
4120    }
4121
4122    puschCfg->choice.setup->codeBlockGroupTransmission = NULLP;
4123    puschCfg->choice.setup->rateMatching = NULLP;
4124    puschCfg->choice.setup->xOverhead = NULLP;
4125    puschCfg->choice.setup->ext1 = NULLP;
4126    CU_ALLOC(puschCfg->choice.setup->ext1, sizeof(struct PUSCH_ServingCellConfig__ext1));
4127    if(!puschCfg->choice.setup->ext1)
4128    {
4129       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
4130       return RFAILED;
4131    }
4132
4133    puschCfg->choice.setup->ext1->maxMIMO_Layers = NULLP;
4134    CU_ALLOC(puschCfg->choice.setup->ext1->maxMIMO_Layers, sizeof(long));
4135    if(!puschCfg->choice.setup->ext1->maxMIMO_Layers)
4136    {
4137       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
4138       return RFAILED;
4139    }
4140    *(puschCfg->choice.setup->ext1->maxMIMO_Layers) = PUSCH_MAX_MIMO_LAYERS;
4141
4142    puschCfg->choice.setup->ext1->processingType2Enabled= NULLP;
4143    CU_ALLOC(puschCfg->choice.setup->ext1->processingType2Enabled,sizeof(BOOLEAN_t));
4144    if(!puschCfg->choice.setup->ext1->processingType2Enabled)
4145    {
4146       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
4147       return RFAILED;
4148    }
4149    *(puschCfg->choice.setup->ext1->processingType2Enabled) = PUSCH_PROCESS_TYPE2_ENABLED;
4150    return ROK;
4151 }
4152
4153 /*******************************************************************
4154  *
4155  * @brief Builds UL config
4156  * @details
4157  *
4158  *    Function : BuildUlCfg
4159  *
4160  *    Functionality: Builds UL config in spCellCfgDed
4161  *
4162  * @params[in] UplinkConfig_t *ulCfg
4163  *
4164  * @return ROK     - success
4165  *         RFAILED - failure
4166  *
4167  * ****************************************************************/
4168 uint8_t BuildUlCfg(UplinkConfig_t *ulCfg)
4169 {
4170    ulCfg->initialUplinkBWP = NULLP;
4171    CU_ALLOC(ulCfg->initialUplinkBWP, sizeof(BWP_UplinkDedicated_t));
4172    if(!ulCfg->initialUplinkBWP)
4173    {
4174       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failed in BuildUlCfg");
4175       return RFAILED;
4176    }
4177
4178    if(BuildInitialUlBWP(ulCfg->initialUplinkBWP) != ROK)
4179    {
4180       return RFAILED;
4181    }
4182
4183    ulCfg->uplinkBWP_ToReleaseList = NULLP;
4184    ulCfg->uplinkBWP_ToAddModList = NULLP;
4185    ulCfg->firstActiveUplinkBWP_Id = NULLP;
4186    CU_ALLOC(ulCfg->firstActiveUplinkBWP_Id, sizeof(BWP_Id_t));
4187    if(!ulCfg->firstActiveUplinkBWP_Id)
4188    {
4189       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failed in BuildUlCfg");
4190       return RFAILED;
4191    }
4192    *(ulCfg->firstActiveUplinkBWP_Id) = ACTIVE_UL_BWP_ID;
4193
4194    ulCfg->pusch_ServingCellConfig = NULLP;
4195    CU_ALLOC(ulCfg->pusch_ServingCellConfig, \
4196          sizeof(struct UplinkConfig__pusch_ServingCellConfig));
4197    if(!ulCfg->pusch_ServingCellConfig)
4198    {
4199       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failed in BuildUlCfg");
4200       return RFAILED;
4201    }
4202
4203    if(BuildPuschSrvCellCfg(ulCfg->pusch_ServingCellConfig) != ROK)
4204    {
4205       return RFAILED;
4206    }
4207
4208    ulCfg->carrierSwitching = NULLP;
4209    ulCfg->ext1 = NULLP;
4210    return ROK;
4211 }
4212
4213 /*******************************************************************
4214  *
4215  * @brief Builds PDSCH serving cell config
4216  * @details
4217  *
4218  *    Function : BuildPdschSrvCellCfg
4219  *
4220  *    Functionality: Builds PDSCH serving cell config in spCellCfgDed
4221  *
4222  * @params[in] struct ServingCellConfig__pdsch_ServingCellConfig *pdschCfg
4223  *
4224  * @return ROK     - success
4225  *         RFAILED - failure
4226  *
4227  * ****************************************************************/
4228 uint8_t BuildPdschSrvCellCfg(struct ServingCellConfig__pdsch_ServingCellConfig *pdschCfg)
4229 {
4230    pdschCfg->present =  ServingCellConfig__pdsch_ServingCellConfig_PR_setup;
4231    pdschCfg->choice.setup = NULLP;
4232    CU_ALLOC(pdschCfg->choice.setup, sizeof( struct PDSCH_ServingCellConfig));
4233    if(!pdschCfg->choice.setup)
4234    {
4235       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschSrvCellCfg");
4236       return RFAILED;
4237    }
4238
4239    pdschCfg->choice.setup->codeBlockGroupTransmission = NULLP;
4240    pdschCfg->choice.setup->xOverhead = NULLP;
4241    pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH = NULLP;
4242    CU_ALLOC(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH, sizeof(long));
4243    if(!pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH)
4244    {
4245       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschSrvCellCfg");
4246       return RFAILED;
4247    }
4248    *(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH)= PDSCH_NUM_HARQ_PROC;
4249    pdschCfg->choice.setup->pucch_Cell = NULLP;
4250    pdschCfg->choice.setup->ext1 = NULLP;
4251
4252    return ROK;
4253 }
4254
4255 /*******************************************************************
4256  *
4257  * @brief Builds CSI Meas config
4258  * @details
4259  *
4260  *    Function : BuildCsiMeasCfg
4261  *
4262  *    Functionality: Builds CSI Meas config in spCellCfgDed
4263  *
4264  * @params[in] struct ServingCellConfig__csi_MeasConfig *csiMeasCfg
4265  *
4266  * @return ROK     - success
4267  *         RFAILED - failure
4268  *
4269  * ****************************************************************/
4270 uint8_t BuildCsiMeasCfg(struct ServingCellConfig__csi_MeasConfig *csiMeasCfg)
4271 {
4272
4273    return ROK;
4274 }
4275
4276 /*******************************************************************
4277  *
4278  * @brief Builds Spcell config dedicated
4279  * @details
4280  *
4281  *    Function : BuildSpCellCfgDed
4282  *
4283  *    Functionality: Builds sp cell config dedicated in spCellCfg
4284  *
4285  * @params[in] ServingCellConfig_t srvCellCfg
4286  *
4287  * @return ROK     - success
4288  *         RFAILED - failure
4289  *
4290  * ****************************************************************/
4291 uint8_t BuildSpCellCfgDed(ServingCellConfig_t *srvCellCfg)
4292 {
4293    srvCellCfg->tdd_UL_DL_ConfigurationDedicated = NULLP;
4294
4295    srvCellCfg->initialDownlinkBWP = NULLP;
4296    CU_ALLOC(srvCellCfg->initialDownlinkBWP, sizeof(BWP_DownlinkDedicated_t));
4297    if(!srvCellCfg->initialDownlinkBWP)
4298    {
4299       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
4300       return RFAILED;
4301    }
4302
4303    if(BuildInitialDlBWP(srvCellCfg->initialDownlinkBWP) != ROK)
4304    {
4305       DU_LOG("\nERROR  -->  F1AP : BuildInitialDlBWP failed");
4306       return RFAILED;
4307    }
4308    srvCellCfg->downlinkBWP_ToReleaseList = NULLP;
4309    srvCellCfg->downlinkBWP_ToAddModList = NULLP;
4310
4311    srvCellCfg->firstActiveDownlinkBWP_Id = NULLP;
4312    CU_ALLOC(srvCellCfg->firstActiveDownlinkBWP_Id, sizeof(long));
4313    if(!srvCellCfg->firstActiveDownlinkBWP_Id)
4314    {
4315       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
4316       return RFAILED;
4317    }
4318    *(srvCellCfg->firstActiveDownlinkBWP_Id) = ACTIVE_DL_BWP_ID;
4319
4320    srvCellCfg->bwp_InactivityTimer = NULLP;
4321
4322    srvCellCfg->defaultDownlinkBWP_Id = NULLP;
4323    CU_ALLOC(srvCellCfg->defaultDownlinkBWP_Id, sizeof(long));
4324    if(!srvCellCfg->defaultDownlinkBWP_Id)
4325    {
4326       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
4327       return RFAILED;
4328    }
4329    *(srvCellCfg->defaultDownlinkBWP_Id) = ACTIVE_DL_BWP_ID;
4330
4331    srvCellCfg->uplinkConfig = NULLP;
4332    CU_ALLOC(srvCellCfg->uplinkConfig, sizeof(UplinkConfig_t));
4333    if(!srvCellCfg->uplinkConfig)
4334    {
4335       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
4336       return RFAILED;
4337    }
4338
4339    if(BuildUlCfg(srvCellCfg->uplinkConfig) != ROK)
4340    {
4341       DU_LOG("\nERROR  -->  F1AP : BuildUlCfg failed");
4342       return RFAILED;
4343    }
4344    srvCellCfg->supplementaryUplink = NULLP;
4345    srvCellCfg->pdcch_ServingCellConfig = NULLP;
4346
4347    srvCellCfg->pdsch_ServingCellConfig = NULLP;
4348    CU_ALLOC(srvCellCfg->pdsch_ServingCellConfig, sizeof(struct  ServingCellConfig__pdsch_ServingCellConfig));
4349    if(!srvCellCfg->pdsch_ServingCellConfig)
4350    {
4351       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
4352       return RFAILED;
4353    }
4354
4355    if(BuildPdschSrvCellCfg(srvCellCfg->pdsch_ServingCellConfig) != ROK)
4356    {
4357       DU_LOG("\nERROR  -->  F1AP : BuildPdschSrvCellCfg failed");
4358       return RFAILED;
4359    }
4360
4361    srvCellCfg->csi_MeasConfig = NULLP;
4362 #if 0
4363    CU_ALLOC(srvCellCfg->csi_MeasConfig, sizeof(struct   ServingCellConfig__csi_MeasConfig))
4364       if(!srvCellCfg->csi_MeasConfig)
4365       {
4366          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
4367          return RFAILED;
4368       }
4369
4370    if(BuildCsiMeasCfg(srvCellCfg->csi_MeasConfig) != ROK)
4371    {
4372       DU_LOG("\nF1AP : BuildCsiMeasCfg failed");
4373       return RFAILED;
4374    }
4375 #endif
4376    srvCellCfg->sCellDeactivationTimer = NULLP;
4377    srvCellCfg->crossCarrierSchedulingConfig = NULLP;
4378    srvCellCfg->tag_Id = TAG_ID;
4379    srvCellCfg->dummy = NULLP;
4380    srvCellCfg->pathlossReferenceLinking = NULLP;
4381    srvCellCfg->servingCellMO = NULLP;
4382    srvCellCfg->ext1 = NULLP;
4383
4384    return ROK;
4385 }
4386 /*******************************************************************
4387  *
4388  * @brief Builds Spcell config
4389  *
4390  * @details
4391  *
4392  *    Function : BuildSpCellCfg
4393  *
4394  *    Functionality: Builds sp cell config in DuToCuRrcContainer
4395  *
4396  * @params[in] SpCellConfig_t spCellCfg
4397  *
4398  * @return ROK     - success
4399  *         RFAILED - failure
4400  *
4401  * ****************************************************************/
4402 uint8_t BuildSpCellCfg(SpCellConfig_t *spCellCfg)
4403 {
4404
4405    spCellCfg->servCellIndex = NULLP;
4406    CU_ALLOC(spCellCfg->servCellIndex, sizeof(long));
4407    if(!spCellCfg->servCellIndex)
4408    {
4409       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfg");
4410       return RFAILED;
4411    }
4412    *(spCellCfg->servCellIndex) = SERV_CELL_IDX;
4413
4414    spCellCfg->reconfigurationWithSync = NULLP;
4415    spCellCfg->rlf_TimersAndConstants = NULLP;
4416    spCellCfg->rlmInSyncOutOfSyncThreshold = NULLP;
4417    CU_ALLOC(spCellCfg->rlmInSyncOutOfSyncThreshold, sizeof(long));
4418    if(!spCellCfg->rlmInSyncOutOfSyncThreshold)
4419    {
4420       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfg");
4421       return RFAILED;
4422    }
4423    *(spCellCfg->rlmInSyncOutOfSyncThreshold) = RLM_SYNC_OUT_SYNC_THRESHOLD;
4424
4425    spCellCfg->spCellConfigDedicated = NULLP;
4426    CU_ALLOC(spCellCfg->spCellConfigDedicated, sizeof(ServingCellConfig_t));
4427    if(!spCellCfg->spCellConfigDedicated)
4428    {
4429       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfg");
4430       return RFAILED;
4431    }
4432    if(BuildSpCellCfgDed(spCellCfg->spCellConfigDedicated) != ROK)
4433    {
4434       DU_LOG("\nERROR  -->  F1AP : BuildSpCellCfgDed failed");
4435       return RFAILED;
4436    }
4437    return ROK;
4438 }
4439 /*******************************************************************
4440  *
4441  * @brief Builds Phy cell group config
4442  *
4443  * @details
4444  *
4445  *    Function : BuildPhyCellGrpCfg
4446  *
4447  *    Functionality: Builds Phy cell group config in DuToCuRrcContainer
4448  *
4449  * @params[in] PhysicalCellGroupConfig_t *phyCellGrpCfg
4450  *
4451  * @return ROK     - success
4452  *         RFAILED - failure
4453  *
4454  * ****************************************************************/
4455 uint8_t BuildPhyCellGrpCfg(PhysicalCellGroupConfig_t *phyCellGrpCfg)
4456 {
4457    phyCellGrpCfg->harq_ACK_SpatialBundlingPUCCH = NULLP;
4458    phyCellGrpCfg->harq_ACK_SpatialBundlingPUSCH = NULLP;
4459
4460    phyCellGrpCfg->p_NR_FR1 = NULLP;
4461    CU_ALLOC(phyCellGrpCfg->p_NR_FR1, sizeof(long));
4462    if(!phyCellGrpCfg->p_NR_FR1)
4463    {
4464       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildPhyCellGrpCfg");
4465       return RFAILED;
4466    }
4467    *(phyCellGrpCfg->p_NR_FR1)             = P_NR_FR1;
4468    phyCellGrpCfg->pdsch_HARQ_ACK_Codebook = PDSCH_HARQ_ACK_CODEBOOK;
4469    phyCellGrpCfg->tpc_SRS_RNTI = NULLP;
4470    phyCellGrpCfg->tpc_PUCCH_RNTI = NULLP;
4471    phyCellGrpCfg->tpc_PUSCH_RNTI = NULLP;
4472    phyCellGrpCfg->sp_CSI_RNTI = NULLP;
4473    phyCellGrpCfg->cs_RNTI = NULLP;
4474    phyCellGrpCfg->ext1 = NULLP;
4475    phyCellGrpCfg->ext2 = NULLP;
4476
4477    return ROK;
4478 }
4479
4480 /*******************************************************************
4481  *
4482  * @brief Builds tag config
4483  *
4484  * @details
4485  *
4486  *    Function : BuildTagConfig
4487  *
4488  *    Functionality: Builds tag config in MacCellGroupConfig
4489  *
4490  * @params[in] TAG_Config *tag_Config
4491  *
4492  * @return ROK     - success
4493  *         RFAILED - failure
4494  *
4495  * ****************************************************************/
4496 uint8_t BuildTagConfig(struct TAG_Config *tagConfig)
4497 {
4498    struct TAG_Config__tag_ToAddModList *tagList;
4499    uint8_t                     idx, elementCnt;
4500
4501    tagConfig->tag_ToReleaseList = NULLP;
4502    tagConfig->tag_ToAddModList = NULLP;
4503    CU_ALLOC(tagConfig->tag_ToAddModList, sizeof(struct TAG_Config__tag_ToAddModList));
4504    if(!tagConfig->tag_ToAddModList)
4505    {
4506       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildTagConfig");
4507       return RFAILED;
4508    }
4509
4510    elementCnt = 1; //ODU_VALUE_ONE;
4511    tagList = tagConfig->tag_ToAddModList;
4512    tagList->list.count = elementCnt;
4513    tagList->list.size  =  elementCnt * sizeof(struct TAG *);
4514
4515    tagList->list.array = NULLP;
4516    CU_ALLOC(tagList->list.array, tagList->list.size);
4517    if(!tagList->list.array)
4518    {
4519       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildTagConfig");
4520       return RFAILED;
4521    }
4522
4523    for(idx=0; idx<tagList->list.count; idx++)
4524    {
4525       tagList->list.array[idx] = NULLP;
4526       CU_ALLOC(tagList->list.array[idx], sizeof(struct TAG));
4527       if(!tagList->list.array[idx])
4528       {
4529          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildTagConfig");
4530          return RFAILED;
4531       }
4532    }
4533
4534    idx = 0;
4535    tagList->list.array[idx]->tag_Id = TAG_ID;
4536    tagList->list.array[idx]->timeAlignmentTimer = TIME_ALIGNMENT_TMR;
4537
4538    return ROK;
4539 }
4540
4541 /*******************************************************************
4542  *
4543  * @brief Builds PHR Config
4544  *
4545  * @details
4546  *
4547  *    Function : BuildPhrConfig
4548  *
4549  *    Functionality: Builds phrConfig in MacCellGroupConfig
4550  *
4551  * @params[in] PHR Config *
4552  *
4553  * @return ROK     - success
4554  *         RFAILED - failure
4555  *
4556  * ****************************************************************/
4557 uint8_t BuildPhrConfig(struct MAC_CellGroupConfig__phr_Config *phrConfig)
4558 {
4559
4560    phrConfig->present = MAC_CellGroupConfig__phr_Config_PR_setup;
4561    phrConfig->choice.setup = NULLP;
4562    CU_ALLOC(phrConfig->choice.setup, sizeof(struct PHR_Config));
4563    if(!phrConfig->choice.setup)
4564    {
4565       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildPhrConfig");
4566       return RFAILED;
4567    }
4568
4569    phrConfig->choice.setup->phr_PeriodicTimer        = PHR_PERIODIC_TMR;
4570    phrConfig->choice.setup->phr_ProhibitTimer        = PHR_PROHIBHIT_TMR;
4571    phrConfig->choice.setup->phr_Tx_PowerFactorChange = PHR_PWR_FACTOR_CHANGE;
4572    phrConfig->choice.setup->multiplePHR              = false;
4573    phrConfig->choice.setup->dummy                    = false;
4574    phrConfig->choice.setup->phr_Type2OtherCell       = false;
4575    phrConfig->choice.setup->phr_ModeOtherCG          = PHR_MODE_OTHER_CG;
4576
4577    return ROK;
4578 }
4579
4580 /*******************************************************************
4581  *
4582  * @brief Builds BSR Config
4583  *
4584  * @details
4585  *
4586  *    Function : BuildBsrConfig
4587  *
4588  *    Functionality: Builds BuildBsrConfig in MacCellGroupConfig
4589  *
4590  * @params[in] BSR_Config *bsrConfig
4591  *
4592  * @return ROK     - success
4593  *         RFAILED - failure
4594  *
4595  * ****************************************************************/
4596 uint8_t BuildBsrConfig(struct BSR_Config *bsrConfig)
4597 {
4598    bsrConfig->periodicBSR_Timer = PERIODIC_BSR_TMR;
4599    bsrConfig->retxBSR_Timer     = RETX_BSR_TMR;
4600    bsrConfig->logicalChannelSR_DelayTimer = NULLP;
4601
4602    return ROK;
4603 }
4604
4605 /*******************************************************************
4606  *
4607  * @brief Builds scheduling request config
4608  *
4609  * @details
4610  *
4611  *    Function : BuildSchedulingReqConfig
4612  *
4613  *    Functionality: Builds BuildSchedulingReqConfig in MacCellGroupConfig
4614  *
4615  * @params[in] SchedulingRequestConfig *schedulingRequestConfig
4616  *
4617  * @return ROK     - success
4618  *         RFAILED - failure
4619  *
4620  * ****************************************************************/
4621 uint8_t BuildSchedulingReqConfig(struct SchedulingRequestConfig *schedulingRequestConfig)
4622 {
4623    struct SchedulingRequestConfig__schedulingRequestToAddModList *schReqList;
4624    uint8_t                     idx, elementCnt;
4625
4626    schedulingRequestConfig->schedulingRequestToAddModList = NULLP;
4627    CU_ALLOC(schedulingRequestConfig->schedulingRequestToAddModList,
4628          sizeof(struct SchedulingRequestConfig__schedulingRequestToAddModList));
4629    if(!schedulingRequestConfig->schedulingRequestToAddModList)
4630    {
4631       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSchedulingReqConfig");
4632       return RFAILED;
4633    }
4634
4635    elementCnt = 1; //ODU_VALUE_ONE;
4636    schReqList = schedulingRequestConfig->schedulingRequestToAddModList;
4637    schReqList->list.count = elementCnt;
4638    schReqList->list.size  = elementCnt * sizeof(struct SchedulingRequestToAddMod *);
4639
4640    schReqList->list.array = NULLP;
4641    CU_ALLOC(schReqList->list.array, schReqList->list.size);
4642    if(!schReqList->list.array)
4643    {
4644       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSchedulingReqConfig");
4645       return RFAILED;
4646    }
4647
4648    for(idx=0;idx<schReqList->list.count; idx++)
4649    {
4650       schReqList->list.array[idx] = NULLP;
4651       CU_ALLOC(schReqList->list.array[idx], sizeof(struct SchedulingRequestToAddMod));
4652       if(!schReqList->list.array[idx])
4653       {
4654          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSchedulingReqConfig");
4655          return RFAILED;
4656       }
4657    }
4658
4659    idx = 0;
4660    schReqList->list.array[idx]->schedulingRequestId = SCH_REQ_ID;
4661
4662    schReqList->list.array[idx]->sr_ProhibitTimer = NULLP;
4663    CU_ALLOC(schReqList->list.array[idx]->sr_ProhibitTimer, sizeof(long));
4664    if(!schReqList->list.array[idx]->sr_ProhibitTimer)
4665    {
4666       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSchedulingReqConfig");
4667       return RFAILED;
4668    }
4669    *(schReqList->list.array[idx]->sr_ProhibitTimer) = SR_PROHIBIT_TMR;
4670    schReqList->list.array[idx]->sr_TransMax = SR_TRANS_MAX;
4671    schedulingRequestConfig->schedulingRequestToReleaseList = NULLP;
4672
4673    return ROK;
4674 }
4675 /*******************************************************************
4676  *
4677  * @brief Builds Mac cell group config
4678  *
4679  * @details
4680  *
4681  *    Function : BuildMacCellGrpCfg
4682  *
4683  *    Functionality: Builds Mac cell group config in DuToCuRrcContainer
4684  *
4685  * @params[in] MAC_CellGroupConfig_t *macCellGrpCfg
4686  *
4687  * @return ROK     - success
4688  *         RFAILED - failure
4689  *
4690  * ****************************************************************/
4691 uint8_t BuildMacCellGrpCfg(MAC_CellGroupConfig_t *macCellGrpCfg)
4692 {
4693    macCellGrpCfg->drx_Config = NULLP;
4694    macCellGrpCfg->schedulingRequestConfig = NULLP;
4695    CU_ALLOC(macCellGrpCfg->schedulingRequestConfig, sizeof(struct SchedulingRequestConfig));
4696    if(!macCellGrpCfg->schedulingRequestConfig)
4697    {
4698       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacCellGrpCfg");
4699       return RFAILED;
4700    }
4701
4702    if(BuildSchedulingReqConfig(macCellGrpCfg->schedulingRequestConfig) != ROK)
4703    {
4704       DU_LOG("\nERROR  -->  F1AP : BuildSchedulingReqConfig failed");
4705       return RFAILED;
4706    }
4707
4708    macCellGrpCfg->bsr_Config = NULLP;
4709    CU_ALLOC(macCellGrpCfg->bsr_Config, sizeof(struct BSR_Config));
4710    if(!macCellGrpCfg->bsr_Config)
4711    {
4712       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacCellGrpCfg");
4713       return RFAILED;
4714    }
4715
4716    if(BuildBsrConfig(macCellGrpCfg->bsr_Config) != ROK)
4717    {
4718       DU_LOG("\nERROR  -->  F1AP : BuildBsrConfig failed");
4719       return RFAILED;
4720    }
4721
4722    macCellGrpCfg->tag_Config = NULLP;
4723    CU_ALLOC(macCellGrpCfg->tag_Config, sizeof(struct TAG_Config));
4724    if(!macCellGrpCfg->tag_Config)
4725    {
4726       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacCellGrpCfg");
4727       return RFAILED;
4728    }
4729
4730    if(BuildTagConfig(macCellGrpCfg->tag_Config) != ROK)
4731    {
4732       DU_LOG("\nERROR  -->  F1AP : BuildTagConfig failed");
4733       return RFAILED;
4734    }
4735
4736    macCellGrpCfg->phr_Config = NULLP;
4737    CU_ALLOC(macCellGrpCfg->phr_Config, sizeof(struct MAC_CellGroupConfig__phr_Config));
4738    if(!macCellGrpCfg->phr_Config)
4739    {
4740       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacCellGrpCfg");
4741       return RFAILED;
4742    }
4743
4744    if(BuildPhrConfig(macCellGrpCfg->phr_Config) != ROK)
4745    {
4746       DU_LOG("\nERROR  -->  F1AP : BuildPhrConfig failed");
4747       return RFAILED;
4748    }
4749
4750    macCellGrpCfg->skipUplinkTxDynamic = false;
4751    macCellGrpCfg->ext1 = NULLP;
4752
4753    return ROK;
4754 }
4755 /*******************************************************************
4756  *
4757  * @brief Frees memeory allocated for SearchSpcToAddModList
4758  *
4759  * @details
4760  *
4761  *    Function : FreeSearchSpcToAddModList
4762  *
4763  *    Functionality: Deallocating memory of SearchSpcToAddModList
4764  *
4765  * @params[in] struct PDCCH_Config__searchSpacesToAddModList *searchSpcList
4766  *
4767  * @return void
4768  *
4769  4221 * ****************************************************************/
4770 void FreeSearchSpcToAddModList(struct PDCCH_Config__searchSpacesToAddModList *searchSpcList)
4771 {
4772    uint8_t idx1=0;
4773    uint8_t idx2=0;
4774    struct  SearchSpace *searchSpc=NULLP;
4775
4776    if(searchSpcList->list.array)
4777    {
4778       if(searchSpcList->list.array[idx2])
4779       {
4780          searchSpc = searchSpcList->list.array[idx2];
4781          if(searchSpc->controlResourceSetId)
4782          {
4783             if(searchSpc->monitoringSlotPeriodicityAndOffset)
4784             {
4785                if(searchSpc->monitoringSymbolsWithinSlot)
4786                {
4787                   if(searchSpc->monitoringSymbolsWithinSlot->buf)
4788                   {
4789                      if(searchSpc->nrofCandidates)
4790                      {
4791                         if(searchSpc->searchSpaceType)
4792                         {
4793                            CU_FREE(searchSpc->searchSpaceType->choice.ue_Specific,\
4794                                  sizeof(struct SearchSpace__searchSpaceType__ue_Specific));
4795                            CU_FREE(searchSpc->searchSpaceType, sizeof(struct
4796                                     SearchSpace__searchSpaceType));
4797                         }
4798                         CU_FREE(searchSpc->nrofCandidates,
4799                               sizeof(struct SearchSpace__nrofCandidates));
4800                      }
4801                      CU_FREE(searchSpc->monitoringSymbolsWithinSlot->buf, \
4802                            searchSpc->monitoringSymbolsWithinSlot->size);
4803                   }
4804                   CU_FREE(searchSpc->monitoringSymbolsWithinSlot,
4805                         sizeof(BIT_STRING_t));
4806                }
4807                CU_FREE(searchSpc->monitoringSlotPeriodicityAndOffset, \
4808                      sizeof(struct SearchSpace__monitoringSlotPeriodicityAndOffset));
4809             }
4810             CU_FREE(searchSpc->controlResourceSetId,
4811                   sizeof(ControlResourceSetId_t));
4812          }
4813       }
4814       for(idx1 = 0; idx1 < searchSpcList->list.count; idx1++)
4815       {
4816          CU_FREE(searchSpcList->list.array[idx1],
4817                sizeof(struct SearchSpace));
4818       }
4819       CU_FREE(searchSpcList->list.array,searchSpcList->list.size);
4820    }
4821 }
4822 /*******************************************************************
4823  *
4824  * @brief Frees memory allocated for PdschTimeDomAllocList
4825  *
4826  * @details
4827  *
4828  *    Function : FreePdschTimeDomAllocList
4829  *
4830  *    Functionality: Deallocating memory of PdschTimeDomAllocList
4831  *
4832  * @params[in] struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList
4833  *
4834  * @return void
4835  *
4836  4221 * ****************************************************************/
4837 void FreePdschTimeDomAllocList( struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList)
4838 {
4839    uint8_t idx1=0;
4840
4841    if(timeDomAllocList->choice.setup)
4842    {
4843       if(timeDomAllocList->choice.setup->list.array)
4844       {
4845          for(idx1 = 0; idx1 <timeDomAllocList->choice.setup->list.count ; idx1++)
4846          {
4847             CU_FREE(timeDomAllocList->choice.setup->list.array[idx1],
4848                   sizeof(struct PDSCH_TimeDomainResourceAllocation));
4849          }
4850          CU_FREE(timeDomAllocList->choice.setup->list.array, \
4851                timeDomAllocList->choice.setup->list.size);
4852       }
4853       CU_FREE(timeDomAllocList->choice.setup,\
4854             sizeof(struct PDSCH_TimeDomainResourceAllocationList));
4855    }
4856 }
4857 /*******************************************************************
4858  *
4859  * @brief Frees memory allocated for PuschTimeDomAllocList
4860  *
4861  *@details
4862  *
4863  *    Function : FreePuschTimeDomAllocList
4864  *
4865  *    Functionality: Deallocating memory of PuschTimeDomAllocList
4866  *
4867  * @params[in] PUSCH_Config_t *puschCfg
4868  *
4869  * @return void
4870  *
4871  ***********************************************************************/
4872 void FreePuschTimeDomAllocList(PUSCH_Config_t *puschCfg)
4873 {
4874    uint8_t idx1=0;
4875    uint8_t idx2=0;
4876    struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList_t=NULLP;
4877
4878    if(puschCfg->pusch_TimeDomainAllocationList)
4879    {
4880       timeDomAllocList_t=puschCfg->pusch_TimeDomainAllocationList;
4881       if(timeDomAllocList_t->choice.setup)
4882       {
4883          if(timeDomAllocList_t->choice.setup->list.array)
4884          {
4885             CU_FREE(timeDomAllocList_t->choice.setup->list.array[idx2]->k2, sizeof(long));
4886             for(idx1 = 0; idx1<timeDomAllocList_t->choice.setup->list.count; idx1++)
4887             {
4888                CU_FREE(timeDomAllocList_t->choice.setup->list.array[idx1],\
4889                      sizeof(PUSCH_TimeDomainResourceAllocation_t));
4890             }
4891             CU_FREE(timeDomAllocList_t->choice.setup->list.array, \
4892                   timeDomAllocList_t->choice.setup->list.size);
4893          }
4894          CU_FREE(timeDomAllocList_t->choice.setup, \
4895                sizeof(struct PUSCH_TimeDomainResourceAllocationList));
4896       }
4897       CU_FREE(puschCfg->transformPrecoder, sizeof(long));
4898       CU_FREE(puschCfg->pusch_TimeDomainAllocationList, \
4899             sizeof(struct PUSCH_Config__pusch_TimeDomainAllocationList));
4900    }
4901
4902 }
4903 /*******************************************************************
4904  *
4905  * @brief Frees memory allocated for InitialUlBWP
4906  *
4907  * @details
4908  *
4909  *    Function : FreeInitialUlBWP
4910  *
4911  *    Functionality: Deallocating memory of InitialUlBWP
4912  *
4913  * @params[in] BWP_UplinkDedicated_t *ulBwp
4914  *
4915  * @return void
4916  *
4917  * ****************************************************************/
4918 void FreeInitialUlBWP(BWP_UplinkDedicated_t *ulBwp)
4919 {
4920    uint8_t  rSetIdx, rsrcIdx;
4921    SRS_Config_t   *srsCfg = NULLP;
4922    PUSCH_Config_t *puschCfg = NULLP;
4923    struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA *dmrsUlCfg = NULLP;
4924    struct SRS_Config__srs_ResourceSetToAddModList *rsrcSetList = NULLP;
4925    struct SRS_ResourceSet__srs_ResourceIdList *rsrcIdList = NULLP;
4926    struct SRS_Config__srs_ResourceToAddModList *resourceList = NULLP;
4927
4928    if(ulBwp->pusch_Config)
4929    {
4930       if(ulBwp->pusch_Config->choice.setup)
4931       {
4932          puschCfg=ulBwp->pusch_Config->choice.setup;
4933          if(puschCfg->dataScramblingIdentityPUSCH)
4934          {
4935             if(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA)
4936             {
4937                FreePuschTimeDomAllocList(puschCfg);
4938                dmrsUlCfg=puschCfg->dmrs_UplinkForPUSCH_MappingTypeA;
4939                if(dmrsUlCfg->choice.setup)
4940                {
4941                   if(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition)
4942                   {
4943                      if(dmrsUlCfg->choice.setup->transformPrecodingDisabled)
4944                      {
4945                         CU_FREE(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0,\
4946                               sizeof(long));
4947                         CU_FREE(dmrsUlCfg->choice.setup->transformPrecodingDisabled,
4948                               sizeof(struct DMRS_UplinkConfig__transformPrecodingDisabled));
4949                      }
4950                      CU_FREE(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition,
4951                            sizeof(long));
4952                   }
4953                   CU_FREE(dmrsUlCfg->choice.setup,sizeof(DMRS_UplinkConfig_t));
4954                }
4955                CU_FREE(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA, \
4956                      sizeof(struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA));
4957             }
4958             CU_FREE(puschCfg->dataScramblingIdentityPUSCH, sizeof(long));
4959          }
4960          CU_FREE(ulBwp->pusch_Config->choice.setup, sizeof(PUSCH_Config_t));
4961       }
4962       CU_FREE(ulBwp->pusch_Config, sizeof(struct BWP_UplinkDedicated__pusch_Config));
4963
4964       /* Free SRS-Config */
4965       if(ulBwp->srs_Config)
4966       {
4967          if(ulBwp->srs_Config->choice.setup)
4968          {
4969             srsCfg = ulBwp->srs_Config->choice.setup;
4970
4971             /* Free Resource Set to add/mod list */
4972             if(srsCfg->srs_ResourceSetToAddModList)
4973             {
4974                rsrcSetList = srsCfg->srs_ResourceSetToAddModList;
4975                if(rsrcSetList->list.array)
4976                {
4977                   rSetIdx = 0;
4978
4979                   /* Free SRS resource Id list in this SRS resource set */
4980                   if(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList)
4981                   {
4982                      rsrcIdList = rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList;
4983
4984                      if(rsrcIdList->list.array)
4985                      {
4986                         for(rsrcIdx = 0; rsrcIdx < rsrcIdList->list.count; rsrcIdx++)
4987                         {
4988                            CU_FREE(rsrcIdList->list.array[rsrcIdx], sizeof(SRS_ResourceId_t));
4989                         }
4990                         CU_FREE(rsrcIdList->list.array, rsrcIdList->list.size);
4991                      }
4992                      CU_FREE(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList,\
4993                            sizeof(struct SRS_ResourceSet__srs_ResourceIdList));
4994                   }
4995
4996                   /* Free resource type info for this SRS resource set */
4997                   CU_FREE(rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic, \
4998                         sizeof(struct SRS_ResourceSet__resourceType__aperiodic));
4999
5000                   /* Free memory for each resource set */
5001                   for(rSetIdx = 0; rSetIdx < rsrcSetList->list.count; rSetIdx++)
5002                   {
5003                      CU_FREE(rsrcSetList->list.array[rSetIdx], sizeof(SRS_ResourceSet_t));
5004                   }
5005                   CU_FREE(rsrcSetList->list.array, rsrcSetList->list.size);
5006                }
5007                CU_FREE(srsCfg->srs_ResourceSetToAddModList, \
5008                      sizeof(struct SRS_Config__srs_ResourceSetToAddModList));
5009             }
5010
5011             /* Free resource to add/modd list */
5012             if(srsCfg->srs_ResourceToAddModList)
5013             {
5014                resourceList = srsCfg->srs_ResourceToAddModList;
5015                if(resourceList->list.array)
5016                {
5017                   rsrcIdx = 0;
5018                   CU_FREE(resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2,\
5019                         sizeof(struct SRS_Resource__transmissionComb__n2));
5020                   CU_FREE(resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic,\
5021                         sizeof(struct SRS_Resource__resourceType__aperiodic));
5022
5023                   for(rsrcIdx = 0; rsrcIdx < resourceList->list.count; rsrcIdx++)
5024                   {
5025                      CU_FREE(resourceList->list.array[rsrcIdx], sizeof(SRS_Resource_t));
5026                   }
5027                   CU_FREE(resourceList->list.array, resourceList->list.size);
5028                }
5029                CU_FREE(srsCfg->srs_ResourceToAddModList, \
5030                      sizeof(struct SRS_Config__srs_ResourceToAddModList));
5031             }
5032
5033             CU_FREE(ulBwp->srs_Config->choice.setup, sizeof(SRS_Config_t));
5034          }
5035          CU_FREE(ulBwp->srs_Config, sizeof(struct BWP_UplinkDedicated__srs_Config));
5036       }
5037    }
5038 }
5039 /*******************************************************************
5040  *
5041  * @brief Frees memory allocated for initialUplinkBWP
5042  *
5043  * @details
5044  *
5045  *    Function : FreeinitialUplinkBWP
5046  *
5047  *    Functionality: Deallocating memory of initialUplinkBWP
5048  *
5049  * @params[in] UplinkConfig_t *ulCfg
5050  *
5051  * @return void
5052  *
5053  *
5054  * ****************************************************************/
5055 void FreeinitialUplinkBWP(UplinkConfig_t *ulCfg)
5056 {
5057    BWP_UplinkDedicated_t *ulBwp=NULLP;
5058    struct UplinkConfig__pusch_ServingCellConfig *puschCfg=NULLP;
5059
5060    if(ulCfg->initialUplinkBWP)
5061    {
5062       ulBwp=ulCfg->initialUplinkBWP;
5063       if(ulCfg->firstActiveUplinkBWP_Id)
5064       {
5065          if(ulCfg->pusch_ServingCellConfig)
5066          {
5067             puschCfg=ulCfg->pusch_ServingCellConfig;
5068             if(puschCfg->choice.setup)
5069             {
5070                if(puschCfg->choice.setup->ext1)
5071                {
5072                   CU_FREE(puschCfg->choice.setup->ext1->\
5073                         processingType2Enabled,sizeof(BOOLEAN_t));
5074                   CU_FREE(puschCfg->choice.setup->ext1->\
5075                         maxMIMO_Layers,sizeof(long));
5076                   CU_FREE(puschCfg->choice.setup->ext1, \
5077                         sizeof(struct PUSCH_ServingCellConfig__ext1));
5078                }
5079                CU_FREE(puschCfg->choice.setup, sizeof(struct PUSCH_ServingCellConfig));
5080             }
5081             CU_FREE(ulCfg->pusch_ServingCellConfig, sizeof(struct UplinkConfig__pusch_ServingCellConfig));
5082          }
5083          CU_FREE(ulCfg->firstActiveUplinkBWP_Id, sizeof(BWP_Id_t));
5084       }
5085       FreeInitialUlBWP(ulBwp);
5086       CU_FREE(ulCfg->initialUplinkBWP, sizeof(BWP_UplinkDedicated_t));
5087    }
5088 }
5089 /*******************************************************************
5090  *
5091  * @brief Frees emmory allocated for BWPDlDedPdschCfg
5092  *
5093  * @details
5094  *
5095  *    Function : FreeBWPDlDedPdschCfg
5096  *
5097  *    Functionality: Deallocating memory of BWPDlDedPdschCfg
5098  *
5099  * @params[in] BWP_DownlinkDedicated_t *dlBwp
5100  *
5101  * @return void
5102  *
5103  *
5104  * ****************************************************************/
5105 void FreeBWPDlDedPdschCfg(BWP_DownlinkDedicated_t *dlBwp)
5106 {
5107    struct PDSCH_Config *pdschCfg=NULLP;
5108    struct PDSCH_Config__prb_BundlingType *prbBndlType=NULLP;
5109    struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList=NULLP;
5110    struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA *dmrsDlCfg=NULLP;
5111
5112    if(dlBwp->pdsch_Config->choice.setup)
5113    {
5114       pdschCfg=dlBwp->pdsch_Config->choice.setup;
5115       if(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA)
5116       {
5117          if(pdschCfg->pdsch_TimeDomainAllocationList)
5118          {
5119             timeDomAllocList=pdschCfg->pdsch_TimeDomainAllocationList;
5120             if(pdschCfg->maxNrofCodeWordsScheduledByDCI)
5121             {
5122                prbBndlType=&pdschCfg->prb_BundlingType;
5123                CU_FREE(prbBndlType->choice.staticBundling,\
5124                      sizeof(struct PDSCH_Config__prb_BundlingType__staticBundling));
5125                CU_FREE(pdschCfg->maxNrofCodeWordsScheduledByDCI, sizeof(long));
5126             }
5127             FreePdschTimeDomAllocList(timeDomAllocList);
5128             CU_FREE(pdschCfg->pdsch_TimeDomainAllocationList, \
5129                   sizeof(struct PDSCH_Config__pdsch_TimeDomainAllocationList));
5130          }
5131          dmrsDlCfg=pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA;
5132          if(dmrsDlCfg->choice.setup)
5133          {
5134             CU_FREE(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition,
5135                   sizeof(long));
5136             CU_FREE(dmrsDlCfg->choice.setup, sizeof(struct DMRS_DownlinkConfig));
5137          }
5138          CU_FREE(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA, \
5139                sizeof(struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA));
5140       }
5141       CU_FREE(dlBwp->pdsch_Config->choice.setup, sizeof(struct PDSCH_Config));
5142    }
5143 }
5144 /*******************************************************************
5145  *
5146  * @brief Frees emmory allocated for BWPDlDedPdcchCfg
5147  *
5148  * @details
5149  *
5150  *    Function : FreeBWPDlDedPdcchCfg
5151  *
5152  *    Functionality: Deallocating memory of BWPDlDedPdcchCfg
5153  *
5154  * @params[in] BWP_DownlinkDedicated_t *dlBwp
5155  *
5156  * @return void
5157  *
5158  *
5159  * ****************************************************************/
5160 void FreeBWPDlDedPdcchCfg(BWP_DownlinkDedicated_t *dlBwp)
5161 {
5162    uint8_t idx1=0;
5163    uint8_t idx2=0;
5164    struct PDCCH_Config *pdcchCfg=NULLP;
5165    struct ControlResourceSet *controlRSet=NULLP;
5166    struct PDCCH_Config__controlResourceSetToAddModList *controlRSetList=NULLP;
5167
5168    if(dlBwp->pdcch_Config->choice.setup)
5169    {
5170       pdcchCfg=dlBwp->pdcch_Config->choice.setup;
5171       if(pdcchCfg->controlResourceSetToAddModList)
5172       {
5173          controlRSetList = pdcchCfg->controlResourceSetToAddModList;
5174          if(controlRSetList->list.array)
5175          {
5176             controlRSet = controlRSetList->list.array[idx2];
5177             if(controlRSet)
5178             {
5179                if(controlRSet->frequencyDomainResources.buf)
5180                {
5181                   if(controlRSet->pdcch_DMRS_ScramblingID)
5182                   {
5183                      if(pdcchCfg->searchSpacesToAddModList)
5184                      {
5185                         FreeSearchSpcToAddModList(pdcchCfg->searchSpacesToAddModList);
5186                         CU_FREE(pdcchCfg->searchSpacesToAddModList, \
5187                               sizeof(struct PDCCH_Config__searchSpacesToAddModList));
5188                      }
5189                      CU_FREE(controlRSet->pdcch_DMRS_ScramblingID, sizeof(long));
5190                   }
5191                   CU_FREE(controlRSet->frequencyDomainResources.buf, \
5192                         controlRSet->frequencyDomainResources.size);
5193                }
5194             }
5195             for(idx1 = 0; idx1 <controlRSetList->list.count; idx1++)
5196             {
5197                CU_FREE(controlRSetList->list.array[idx1], sizeof(struct ControlResourceSet));
5198             }
5199             CU_FREE(controlRSetList->list.array, controlRSetList->list.size);
5200          }
5201          CU_FREE(pdcchCfg->controlResourceSetToAddModList, \
5202                sizeof(struct PDCCH_Config__controlResourceSetToAddModList));
5203       }
5204       CU_FREE(dlBwp->pdcch_Config->choice.setup, sizeof(struct PDCCH_Config));
5205    }
5206 }
5207 /*******************************************************************
5208  *
5209  * @brief Builds RLC Config
5210  *
5211  * @details
5212  *
5213  *    Function : BuildRlcConfig
5214  *
5215  *    Functionality: Builds RLC Config in BuildRlcBearerToAddModList
5216  *
5217  * @params[in] RLC_Config *rlcConfig
5218  *
5219  * @return ROK     - success
5220  *         RFAILED - failure
5221  *
5222  * ****************************************************************/
5223 uint8_t BuildRlcConfig(struct RLC_Config *rlcConfig)
5224 {
5225
5226    rlcConfig->present = RLC_Config_PR_am;
5227
5228    rlcConfig->choice.am = NULLP;
5229    CU_ALLOC(rlcConfig->choice.am, sizeof(struct RLC_Config__am));
5230    if(!rlcConfig->choice.am)
5231    {
5232       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfig");
5233       return RFAILED;
5234    }
5235
5236    /* UL */
5237    rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength = NULLP;
5238    CU_ALLOC(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
5239    if(!rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength)
5240    {
5241       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfig");
5242       return RFAILED;
5243    }
5244    *(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength) = SN_FIELD_LEN;
5245    rlcConfig->choice.am->ul_AM_RLC.t_PollRetransmit  = T_POLL_RETRANSMIT;
5246    rlcConfig->choice.am->ul_AM_RLC.pollPDU           = POLL_PDU;
5247    rlcConfig->choice.am->ul_AM_RLC.pollByte          = POLL_BYTE;
5248    rlcConfig->choice.am->ul_AM_RLC.maxRetxThreshold  = MAX_RETX_THRESHOLD;
5249
5250    /* DL */
5251    rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength = NULLP;
5252    CU_ALLOC(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
5253    if(!rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength)
5254    {
5255       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfig");
5256       return RFAILED;
5257    }
5258    *(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength) = SN_FIELD_LEN;
5259    rlcConfig->choice.am->dl_AM_RLC.t_Reassembly      = T_REASSEMBLY;
5260    rlcConfig->choice.am->dl_AM_RLC.t_StatusProhibit  = T_STATUS_PROHIBHIT;
5261
5262    return ROK;
5263 }
5264
5265 /*******************************************************************
5266  *
5267  * @brief Builds MAC LC Config
5268  *
5269  * @details
5270  *
5271  *    Function : BuildMacLCConfig
5272  *
5273  *    Functionality: Builds MAC LC Config in BuildRlcBearerToAddModList
5274  *
5275  * @params[in] struct LogicalChannelConfig macLcConfig
5276  *
5277  * @return ROK     - success
5278  *         RFAILED - failure
5279  *
5280  * ****************************************************************/
5281 uint8_t BuildMacLCConfig(struct LogicalChannelConfig *macLcConfig)
5282 {
5283
5284    macLcConfig->ul_SpecificParameters = NULLP;
5285    CU_ALLOC(macLcConfig->ul_SpecificParameters, sizeof(struct LogicalChannelConfig__ul_SpecificParameters));
5286    if(!macLcConfig->ul_SpecificParameters)
5287    {
5288       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacLCConfig");
5289       return RFAILED;
5290    }
5291
5292    macLcConfig->ul_SpecificParameters->priority = MAC_LC_PRIORITY;
5293    macLcConfig->ul_SpecificParameters->prioritisedBitRate =     PRIORTISIED_BIT_RATE;
5294    macLcConfig->ul_SpecificParameters->bucketSizeDuration =     BUCKET_SIZE_DURATION;
5295    macLcConfig->ul_SpecificParameters->allowedServingCells = NULLP;
5296    macLcConfig->ul_SpecificParameters->allowedSCS_List = NULLP;
5297    macLcConfig->ul_SpecificParameters->maxPUSCH_Duration = NULLP;
5298    macLcConfig->ul_SpecificParameters->configuredGrantType1Allowed = NULLP;
5299
5300    macLcConfig->ul_SpecificParameters->logicalChannelGroup = NULLP;
5301    CU_ALLOC(macLcConfig->ul_SpecificParameters->logicalChannelGroup,    sizeof(long));
5302    if(!macLcConfig->ul_SpecificParameters->logicalChannelGroup)
5303    {
5304       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacLCConfig");
5305       return RFAILED;
5306    }
5307    *(macLcConfig->ul_SpecificParameters->logicalChannelGroup) = LC_GRP;
5308
5309    macLcConfig->ul_SpecificParameters->schedulingRequestID = NULLP;
5310    CU_ALLOC(macLcConfig->ul_SpecificParameters->schedulingRequestID,    sizeof(SchedulingRequestId_t));
5311    if(!macLcConfig->ul_SpecificParameters->schedulingRequestID)
5312    {
5313       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacLCConfig");
5314       return RFAILED;
5315    }
5316    *(macLcConfig->ul_SpecificParameters->schedulingRequestID) = SCH_REQ_ID;
5317
5318    macLcConfig->ul_SpecificParameters->logicalChannelSR_Mask = false;
5319    macLcConfig->ul_SpecificParameters->logicalChannelSR_DelayTimerApplied = false;
5320    macLcConfig->ul_SpecificParameters->bitRateQueryProhibitTimer = NULLP;
5321
5322    return ROK;
5323 }
5324 /*******************************************************************
5325  *
5326  * @brief Builds RLC Bearer to Add/Mod list
5327  *
5328  * @details
5329  *
5330  *    Function :BuildRlcBearerToAddModList
5331  *
5332  *    Functionality: Builds RLC Bearer to Add/Mod list in DuToCuRrcContainer
5333  *
5334  * @params[in] rlc_BearerToAddModList
5335  *
5336  * @return ROK     - success
5337  *         RFAILED - failure
5338  *
5339  * ****************************************************************/
5340 uint8_t BuildRlcBearerToAddModList(struct CellGroupConfigRrc__rlc_BearerToAddModList *rlcBearerList)
5341 {
5342    uint8_t                     idx, elementCnt;
5343
5344    elementCnt = 1;
5345    rlcBearerList->list.count = elementCnt;
5346    rlcBearerList->list.size  = elementCnt * sizeof(struct RLC_BearerConfig *);
5347
5348    rlcBearerList->list.array = NULLP;
5349    CU_ALLOC(rlcBearerList->list.array, rlcBearerList->list.size);
5350    if(!rlcBearerList->list.array)
5351    {
5352       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
5353       return RFAILED;
5354    }
5355
5356    for(idx=0; idx<rlcBearerList->list.count; idx++)
5357    {
5358       rlcBearerList->list.array[idx] = NULLP;
5359       CU_ALLOC(rlcBearerList->list.array[idx], sizeof(struct RLC_BearerConfig));
5360       if(!rlcBearerList->list.array[idx])
5361       {
5362          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
5363          return RFAILED;
5364       }
5365    }
5366
5367    idx = 0;
5368    rlcBearerList->list.array[idx]->logicalChannelIdentity = RLC_LCID;
5369
5370    CU_ALLOC(rlcBearerList->list.array[idx]->servedRadioBearer, sizeof(struct RLC_BearerConfig__servedRadioBearer));
5371    if(!rlcBearerList->list.array[idx]->servedRadioBearer)
5372    {
5373       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
5374       return RFAILED;
5375    }
5376
5377    rlcBearerList->list.array[idx]->servedRadioBearer->present = RLC_BearerConfig__servedRadioBearer_PR_srb_Identity;
5378    rlcBearerList->list.array[idx]->servedRadioBearer->choice.srb_Identity = SRB_ID_1;
5379
5380    rlcBearerList->list.array[idx]->reestablishRLC = NULLP;
5381    rlcBearerList->list.array[idx]->rlc_Config = NULLP;
5382    CU_ALLOC(rlcBearerList->list.array[idx]->rlc_Config, sizeof(struct RLC_Config));
5383    if(!rlcBearerList->list.array[idx]->rlc_Config)
5384    {
5385       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
5386       return RFAILED;
5387    }
5388
5389    if(BuildRlcConfig(rlcBearerList->list.array[idx]->rlc_Config) != ROK)
5390    {
5391       DU_LOG("\nERROR  -->  F1AP : BuildRlcConfig failed");
5392       return RFAILED;
5393    }
5394
5395    rlcBearerList->list.array[idx]->mac_LogicalChannelConfig = NULLP;
5396    CU_ALLOC(rlcBearerList->list.array[idx]->mac_LogicalChannelConfig, sizeof(struct LogicalChannelConfig));
5397    if(!rlcBearerList->list.array[idx]->mac_LogicalChannelConfig)
5398    {
5399       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
5400       return RFAILED;
5401    }
5402
5403    if(BuildMacLCConfig(rlcBearerList->list.array[idx]->mac_LogicalChannelConfig) != ROK)
5404    {
5405       DU_LOG("\nERROR  -->  F1AP : BuildMacLCConfig failed");
5406       return RFAILED;
5407    }
5408
5409    return ROK;
5410 }
5411
5412 /*******************************************************************
5413  *
5414  * @brief Free memory allocated for CellGroupConfig
5415  *
5416  * @details
5417  *
5418  *    Function : FreeMemCellGrpCfg
5419  *
5420  *    Functionality: Deallocating memory of CellGroupConfig
5421  *
5422  * @params[in] pointer to CellGroupConfigRrc_t
5423  *
5424  * @return ROK     - success
5425  *         RFAILED - failure
5426  *
5427  ******************************************************************/
5428 uint8_t FreeMemCellGrpCfg(CellGroupConfigRrc_t *cellGrpCfg)
5429 {
5430    uint8_t idx=0;
5431    SpCellConfig_t *spCellCfg=NULLP;
5432    ServingCellConfig_t *srvCellCfg=NULLP;
5433    BWP_DownlinkDedicated_t *dlBwp=NULLP;
5434    MAC_CellGroupConfig_t *macCellGrpCfg=NULLP;
5435    PhysicalCellGroupConfig_t *phyCellGrpCfg=NULLP;
5436    struct CellGroupConfigRrc__rlc_BearerToAddModList *rlcBearerList=NULLP;
5437    struct RLC_Config *rlcConfig=NULLP;
5438    struct LogicalChannelConfig *macLcConfig=NULLP;
5439    struct SchedulingRequestConfig *schedulingRequestConfig=NULLP;
5440    struct SchedulingRequestConfig__schedulingRequestToAddModList *schReqList=NULLP;
5441    struct TAG_Config *tagConfig=NULLP;
5442    struct TAG_Config__tag_ToAddModList *tagList=NULLP;
5443    struct MAC_CellGroupConfig__phr_Config *phrConfig=NULLP;
5444    struct ServingCellConfig__pdsch_ServingCellConfig *pdschCfg=NULLP;
5445
5446    rlcBearerList = cellGrpCfg->rlc_BearerToAddModList;
5447    if(rlcBearerList)
5448    {
5449       if(rlcBearerList->list.array)
5450       {
5451          for(idx=0; idx<rlcBearerList->list.count; idx++)
5452          {
5453             if(rlcBearerList->list.array[idx])
5454             {
5455                rlcConfig   = rlcBearerList->list.array[idx]->rlc_Config;
5456                macLcConfig = rlcBearerList->list.array[idx]->mac_LogicalChannelConfig;
5457                if(rlcConfig)
5458                {
5459                   if(rlcConfig->choice.am)
5460                   {
5461                      CU_FREE(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
5462                      CU_FREE(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
5463                      CU_FREE(rlcConfig->choice.am, sizeof(struct RLC_Config__am));
5464                   }
5465                   CU_FREE(rlcConfig, sizeof(struct RLC_Config));
5466                }
5467                CU_FREE(rlcBearerList->list.array[idx]->servedRadioBearer, sizeof(struct RLC_BearerConfig__servedRadioBearer));
5468                if(macLcConfig)
5469                {
5470                   if(macLcConfig->ul_SpecificParameters)
5471                   {
5472                      CU_FREE(macLcConfig->ul_SpecificParameters->schedulingRequestID,   sizeof(SchedulingRequestId_t));
5473                      CU_FREE(macLcConfig->ul_SpecificParameters->logicalChannelGroup,   sizeof(long));
5474                      CU_FREE(macLcConfig->ul_SpecificParameters, sizeof(struct LogicalChannelConfig__ul_SpecificParameters));
5475                   }
5476                   CU_FREE(rlcBearerList->list.array[idx]->mac_LogicalChannelConfig, sizeof(struct LogicalChannelConfig));
5477                }
5478                CU_FREE(rlcBearerList->list.array[idx], sizeof(struct RLC_BearerConfig));
5479             }
5480          }
5481          CU_FREE(rlcBearerList->list.array, rlcBearerList->list.size);
5482       }
5483       CU_FREE(cellGrpCfg->rlc_BearerToAddModList, sizeof(struct CellGroupConfigRrc__rlc_BearerToAddModList));
5484    }
5485
5486    macCellGrpCfg = cellGrpCfg->mac_CellGroupConfig;
5487    if(macCellGrpCfg)
5488    {
5489       schedulingRequestConfig = macCellGrpCfg->schedulingRequestConfig;
5490       if(schedulingRequestConfig)
5491       {
5492          schReqList = schedulingRequestConfig->schedulingRequestToAddModList;
5493          if(schReqList)
5494          {
5495             if(schReqList->list.array)
5496             {
5497                for(idx=0;idx<schReqList->list.count; idx++)
5498                {
5499                   if(schReqList->list.array[idx])
5500                   {
5501                      CU_FREE(schReqList->list.array[idx]->sr_ProhibitTimer, sizeof(long));
5502                      CU_FREE(schReqList->list.array[idx], sizeof(struct SchedulingRequestToAddMod));
5503                   }
5504                }
5505                CU_FREE(schReqList->list.array, schReqList->list.size);
5506             }
5507             CU_FREE(schedulingRequestConfig->schedulingRequestToAddModList,\
5508                   sizeof(struct SchedulingRequestConfig__schedulingRequestToAddModList));    }
5509             CU_FREE(macCellGrpCfg->schedulingRequestConfig, sizeof(struct SchedulingRequestConfig));
5510       }
5511       if(macCellGrpCfg->bsr_Config)
5512       {
5513          CU_FREE(macCellGrpCfg->bsr_Config, sizeof(struct BSR_Config));
5514       }
5515       tagConfig = macCellGrpCfg->tag_Config;
5516       if(tagConfig)
5517       {
5518          tagList = tagConfig->tag_ToAddModList;
5519          if(tagList)
5520          {
5521             if(tagList->list.array)
5522             {
5523                for(idx=0; idx<tagList->list.count; idx++)
5524                {
5525                   CU_FREE(tagList->list.array[idx], sizeof(struct TAG));
5526                }
5527                CU_FREE(tagList->list.array, tagList->list.size);
5528             }
5529             CU_FREE(tagConfig->tag_ToAddModList, sizeof(struct TAG_Config__tag_ToAddModList));
5530          }
5531          CU_FREE(tagConfig, sizeof(struct TAG_Config));
5532       }
5533
5534       phrConfig = macCellGrpCfg->phr_Config;
5535       if(phrConfig)
5536       {
5537          CU_FREE(phrConfig->choice.setup, sizeof(struct PHR_Config));
5538          CU_FREE(phrConfig, sizeof(struct MAC_CellGroupConfig__phr_Config));
5539       }
5540
5541       CU_FREE(macCellGrpCfg, sizeof(MAC_CellGroupConfig_t));
5542    }
5543
5544    phyCellGrpCfg = cellGrpCfg->physicalCellGroupConfig;
5545    if(phyCellGrpCfg)
5546    {
5547       CU_FREE(phyCellGrpCfg->p_NR_FR1, sizeof(long));
5548       CU_FREE(phyCellGrpCfg, sizeof(PhysicalCellGroupConfig_t));
5549    }
5550
5551    spCellCfg = cellGrpCfg->spCellConfig;
5552    if(spCellCfg)
5553    {
5554       if(spCellCfg->servCellIndex)
5555       {
5556          if(spCellCfg->rlmInSyncOutOfSyncThreshold)
5557          {
5558             if(spCellCfg->spCellConfigDedicated)
5559             {
5560                srvCellCfg = spCellCfg->spCellConfigDedicated;
5561                if(srvCellCfg->initialDownlinkBWP)
5562                {
5563                   dlBwp = srvCellCfg->initialDownlinkBWP;
5564                   if(srvCellCfg->firstActiveDownlinkBWP_Id)
5565                   {
5566                      if(srvCellCfg->defaultDownlinkBWP_Id)
5567                      {
5568                         if(srvCellCfg->uplinkConfig)
5569                         {
5570                            if(srvCellCfg->pdsch_ServingCellConfig)
5571                            {
5572                               pdschCfg= srvCellCfg->pdsch_ServingCellConfig;
5573                               if(pdschCfg->choice.setup)
5574                               {
5575                                  CU_FREE(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH,sizeof(long));
5576                                  CU_FREE(pdschCfg->choice.setup, sizeof( struct PDSCH_ServingCellConfig));
5577                               }
5578                               CU_FREE(srvCellCfg->pdsch_ServingCellConfig, sizeof(struct
5579                                        ServingCellConfig__pdsch_ServingCellConfig));
5580                            }
5581                            FreeinitialUplinkBWP(srvCellCfg->uplinkConfig);
5582                            CU_FREE(srvCellCfg->uplinkConfig, sizeof(UplinkConfig_t));
5583                         }
5584                         CU_FREE(srvCellCfg->defaultDownlinkBWP_Id, sizeof(long));
5585                      }
5586                      CU_FREE(srvCellCfg->firstActiveDownlinkBWP_Id, sizeof(long));
5587                   }
5588                   if(dlBwp->pdcch_Config)
5589                   {
5590                      if(dlBwp->pdsch_Config)
5591                      {
5592                         FreeBWPDlDedPdschCfg(dlBwp);
5593                         CU_FREE(dlBwp->pdsch_Config, sizeof(struct BWP_DownlinkDedicated__pdsch_Config));
5594                      }
5595                      FreeBWPDlDedPdcchCfg(dlBwp);
5596                      CU_FREE(dlBwp->pdcch_Config, sizeof(struct BWP_DownlinkDedicated__pdcch_Config));
5597                   }
5598                   CU_FREE(srvCellCfg->initialDownlinkBWP, sizeof(BWP_DownlinkDedicated_t));
5599                }
5600                CU_FREE(spCellCfg->spCellConfigDedicated, sizeof(ServingCellConfig_t));
5601             }
5602             CU_FREE(spCellCfg->rlmInSyncOutOfSyncThreshold, sizeof(long));
5603          }
5604          CU_FREE(spCellCfg->servCellIndex, sizeof(long));
5605       }
5606       CU_FREE(spCellCfg,sizeof(SpCellConfig_t));
5607    }
5608    return ROK;
5609 }
5610
5611 /*******************************************************************
5612  *
5613  * @brief Fills CellGroupConfig
5614  *
5615  * @details
5616  *
5617  *    Function : fillCellGrpCfg
5618  *
5619  *    Functionality: Fills CellGroupConfig
5620  *
5621  * @params[in] pointer to CellGroupConfigRrc_t
5622  *
5623  * @return ROK     - success
5624  *         RFAILED - failure
5625  *
5626  ******************************************************************/
5627
5628 uint8_t fillCellGrpCfg(CellGroupConfig_t *cellGrp)
5629 {
5630    uint8_t               ret = RFAILED;
5631    CellGroupConfigRrc_t  cellGrpCfg;
5632    asn_enc_rval_t        encRetVal;
5633
5634    while(true)
5635    {
5636       cellGrpCfg.cellGroupId = CELL_GRP_ID;
5637
5638       cellGrpCfg.rlc_BearerToAddModList = NULLP;
5639       CU_ALLOC(cellGrpCfg.rlc_BearerToAddModList, sizeof(struct CellGroupConfigRrc__rlc_BearerToAddModList));
5640       if(!cellGrpCfg.rlc_BearerToAddModList)
5641       {
5642          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in CellGrpConfig");
5643          break;
5644       }
5645       if(BuildRlcBearerToAddModList(cellGrpCfg.rlc_BearerToAddModList) != ROK)
5646       {
5647          DU_LOG("\nERROR  -->  F1AP : fillCellGrpCfg failed");
5648          break;
5649       }
5650
5651       cellGrpCfg.rlc_BearerToReleaseList = NULLP;
5652       cellGrpCfg.mac_CellGroupConfig = NULLP;
5653       CU_ALLOC(cellGrpCfg.mac_CellGroupConfig, sizeof(MAC_CellGroupConfig_t));
5654       if(!cellGrpCfg.mac_CellGroupConfig)
5655       {
5656          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in fillCellGrpCfg");
5657          break;
5658       }
5659       if(BuildMacCellGrpCfg(cellGrpCfg.mac_CellGroupConfig) != ROK)
5660       {
5661          DU_LOG("\nERROR  -->  F1AP : BuildMacCellGrpCfg failed");
5662          break;
5663       }
5664
5665
5666       cellGrpCfg.physicalCellGroupConfig = NULLP;
5667       CU_ALLOC(cellGrpCfg.physicalCellGroupConfig, sizeof(PhysicalCellGroupConfig_t));
5668       if(!cellGrpCfg.physicalCellGroupConfig)
5669       {
5670          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildDuToCuRrcContainer");
5671          break;
5672       }
5673       if(BuildPhyCellGrpCfg(cellGrpCfg.physicalCellGroupConfig) != ROK)
5674       {
5675          DU_LOG("\nERROR  -->  F1AP : BuildPhyCellGrpCfg failed");
5676          break;
5677       }
5678
5679       cellGrpCfg.spCellConfig = NULLP;
5680       CU_ALLOC(cellGrpCfg.spCellConfig, sizeof(SpCellConfig_t));
5681       if(!cellGrpCfg.spCellConfig)
5682       {
5683          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildDuToCuRrcContainer");
5684          break;
5685       }
5686       if(BuildSpCellCfg(cellGrpCfg.spCellConfig) != ROK)
5687       {
5688          DU_LOG("\nERROR  -->  F1AP : BuildSpCellCfg failed");
5689          break;
5690       }
5691
5692       cellGrpCfg.sCellToAddModList = NULLP;
5693       cellGrpCfg.sCellToReleaseList = NULLP;
5694       cellGrpCfg.ext1 = NULLP;
5695
5696       /* encode cellGrpCfg into duToCuRrcContainer */
5697       xer_fprint(stdout, &asn_DEF_CellGroupConfigRrc, &cellGrpCfg);
5698       cmMemset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
5699       encBufSize = 0;
5700       encRetVal = aper_encode(&asn_DEF_CellGroupConfigRrc, 0, &cellGrpCfg, PrepFinalEncBuf, encBuf);
5701       /* Encode results */
5702       if(encRetVal.encoded == ENCODE_FAIL)
5703       {
5704          DU_LOG( "\nERROR  -->  F1AP : Could not encode DuToCuRrcContainer (at %s)\n",\
5705                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
5706          break;
5707       }
5708       else
5709       {
5710          DU_LOG("\nDEBUG  -->  F1AP : Created APER encodedbuffer for DuToCuRrcContainer\n");
5711          for(int i=0; i< encBufSize; i++)
5712          {
5713             DU_LOG("%x",encBuf[i]);
5714          }
5715       }
5716
5717       cellGrp->size = encBufSize;
5718       CU_ALLOC(cellGrp->buf, cellGrp->size);
5719       if(!cellGrp->buf)
5720       {
5721          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDuToCuRrcContainer");
5722          break;
5723       }
5724       memcpy(cellGrp->buf, encBuf, cellGrp->size);
5725       ret = ROK;
5726       break;
5727    }
5728    FreeMemCellGrpCfg(&cellGrpCfg);
5729    return ROK;
5730 }
5731
5732 /*******************************************************************
5733  *
5734  * @brief Free UE Capability RAT container
5735  *
5736  * @details
5737  *
5738  *    Function : freeUeCapRatCont
5739  *
5740  *    Functionality:
5741  *       Free UE Capability RAT conatiner
5742  *
5743  * @params[in]
5744  * @return ROK     - success
5745  *         RFAILED - failure
5746  *
5747  * ****************************************************************/
5748 void freeUeCapRatCont(UE_NR_Capability_t *ueNrCap)
5749 {
5750    uint8_t idx;
5751    FeatureSets_t *featureSets;
5752
5753    if(ueNrCap->rf_Parameters.supportedBandListNR.list.array)
5754    {
5755       for(idx = 0; idx < ueNrCap->rf_Parameters.supportedBandListNR.list.count; idx++)
5756       {
5757          if(ueNrCap->rf_Parameters.supportedBandListNR.list.array[idx])
5758             CU_FREE(ueNrCap->rf_Parameters.supportedBandListNR.list.array[idx], sizeof(struct BandNR));
5759       }
5760       CU_FREE(ueNrCap->rf_Parameters.supportedBandListNR.list.array, ueNrCap->rf_Parameters.supportedBandListNR.list.size);
5761    }
5762
5763    if(ueNrCap->featureSets)
5764    {
5765       featureSets = ueNrCap->featureSets;
5766       if(featureSets->featureSetsDownlinkPerCC)
5767       {
5768          if(featureSets->featureSetsDownlinkPerCC->list.array)
5769          {
5770             for(idx = 0; idx < featureSets->featureSetsDownlinkPerCC->list.count; idx++)
5771             {
5772                   if(featureSets->featureSetsDownlinkPerCC->list.array[idx]->supportedModulationOrderDL)
5773                      CU_FREE(featureSets->featureSetsDownlinkPerCC->list.array[idx]->supportedModulationOrderDL, \
5774                         sizeof(ModulationOrder_t));
5775                   CU_FREE(featureSets->featureSetsDownlinkPerCC->list.array[idx], sizeof(struct FeatureSetDownlinkPerCC));
5776             }
5777             CU_FREE(featureSets->featureSetsDownlinkPerCC->list.array, featureSets->featureSetsDownlinkPerCC->list.size);
5778          }
5779          CU_FREE(featureSets->featureSetsDownlinkPerCC, sizeof(struct FeatureSets__featureSetsDownlinkPerCC));
5780       }
5781
5782       if(featureSets->featureSetsUplinkPerCC)
5783       {
5784          if(featureSets->featureSetsUplinkPerCC->list.array)
5785          {
5786             for(idx = 0; idx < featureSets->featureSetsUplinkPerCC->list.count; idx++)
5787             {
5788                if(featureSets->featureSetsUplinkPerCC->list.array[idx])
5789                {
5790                   if(featureSets->featureSetsUplinkPerCC->list.array[idx]->supportedModulationOrderUL)
5791                      CU_FREE(featureSets->featureSetsUplinkPerCC->list.array[idx]->supportedModulationOrderUL,\
5792                          sizeof(ModulationOrder_t));
5793                   CU_FREE(featureSets->featureSetsUplinkPerCC->list.array[idx], sizeof(struct FeatureSetUplinkPerCC));
5794                }
5795             }
5796             CU_FREE(featureSets->featureSetsUplinkPerCC->list.array,  featureSets->featureSetsUplinkPerCC->list.size);
5797          }
5798          CU_FREE(featureSets->featureSetsUplinkPerCC, sizeof(struct FeatureSets__featureSetsUplinkPerCC));
5799       }
5800       CU_FREE(ueNrCap->featureSets, sizeof(struct FeatureSets));
5801    }
5802 }
5803
5804 /*******************************************************************
5805  *
5806  * @brief Free UE capability RAT container list
5807  *
5808  * @details
5809  *
5810  *    Function : freeUeCapRatContList
5811  *
5812  *    Functionality: Free UE capability RAT container list
5813  *
5814  * @params[in]
5815  * @return ROK     - success
5816  *         RFAILED - failure
5817  *
5818  * ****************************************************************/
5819 void freeUeCapRatContList(UE_CapabilityRAT_ContainerListRRC_t *ueCapablityList)
5820 {
5821    uint8_t idx;
5822    if(ueCapablityList->list.array)
5823    {
5824       for(idx = 0; idx < ueCapablityList->list.count; idx++)
5825       {
5826          if(ueCapablityList->list.array[idx])
5827             CU_FREE(ueCapablityList->list.array[idx], sizeof(UE_CapabilityRAT_Container_t));
5828       }
5829       CU_FREE(ueCapablityList->list.array, ueCapablityList->list.size);
5830    }
5831 }
5832
5833 /*******************************************************************
5834  *
5835  * @brief Fill feature sets
5836  *
5837  * @details
5838  *
5839  *    Function : fillFeatureSets
5840  *
5841  *    Functionality: Fill feature sets
5842  *
5843  * @params[in]
5844  * @return ROK     - success
5845  *         RFAILED - failure
5846  *
5847  * ****************************************************************/
5848 uint8_t fillFeatureSets(FeatureSets_t *featureSets)
5849 {
5850    uint8_t idx, elementCnt;
5851
5852    featureSets->featureSetsDownlink = NULLP;
5853    CU_ALLOC(featureSets->featureSetsDownlinkPerCC, sizeof(struct FeatureSets__featureSetsDownlinkPerCC));
5854    if(!featureSets->featureSetsDownlinkPerCC)
5855    {
5856       DU_LOG("\nERROR  --> F1AP : Memory allocation failed in fillFeatureSets");
5857       return RFAILED;
5858    }
5859
5860    elementCnt = 1;
5861    featureSets->featureSetsDownlinkPerCC->list.count = elementCnt;
5862    featureSets->featureSetsDownlinkPerCC->list.size = elementCnt * sizeof(struct FeatureSetDownlinkPerCC *);
5863    CU_ALLOC(featureSets->featureSetsDownlinkPerCC->list.array, featureSets->featureSetsDownlinkPerCC->list.size);
5864    if(!featureSets->featureSetsDownlinkPerCC->list.array)
5865    {
5866       DU_LOG("\nERROR  --> F1AP : Memory allocation failed in fillFeatureSets");
5867       return RFAILED;
5868    }
5869
5870    for(idx = 0; idx < elementCnt; idx++)
5871    {
5872       CU_ALLOC(featureSets->featureSetsDownlinkPerCC->list.array[idx], sizeof(struct FeatureSetDownlinkPerCC));
5873       if(!featureSets->featureSetsDownlinkPerCC->list.array[idx])
5874       {
5875          DU_LOG("\nERROR  --> F1AP : Memory allocation failed in fillFeatureSets");
5876          return RFAILED;
5877       }
5878    }
5879
5880    idx = 0;
5881    featureSets->featureSetsDownlinkPerCC->list.array[idx]->supportedSubcarrierSpacingDL = SubcarrierSpacing_kHz15;
5882    featureSets->featureSetsDownlinkPerCC->list.array[idx]->supportedBandwidthDL.present = SupportedBandwidth_PR_fr1;
5883    featureSets->featureSetsDownlinkPerCC->list.array[idx]->supportedBandwidthDL.choice.fr1 = SupportedBandwidth__fr1_mhz20;
5884    featureSets->featureSetsDownlinkPerCC->list.array[idx]->channelBW_90mhz = NULLP;
5885    featureSets->featureSetsDownlinkPerCC->list.array[idx]->maxNumberMIMO_LayersPDSCH = NULLP;
5886
5887    CU_ALLOC(featureSets->featureSetsDownlinkPerCC->list.array[idx]->supportedModulationOrderDL, sizeof(ModulationOrder_t));
5888    if(!featureSets->featureSetsDownlinkPerCC->list.array[idx]->supportedModulationOrderDL)
5889    {
5890       DU_LOG("\nERROR  --> F1AP : Memory allocation failed in fillFeatureSets");
5891       return RFAILED;
5892    }
5893    *(featureSets->featureSetsDownlinkPerCC->list.array[idx]->supportedModulationOrderDL) = ModulationOrder_qam64;
5894
5895    featureSets->featureSetsUplink = NULLP;
5896    CU_ALLOC(featureSets->featureSetsUplinkPerCC, sizeof(struct FeatureSets__featureSetsUplinkPerCC));
5897    if(!featureSets->featureSetsUplinkPerCC)
5898    {
5899       DU_LOG("\nERROR  --> F1AP : Memory allocation failed in fillFeatureSets");
5900       return RFAILED;
5901    }
5902
5903    elementCnt = 1;
5904    featureSets->featureSetsUplinkPerCC->list.count = elementCnt;
5905    featureSets->featureSetsUplinkPerCC->list.size = elementCnt * sizeof(struct FeatureSetUplinkPerCC *);
5906    CU_ALLOC(featureSets->featureSetsUplinkPerCC->list.array, featureSets->featureSetsUplinkPerCC->list.size);
5907    if(!featureSets->featureSetsUplinkPerCC->list.array)
5908    {
5909       DU_LOG("\nERROR  --> F1AP : Memory allocation failed in fillFeatureSets");
5910       return RFAILED;
5911    }
5912
5913    for(idx = 0; idx < elementCnt; idx++)
5914    {
5915       CU_ALLOC(featureSets->featureSetsUplinkPerCC->list.array[idx], sizeof(struct FeatureSetUplinkPerCC));
5916       if(!featureSets->featureSetsUplinkPerCC->list.array[idx])
5917       {
5918          DU_LOG("\nERROR  --> F1AP : Memory allocation failed in fillFeatureSets");
5919          return RFAILED;
5920       }
5921    }
5922
5923    idx = 0;
5924    featureSets->featureSetsUplinkPerCC->list.array[idx]->supportedSubcarrierSpacingUL = SubcarrierSpacing_kHz15;
5925    featureSets->featureSetsUplinkPerCC->list.array[idx]->supportedBandwidthUL.present = SupportedBandwidth_PR_fr1;
5926    featureSets->featureSetsUplinkPerCC->list.array[idx]->supportedBandwidthUL.choice.fr1 = SupportedBandwidth__fr1_mhz20;
5927    featureSets->featureSetsUplinkPerCC->list.array[idx]->channelBW_90mhz = NULLP;
5928    featureSets->featureSetsUplinkPerCC->list.array[idx]->mimo_CB_PUSCH = NULLP;
5929    featureSets->featureSetsUplinkPerCC->list.array[idx]->maxNumberMIMO_LayersNonCB_PUSCH = NULLP;
5930
5931    CU_ALLOC(featureSets->featureSetsUplinkPerCC->list.array[idx]->supportedModulationOrderUL, sizeof(ModulationOrder_t));
5932    if(!featureSets->featureSetsUplinkPerCC->list.array[idx]->supportedModulationOrderUL)
5933    {
5934       DU_LOG("\nERROR  --> F1AP : Memory allocation failed in fillFeatureSets");
5935       return RFAILED;
5936    }
5937    *(featureSets->featureSetsUplinkPerCC->list.array[idx]->supportedModulationOrderUL) = ModulationOrder_qam16;
5938
5939    return ROK;
5940 }
5941
5942 /*******************************************************************
5943  *
5944  * @brief Fill UE capability RAT container
5945  *
5946  * @details
5947  *
5948  *    Function : fillUeCapRatCont
5949  *
5950  *    Functionality: Fill UE capability RAT container
5951  *
5952  * @params[in] UE Capability RAT container buffer
5953  * @return ROK     - success
5954  *         RFAILED - failure
5955  *
5956  * ****************************************************************/
5957 uint8_t fillUeCapRatCont(OCTET_STRING_t *ueCapRatContBuf)
5958 {
5959    uint8_t             ret = ROK;
5960    uint8_t             idx, elementCnt;
5961    asn_enc_rval_t      encRetVal;
5962    UE_NR_Capability_t  ueNrCap;
5963
5964    while(true)
5965    {
5966       ueNrCap.accessStratumRelease = AccessStratumRelease_rel15;
5967
5968       /* Filling PDCP parameters */
5969       ueNrCap.pdcp_Parameters.supportedROHC_Profiles.profile0x0000 = false;
5970       ueNrCap.pdcp_Parameters.supportedROHC_Profiles.profile0x0001 = false;
5971       ueNrCap.pdcp_Parameters.supportedROHC_Profiles.profile0x0002 = false;
5972       ueNrCap.pdcp_Parameters.supportedROHC_Profiles.profile0x0003 = false;
5973       ueNrCap.pdcp_Parameters.supportedROHC_Profiles.profile0x0004 = false;
5974       ueNrCap.pdcp_Parameters.supportedROHC_Profiles.profile0x0006 = false;
5975       ueNrCap.pdcp_Parameters.supportedROHC_Profiles.profile0x0101 = false;
5976       ueNrCap.pdcp_Parameters.supportedROHC_Profiles.profile0x0102 = false;
5977       ueNrCap.pdcp_Parameters.supportedROHC_Profiles.profile0x0103 = false;
5978       ueNrCap.pdcp_Parameters.supportedROHC_Profiles.profile0x0104 = false;
5979       ueNrCap.pdcp_Parameters.maxNumberROHC_ContextSessions = PDCP_Parameters__maxNumberROHC_ContextSessions_cs2;
5980       ueNrCap.pdcp_Parameters.uplinkOnlyROHC_Profiles = NULLP;
5981       ueNrCap.pdcp_Parameters.continueROHC_Context = NULLP;
5982       ueNrCap.pdcp_Parameters.outOfOrderDelivery = NULLP;
5983       ueNrCap.pdcp_Parameters.shortSN = NULLP;
5984       ueNrCap.pdcp_Parameters.pdcp_DuplicationSRB = NULLP;
5985       ueNrCap.pdcp_Parameters.pdcp_DuplicationMCG_OrSCG_DRB = NULLP;
5986
5987       ueNrCap.rlc_Parameters = NULLP;
5988       ueNrCap.mac_Parameters = NULLP;
5989
5990       /* Filling PHY parameters */
5991       ueNrCap.phy_Parameters.phy_ParametersCommon = NULLP;
5992       ueNrCap.phy_Parameters.phy_ParametersXDD_Diff = NULLP;
5993       ueNrCap.phy_Parameters.phy_ParametersFRX_Diff = NULLP;
5994       ueNrCap.phy_Parameters.phy_ParametersFR1 = NULLP;
5995       ueNrCap.phy_Parameters.phy_ParametersFR2 = NULLP;
5996
5997       /* Filling RF parameters */
5998       elementCnt = 1;
5999       ueNrCap.rf_Parameters.supportedBandListNR.list.count = elementCnt;
6000       ueNrCap.rf_Parameters.supportedBandListNR.list.size = elementCnt * sizeof(struct BandNR *);
6001       CU_ALLOC(ueNrCap.rf_Parameters.supportedBandListNR.list.array, ueNrCap.rf_Parameters.supportedBandListNR.list.size);
6002       if(!ueNrCap.rf_Parameters.supportedBandListNR.list.array)
6003       {
6004          DU_LOG("\nERROR  --> F1AP : Memory allocation failed in fillUeCapRatCont");
6005          ret = RFAILED;
6006          break;
6007       }
6008
6009       for(idx = 0; idx < elementCnt; idx++)
6010       {
6011          CU_ALLOC(ueNrCap.rf_Parameters.supportedBandListNR.list.array[idx], sizeof(struct BandNR));
6012          if(!ueNrCap.rf_Parameters.supportedBandListNR.list.array[idx])
6013          {
6014             ret = RFAILED;
6015             break;
6016          }
6017       }
6018       if(ret == RFAILED)
6019          break;
6020
6021       idx = 0;
6022       ueNrCap.rf_Parameters.supportedBandListNR.list.array[idx]->bandNR = 1;
6023       ueNrCap.rf_Parameters.supportedBandCombinationList = NULLP;
6024       ueNrCap.rf_Parameters.appliedFreqBandListFilter = NULLP;
6025
6026       ueNrCap.measAndMobParameters = NULLP;
6027       ueNrCap.fdd_Add_UE_NR_Capabilities = NULLP;
6028       ueNrCap.tdd_Add_UE_NR_Capabilities = NULLP;
6029       ueNrCap.fr1_Add_UE_NR_Capabilities = NULLP;
6030       ueNrCap.fr2_Add_UE_NR_Capabilities = NULLP;
6031       ueNrCap.featureSets = NULLP;
6032
6033       CU_ALLOC(ueNrCap.featureSets, sizeof(struct FeatureSets));
6034       if(!ueNrCap.featureSets)
6035       {
6036          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in fillUeCapRatCont");
6037          ret = RFAILED;
6038          break;
6039       }
6040
6041       if(fillFeatureSets(ueNrCap.featureSets) != ROK)
6042       {
6043          DU_LOG("\nERROR  -->  fillDLFeatureSets() failed ");
6044          ret = RFAILED;
6045          break;
6046       }
6047
6048       ueNrCap.featureSetCombinations = NULLP;
6049       ueNrCap.lateNonCriticalExtension = NULLP;
6050       ueNrCap.nonCriticalExtension = NULLP;
6051
6052       /* encode UE Capability RAT Container List into duToCuRrcContainer */
6053       xer_fprint(stdout, &asn_DEF_UE_NR_Capability, &ueNrCap);
6054       cmMemset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
6055       encBufSize = 0;
6056       encRetVal = aper_encode(&asn_DEF_UE_NR_Capability, 0, &ueNrCap, PrepFinalEncBuf, encBuf);
6057
6058       /* Encode results */
6059       if(encRetVal.encoded == ENCODE_FAIL)
6060       {
6061          DU_LOG( "\nERROR  -->  F1AP : Could not encode UE Capability RAT Container (at %s)\n",\
6062             encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
6063          break;
6064       }
6065       else
6066       {
6067          DU_LOG("\nDEBUG  -->  F1AP : Created APER encodedbuffer for UE Capability RAT Container\n");
6068          for(int i=0; i< encBufSize; i++)
6069          {
6070             DU_LOG("%x",encBuf[i]);
6071          }
6072       }
6073
6074       ueCapRatContBuf->size = encBufSize;
6075       CU_ALLOC(ueCapRatContBuf->buf, ueCapRatContBuf->size);
6076       if(!ueCapRatContBuf->buf)
6077       {
6078          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in fillUeCapabilityContainer");
6079          break;
6080       }
6081       memcpy(ueCapRatContBuf->buf, encBuf, ueCapRatContBuf->size);
6082       ret = ROK;
6083       break;
6084    }
6085    freeUeCapRatCont(&ueNrCap);
6086    return ROK;
6087 }
6088
6089 /*******************************************************************
6090  *
6091  * @brief Fill UE Capability RAT container list
6092  *
6093  * @details
6094  *
6095  *    Function : fillUeCapRatContList
6096  *
6097  *    Functionality: Fill UE Capability RAT container list
6098
6099  *
6100  * @params[in] UE capability RAT container list buffer
6101  * @return ROK     - success
6102  *         RFAILED - failure
6103  *
6104  * ****************************************************************/
6105 uint8_t fillUeCapRatContList(UE_CapabilityRAT_ContainerList_t *ueCapablityListBuf)
6106 {
6107     uint8_t          ret = RFAILED;
6108     uint8_t          idx, elementCnt;
6109     asn_enc_rval_t   encRetVal;
6110     UE_CapabilityRAT_ContainerListRRC_t  ueCapablityList;
6111
6112     while(true)
6113     {
6114        elementCnt = 1;
6115        ueCapablityList.list.count = elementCnt;
6116        ueCapablityList.list.size = elementCnt * sizeof(UE_CapabilityRAT_Container_t *);
6117
6118        CU_ALLOC(ueCapablityList.list.array, ueCapablityList.list.size);
6119        if(!ueCapablityList.list.array)
6120        {
6121           DU_LOG("\nERROR  -->  Memory allocation failed in fillUeCapRatContList");
6122           ret = RFAILED;
6123           break;
6124        }
6125
6126        for(idx=0; idx<elementCnt; idx++)
6127        {
6128           CU_ALLOC(ueCapablityList.list.array[idx], sizeof(UE_CapabilityRAT_Container_t));
6129           if(ueCapablityList.list.array[idx] == NULLP)
6130           {
6131              DU_LOG("\nERROR  -->  Memory allocation failed in fillUeCapRatContList");
6132              ret = RFAILED;
6133              break;
6134           }
6135        }
6136        idx = 0;
6137        ueCapablityList.list.array[idx]->rat_Type = RAT_Type_nr;
6138        ret = fillUeCapRatCont(&ueCapablityList.list.array[idx]->ue_CapabilityRAT_Container);
6139
6140        /* encode UE Capability RAT Container List into duToCuRrcContainer */
6141        xer_fprint(stdout, &asn_DEF_UE_CapabilityRAT_ContainerListRRC, &ueCapablityList);
6142        cmMemset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
6143        encBufSize = 0;
6144        encRetVal = aper_encode(&asn_DEF_UE_CapabilityRAT_ContainerListRRC, 0, \
6145           &ueCapablityList, PrepFinalEncBuf, encBuf);
6146
6147        /* Encode results */
6148        if(encRetVal.encoded == ENCODE_FAIL)
6149        {
6150           DU_LOG( "\nERROR  -->  F1AP : Could not encode UE Capability RAT Container (at %s)\n",\
6151              encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
6152           break;
6153        }
6154        else
6155        {
6156           DU_LOG("\nDEBUG  -->  F1AP : Created APER encodedbuffer for UE Capability RAT Container\n");
6157           for(int i=0; i< encBufSize; i++)
6158           {
6159              DU_LOG("%x",encBuf[i]);
6160           }
6161        }
6162
6163        ueCapablityListBuf->size = encBufSize;
6164        CU_ALLOC(ueCapablityListBuf->buf, ueCapablityListBuf->size);
6165        if(!ueCapablityListBuf->buf)
6166        {
6167           DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in fillUeCapabilityContainer");
6168           break;
6169        }
6170        memcpy(ueCapablityListBuf->buf, encBuf, ueCapablityListBuf->size);
6171        ret = ROK;
6172        break;
6173     }
6174     freeUeCapRatContList(&ueCapablityList);
6175     return ROK;
6176 }
6177
6178 /*******************************************************************
6179  *
6180  * @brief Fills CuToDuContainer
6181  *
6182  * @details
6183  *
6184  *    Function : fillCuToDuContainer
6185  *
6186  *    Functionality: Fills CuToDuContainer
6187  *
6188  * @params[in] pointer to CUtoDURRCInformation_t
6189  *
6190  * @return ROK     - success
6191  *         RFAILED - failure
6192  *
6193  ******************************************************************/
6194
6195 uint8_t fillCuToDuContainer(CUtoDURRCInformation_t *rrcMsg)
6196 {
6197    uint8_t elementCnt = 0;
6198    uint8_t ret = ROK;
6199    uint8_t idx, idx2, rrcBufLen;
6200
6201    CU_ALLOC(rrcMsg->uE_CapabilityRAT_ContainerList, sizeof(UE_CapabilityRAT_ContainerList_t));
6202    if(!rrcMsg->uE_CapabilityRAT_ContainerList)
6203    {
6204       DU_LOG("\nERROR  -->  F1AP : Memory allocation for CUtoDURRCInformation_ExtIEs failed");
6205       return RFAILED;
6206    }
6207    ret = fillUeCapRatContList(rrcMsg->uE_CapabilityRAT_ContainerList);
6208
6209    CU_ALLOC(rrcMsg->iE_Extensions, sizeof(ProtocolExtensionContainer_4624P16_t));
6210    if(rrcMsg->iE_Extensions)
6211    {
6212       elementCnt = 1;
6213       rrcMsg->iE_Extensions->list.count = elementCnt;
6214       rrcMsg->iE_Extensions->list.size = elementCnt * sizeof(CUtoDURRCInformation_ExtIEs_t);
6215
6216       /* Initialize the CUtoDURRCInformation_ExtIEs */
6217       CU_ALLOC(rrcMsg->iE_Extensions->list.array, rrcMsg->iE_Extensions->list.size);
6218
6219       if(rrcMsg->iE_Extensions->list.array == NULLP)
6220       {
6221          DU_LOG("\nERROR  -->  F1AP : Memory allocation for CUtoDURRCInformation_ExtIEs failed");
6222          ret = RFAILED;
6223       }
6224
6225       for(idx=0; idx<elementCnt; idx++)
6226       {
6227          CU_ALLOC(rrcMsg->iE_Extensions->list.array[idx], sizeof(CUtoDURRCInformation_ExtIEs_t));
6228          if(rrcMsg->iE_Extensions->list.array[idx] == NULLP)
6229          {
6230             ret = RFAILED;
6231          }
6232       }
6233       idx = 0;
6234       /* Filling CellGroupConfig_t IE */
6235       rrcMsg->iE_Extensions->list.array[idx]->id = ProtocolIE_ID_id_CellGroupConfig;
6236       rrcMsg->iE_Extensions->list.array[idx]->criticality = Criticality_ignore;
6237       rrcMsg->iE_Extensions->list.array[idx]->extensionValue.present  =\
6238                                                                        CUtoDURRCInformation_ExtIEs__extensionValue_PR_CellGroupConfig;
6239       ret = fillCellGrpCfg(&rrcMsg->iE_Extensions->list.array[idx]->extensionValue.choice.CellGroupConfig);
6240    }
6241    return ret;
6242 }
6243
6244 /*******************************************************************
6245  *
6246  * @brief Free CuToDuContainer
6247  *
6248  * @details
6249  *
6250  *    Function : FreeCuToDuInfo
6251  *
6252  *    Functionality: Free CuToDuContainer
6253  *
6254  * @params[in] pointer to CUtoDURRCInformation_t
6255  *
6256  * @return ROK     - success
6257  *         RFAILED - failure
6258  *
6259  ******************************************************************/
6260
6261 void FreeCuToDuInfo(CUtoDURRCInformation_t *rrcMsg)
6262 {
6263    uint8_t idx, idx2;
6264
6265    if(rrcMsg->uE_CapabilityRAT_ContainerList)
6266    {
6267       if(rrcMsg->uE_CapabilityRAT_ContainerList->buf)
6268          CU_FREE(rrcMsg->uE_CapabilityRAT_ContainerList->buf, rrcMsg->uE_CapabilityRAT_ContainerList->size);
6269       CU_FREE(rrcMsg->uE_CapabilityRAT_ContainerList, sizeof(UE_CapabilityRAT_ContainerList_t));
6270    }
6271    if(rrcMsg->iE_Extensions)
6272    {
6273       if(rrcMsg->iE_Extensions->list.array)
6274       {
6275          for(idx= 0; idx < rrcMsg->iE_Extensions->list.count; idx++)
6276          {
6277             if(rrcMsg->iE_Extensions->list.array[idx])
6278             {
6279                switch(rrcMsg->iE_Extensions->list.array[idx]->id)
6280                {
6281                   case ProtocolIE_ID_id_CellGroupConfig:
6282                      if(rrcMsg->iE_Extensions->list.array[idx]->extensionValue.choice.CellGroupConfig.buf != NULLP)
6283                      {
6284                         CU_FREE(rrcMsg->iE_Extensions->list.array[idx]->extensionValue.choice.CellGroupConfig.buf,\
6285                               rrcMsg->iE_Extensions->list.array[idx]->extensionValue.choice.CellGroupConfig.size);
6286
6287                      }
6288                      break;
6289                   default:
6290                      DU_LOG("\nERROR  -->  F1AP : Invalid Event type %ld at FreeCuToDuInfo()", \
6291                            rrcMsg->iE_Extensions->list.array[idx]->id);
6292                      break;
6293                }
6294             }
6295             break;
6296          }
6297          for(idx2 = 0; idx2 < idx; idx2++)
6298          {
6299             CU_FREE(rrcMsg->iE_Extensions->list.array[idx2], sizeof(CUtoDURRCInformation_ExtIEs_t));
6300          }
6301          CU_FREE(rrcMsg->iE_Extensions->list.array, rrcMsg->iE_Extensions->list.size);
6302
6303       }
6304
6305       CU_FREE(rrcMsg->iE_Extensions, sizeof(ProtocolExtensionContainer_4624P16_t));
6306    }
6307 }
6308 /*******************************************************************
6309  *
6310  * @brief Builds and sends the UE Setup Request
6311  *
6312  * @details
6313  *
6314  *    Function : BuildAndSendUeContextSetupReq
6315  *
6316  *    Functionality: Constructs the UE Setup Request and sends
6317  *                   it to the CU through SCTP.
6318  *
6319  * @params[in]
6320  *
6321  * @return ROK     - success
6322  *         RFAILED - failure
6323  *
6324  * ****************************************************************/
6325 uint8_t BuildAndSendUeContextSetupReq(uint8_t cuUeF1apId, uint8_t duUeF1apId, \
6326       uint16_t rrcContLen, uint8_t *rrcContainer)
6327 {
6328    uint8_t   Nrcgiret;
6329    uint8_t   SplCellListret;
6330    uint8_t   SrbSetupret;
6331    uint8_t   elementCnt;
6332    uint8_t   idx, bufLen;
6333    uint8_t   idx1;
6334    F1AP_PDU_t           *f1apMsg = NULLP;
6335    UEContextSetupRequest_t *ueSetReq = NULLP;
6336    asn_enc_rval_t encRetVal;        /* Encoder return value */
6337    memset(&encRetVal, 0, sizeof(asn_enc_rval_t));
6338    uint8_t ret= RFAILED;
6339    uint8_t ret1;
6340    while(true)
6341    {
6342       DU_LOG("\nINFO  -->  F1AP : Building UE Context Setup Request\n");
6343
6344       CU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
6345       if(f1apMsg == NULLP)
6346       {
6347          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
6348          break;
6349       }
6350
6351       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
6352       CU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
6353       if(f1apMsg->choice.initiatingMessage == NULLP)
6354       {
6355          DU_LOG("\nERROR  -->  F1AP : Memory allocation for     F1AP-PDU failed");
6356          break;
6357       }
6358
6359       f1apMsg->choice.initiatingMessage->procedureCode = \
6360                                                          ProcedureCode_id_UEContextSetup;
6361       f1apMsg->choice.initiatingMessage->criticality = Criticality_reject;
6362       f1apMsg->choice.initiatingMessage->value.present = \
6363                                                          InitiatingMessage__value_PR_UEContextSetupRequest;
6364       ueSetReq =
6365          &f1apMsg->choice.initiatingMessage->value.choice.UEContextSetupRequest;
6366
6367       elementCnt = 12;
6368       ueSetReq->protocolIEs.list.count = elementCnt;
6369       ueSetReq->protocolIEs.list.size = \
6370                                         elementCnt * sizeof(UEContextSetupRequestIEs_t *);
6371
6372       /* Initialize the UESetup members */
6373       CU_ALLOC(ueSetReq->protocolIEs.list.array,ueSetReq->protocolIEs.list.size);
6374
6375       if(ueSetReq->protocolIEs.list.array == NULLP)
6376       {
6377          DU_LOG("\nERROR  -->  F1AP : Memory allocation for UE Context SetupRequest failed");
6378          break;
6379       }
6380
6381       for(idx1=0; idx1<elementCnt; idx1++)
6382       {
6383          CU_ALLOC(ueSetReq->protocolIEs.list.array[idx1],sizeof(UEContextSetupRequestIEs_t));
6384          if(ueSetReq->protocolIEs.list.array[idx1] == NULLP)
6385          {
6386             break;
6387          }
6388       }
6389
6390       idx = 0;
6391
6392       /*GNB CU UE F1AP ID*/
6393       ueSetReq->protocolIEs.list.array[idx]->id = \
6394                                                   ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
6395       ueSetReq->protocolIEs.list.array[idx]->criticality        =       Criticality_reject;
6396       ueSetReq->protocolIEs.list.array[idx]->value.present = \
6397                                                              UEContextSetupRequestIEs__value_PR_GNB_CU_UE_F1AP_ID;
6398       ueSetReq->protocolIEs.list.array[idx]->value.choice.GNB_CU_UE_F1AP_ID = cuUeF1apId;
6399
6400       /*GNB DU UE F1AP ID*/
6401       idx++;
6402       ueSetReq->protocolIEs.list.array[idx]->id = \
6403                                                   ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
6404       ueSetReq->protocolIEs.list.array[idx]->criticality        =       Criticality_ignore;
6405       ueSetReq->protocolIEs.list.array[idx]->value.present = \
6406                                                              UEContextSetupRequestIEs__value_PR_GNB_DU_UE_F1AP_ID;
6407       ueSetReq->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID = duUeF1apId;
6408
6409       /*Special Cell ID*/
6410       idx++;
6411       ueSetReq->protocolIEs.list.array[idx]->id = \
6412                                                   ProtocolIE_ID_id_SpCell_ID;
6413       ueSetReq->protocolIEs.list.array[idx]->criticality        =       Criticality_reject;
6414       ueSetReq->protocolIEs.list.array[idx]->value.present = \
6415                                                              UEContextSetupRequestIEs__value_PR_NRCGI;
6416       Nrcgiret = BuildNrcgi(&ueSetReq->protocolIEs.list.array[idx]->value.choice.NRCGI);
6417       if(Nrcgiret != ROK)
6418       {
6419          break;
6420       }
6421
6422       /*Served Cell Index*/
6423       idx++;
6424       ueSetReq->protocolIEs.list.array[idx]->id = \
6425                                                   ProtocolIE_ID_id_ServCellIndex;
6426       ueSetReq->protocolIEs.list.array[idx]->criticality        =       Criticality_reject;
6427       ueSetReq->protocolIEs.list.array[idx]->value.present = \
6428                                                              UEContextSetupRequestIEs__value_PR_ServCellIndex;
6429       ueSetReq->protocolIEs.list.array[idx]->value.choice.ServCellIndex = \
6430                                                                           CELL_INDEX;
6431
6432       /*CellULConfigured*/
6433       idx++;
6434       ueSetReq->protocolIEs.list.array[idx]->id = \
6435                                                   ProtocolIE_ID_id_SpCellULConfigured;
6436       ueSetReq->protocolIEs.list.array[idx]->criticality        =       Criticality_ignore;
6437       ueSetReq->protocolIEs.list.array[idx]->value.present = \
6438                                                              UEContextSetupRequestIEs__value_PR_CellULConfigured;
6439       ueSetReq->protocolIEs.list.array[idx]->value.choice.CellULConfigured = \
6440                                                                              CellULConfigured_none;
6441
6442       /*CUtoDURRCContainer*/
6443       idx++;
6444       ueSetReq->protocolIEs.list.array[idx]->id = \
6445                                                   ProtocolIE_ID_id_CUtoDURRCInformation;
6446       ueSetReq->protocolIEs.list.array[idx]->criticality        =       Criticality_reject;
6447       ueSetReq->protocolIEs.list.array[idx]->value.present = \
6448                                                              UEContextSetupRequestIEs__value_PR_CUtoDURRCInformation;
6449       if(fillCuToDuContainer(&ueSetReq->protocolIEs.list.array[idx]->value.choice.CUtoDURRCInformation))
6450       {
6451          break;
6452       }
6453
6454       /*Special Cells to be SetupList*/
6455       idx++;
6456       ueSetReq->protocolIEs.list.array[idx]->id = \
6457                                                   ProtocolIE_ID_id_SCell_ToBeSetup_List;
6458       ueSetReq->protocolIEs.list.array[idx]->criticality        =       Criticality_ignore;
6459       ueSetReq->protocolIEs.list.array[idx]->value.present = \
6460                                                              UEContextSetupRequestIEs__value_PR_SCell_ToBeSetup_List;
6461       SplCellListret = BuildSplCellList(&ueSetReq->protocolIEs.list.array[idx]->value.choice.SCell_ToBeSetup_List);
6462       if(SplCellListret != ROK)
6463       {
6464          break;
6465       }
6466       /*SRBs To Be Setup List*/
6467       idx++;
6468       ueSetReq->protocolIEs.list.array[idx]->id = \
6469                                                   ProtocolIE_ID_id_SRBs_ToBeSetup_List;
6470       ueSetReq->protocolIEs.list.array[idx]->criticality        =       Criticality_reject;
6471       ueSetReq->protocolIEs.list.array[idx]->value.present = \
6472                                                              UEContextSetupRequestIEs__value_PR_SRBs_ToBeSetup_List;
6473       SrbSetupret =     BuildSRBSetup(&ueSetReq->protocolIEs.list.array[idx]->value.choice.SRBs_ToBeSetup_List);
6474       if(SrbSetupret != ROK)
6475       {
6476          break;
6477       }
6478       /*DRBs to Be Setup List*/
6479       idx++;
6480       ueSetReq->protocolIEs.list.array[idx]->id = \
6481                                                   ProtocolIE_ID_id_DRBs_ToBeSetup_List;
6482       ueSetReq->protocolIEs.list.array[idx]->criticality        =       Criticality_reject;
6483       ueSetReq->protocolIEs.list.array[idx]->value.present = \
6484                                                              UEContextSetupRequestIEs__value_PR_DRBs_ToBeSetup_List;
6485       ret1 = BuildDRBSetup(&ueSetReq->protocolIEs.list.array[idx]->value.choice.DRBs_ToBeSetup_List);
6486       if(ret1 != ROK)
6487       {
6488          break;
6489       }
6490       /* RRC Container for security mode */
6491       idx++;
6492       ueSetReq->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_RRCContainer;
6493       ueSetReq->protocolIEs.list.array[idx]->criticality = Criticality_reject;
6494       ueSetReq->protocolIEs.list.array[idx]->value.present = \
6495                                                              UEContextSetupRequestIEs__value_PR_RRCContainer;
6496       char secModeBuf[9]={0x00, 0x02, 0x22, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00};
6497       bufLen =9;
6498       ueSetReq->protocolIEs.list.array[idx]->value.choice.RRCContainer.size = bufLen;
6499       CU_ALLOC(ueSetReq->protocolIEs.list.array[idx]->value.choice.RRCContainer.buf,
6500             ueSetReq->protocolIEs.list.array[idx]->value.choice.RRCContainer.size);
6501       if(!ueSetReq->protocolIEs.list.array[idx]->value.choice.RRCContainer.buf)
6502       {
6503          DU_LOG("\nERROR  -->  F1AP : Memory allocation for BuildAndSendUeContextSetupReq failed");
6504          break;
6505       }
6506       memset(ueSetReq->protocolIEs.list.array[idx]->value.choice.RRCContainer.buf, 0, bufLen);
6507       memcpy(ueSetReq->protocolIEs.list.array[idx]->value.choice.RRCContainer.buf, secModeBuf, bufLen);
6508
6509       /* RRC delivery status request */
6510       idx++;
6511       ueSetReq->protocolIEs.list.array[idx]->id = \
6512                                                   ProtocolIE_ID_id_RRCDeliveryStatusRequest;
6513       ueSetReq->protocolIEs.list.array[idx]->criticality = Criticality_ignore;
6514       ueSetReq->protocolIEs.list.array[idx]->value.present = \
6515                                                              UEContextSetupRequestIEs__value_PR_RRCDeliveryStatusRequest;
6516       ueSetReq->protocolIEs.list.array[idx]->value.choice.RRCDeliveryStatusRequest = \
6517                                                                                      RRCDeliveryStatusRequest_true;
6518
6519       /* Bit Rate hardcoded as in reference logs */
6520       idx++;
6521       ueSetReq->protocolIEs.list.array[idx]->id = \
6522                                                   ProtocolIE_ID_id_GNB_DU_UE_AMBR_UL;
6523       ueSetReq->protocolIEs.list.array[idx]->criticality = Criticality_ignore;
6524       ueSetReq->protocolIEs.list.array[idx]->value.present = \
6525                                                              UEContextSetupRequestIEs__value_PR_BitRate;
6526       char bitRateBuf[4]= {0x3B, 0x37, 0xF4, 0xCD};
6527       bufLen = 4;
6528       ueSetReq->protocolIEs.list.array[idx]->value.choice.BitRate.size = bufLen;
6529       CU_ALLOC(ueSetReq->protocolIEs.list.array[idx]->value.choice.BitRate.buf,\
6530             ueSetReq->protocolIEs.list.array[idx]->value.choice.BitRate.size);
6531       if(!ueSetReq->protocolIEs.list.array[idx]->value.choice.BitRate.buf)
6532       {
6533          DU_LOG("\nERROR  -->  F1AP : Failed to allocate memory for Bit Rate in BuildAndSendUeContextSetupReq()");
6534          break;
6535       }
6536       memset(ueSetReq->protocolIEs.list.array[idx]->value.choice.BitRate.buf, 0, bufLen);
6537       memcpy(ueSetReq->protocolIEs.list.array[idx]->value.choice.BitRate.buf, bitRateBuf, bufLen);
6538
6539       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
6540
6541       /* Encode the F1SetupRequest type as APER */
6542       memset(encBuf, 0, ENC_BUF_MAX_LEN);
6543       encBufSize = 0;
6544       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
6545             encBuf);
6546       /* Encode results */
6547       if(encRetVal.encoded == ENCODE_FAIL)
6548       {
6549          DU_LOG( "\nERROR  -->  F1AP : Could not encode UE Context Setup Request structure (at %s)\n",\
6550                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
6551          break;
6552       }
6553       else
6554       {
6555          DU_LOG("\nDEBUG  -->  F1AP : Created APER encodedbuffer for UE Context Setup Request\n");
6556          for(int i=0; i< encBufSize; i++)
6557          {
6558             DU_LOG("%x",encBuf[i]);
6559          }
6560       }
6561
6562       /* Sending  msg  */
6563       if(SendF1APMsg(CU_APP_MEM_REG,CU_POOL)    !=      ROK)
6564       {
6565          DU_LOG("\nERROR  -->  F1AP : Sending UE Context Setup Request Failed");
6566          break;
6567       }
6568       ret = ROK;
6569       break;
6570    }
6571    FreeUeContextSetupReq(f1apMsg);
6572
6573    return ret;
6574 }/* End of BuildAndSendUeContextSetupReq*/
6575
6576 /****************************************************************
6577  * @brief Function to process Ul Rrc Msg received from DU
6578  *
6579  * @details
6580  *
6581  *    Function : procUlRrcMsg
6582  *
6583  *    Functionality:
6584  *         - Function to process Ul Rrc Msg received from DU
6585  *
6586  * @params[in]
6587  * @return ROK     - success
6588  *         RFAILED - failure
6589  *
6590  * ****************************************************************/
6591
6592 uint8_t procUlRrcMsg(F1AP_PDU_t *f1apMsg)
6593 {
6594    uint8_t idx, ret, srbId, rrcMsgType;
6595    uint8_t cuUeF1apId, duUeF1apId;
6596    uint8_t *rrcContainer = NULLP;
6597    uint16_t rrcContLen;
6598    ULRRCMessageTransfer_t *ulRrcMsg = NULLP;
6599
6600    ret = ROK;
6601    ulRrcMsg = &f1apMsg->choice.initiatingMessage->value.choice.ULRRCMessageTransfer;
6602
6603    for(idx=0; idx < ulRrcMsg->protocolIEs.list.count; idx++)
6604    {
6605       switch(ulRrcMsg->protocolIEs.list.array[idx]->id)
6606       {
6607          case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
6608             {
6609                cuUeF1apId = ulRrcMsg->protocolIEs.list.array[idx]->value.choice.GNB_CU_UE_F1AP_ID;
6610                break;
6611             }
6612          case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
6613             {
6614                duUeF1apId = ulRrcMsg->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID;
6615                break;
6616             }
6617          case ProtocolIE_ID_id_SRBID:
6618             srbId = ulRrcMsg->protocolIEs.list.array[idx]->value.choice.SRBID;
6619             break;
6620          case ProtocolIE_ID_id_RRCContainer:
6621             {
6622                rrcContLen = ulRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.size;
6623                CU_ALLOC(rrcContainer, rrcContLen)
6624                   if(!rrcContainer)
6625                   {
6626                      DU_LOG("\nERROR  -->  F1AP : Failed to allocated memory in procUlRrcMsg");
6627                      return RFAILED;
6628                   }
6629                memcpy(rrcContainer, ulRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.buf,\
6630                      rrcContLen);
6631                break;
6632             }
6633
6634          default:
6635             DU_LOG("\nERROR  -->  F1AP : Invalid Event %ld", ulRrcMsg->protocolIEs.list.array[idx]->id);
6636             break;
6637       }
6638    }
6639    if(srbId == 1)
6640    {
6641       f1apMsgDb.dlRrcMsgCount++;
6642       rrcMsgType = setDlRRCMsgType();
6643       if(rrcMsgType == REGISTRATION_ACCEPT)
6644       {
6645          DU_LOG("\nINFO  -->  F1AP: Sending DL RRC MSG for RRC Registration Accept");
6646          ret = BuildAndSendDLRRCMessageTransfer(srbId, rrcMsgType);
6647       }
6648       if(rrcMsgType == UE_CONTEXT_SETUP_REQ)
6649       {
6650          DU_LOG("\nINFO  -->  F1AP: Sending Ue Context Setup Req");
6651          ret = BuildAndSendUeContextSetupReq(cuUeF1apId, duUeF1apId,\
6652                rrcContLen, rrcContainer);
6653       }
6654       if(rrcMsgType == SECURITY_MODE_COMPLETE)
6655       {
6656          /* To trigger the DL RRC Msg for RRC Reconfig */
6657          f1apMsgDb.dlRrcMsgCount++;
6658          rrcMsgType = setDlRRCMsgType();
6659          if(rrcMsgType == RRC_RECONFIG)
6660          {
6661             DU_LOG("\nINFO  -->  F1AP: Sending DL RRC MSG for RRC Reconfig");
6662             BuildAndSendDLRRCMessageTransfer(srbId, rrcMsgType);
6663          }
6664       }
6665       if(rrcMsgType == UE_CONTEXT_MOD_REQ)
6666       {
6667          DU_LOG("\nINFO  -->  F1AP: Sending UE Context Modification Request");
6668          BuildAndSendUeContextModificationReq();
6669       }
6670    }
6671    return ret;
6672 }
6673
6674 /****************************************************************
6675  * @brief Build And Send F1ResetAck
6676  *
6677  * @details
6678  *
6679  *    Function : FreeF1ResetAck
6680  *
6681  *    Functionality:
6682  *         - Build And Send  F1ResetRSP
6683  *
6684  *  @params[in]
6685  * @return ROK     - success
6686  *         RFAILED - failure
6687  *
6688  * ****************************************************************/
6689 void FreeF1ResetAck(F1AP_PDU_t *f1apMsg)
6690 {
6691    uint8_t idx;
6692    ResetAcknowledge_t *f1ResetAck;
6693
6694    if(f1apMsg)
6695    {
6696       if(f1apMsg->choice.successfulOutcome)
6697       {
6698          f1ResetAck= &f1apMsg->choice.successfulOutcome->value.choice.ResetAcknowledge;
6699
6700          if(f1ResetAck->protocolIEs.list.array)
6701          {
6702             for(idx=0; idx<f1ResetAck->protocolIEs.list.count ; idx++)
6703             {
6704                if(f1ResetAck->protocolIEs.list.array[idx])
6705                {
6706                   CU_FREE(f1ResetAck->protocolIEs.list.array[idx], sizeof(ResetAcknowledgeIEs_t));
6707                }
6708             }
6709             CU_FREE(f1ResetAck->protocolIEs.list.array, f1ResetAck->protocolIEs.list.size );
6710          }
6711          CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
6712       }
6713       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
6714    }
6715 }
6716
6717 /****************************************************************
6718  * @brief Build And Send F1ResetAck
6719  *
6720  * @details
6721  *
6722  *    Function : BuildAndSendF1ResetAck
6723  *
6724  *    Functionality:
6725  *         - Build And Send  F1ResetRSP
6726  *
6727  *  @params[in]
6728  * @return ROK     - success
6729  *         RFAILED - failure
6730  *
6731  * ****************************************************************/
6732
6733 uint8_t BuildAndSendF1ResetAck()
6734 {
6735    uint8_t                idx = 0;
6736    uint8_t                elementCnt = 0;
6737    uint8_t                ret = RFAILED;
6738    F1AP_PDU_t             *f1apMsg = NULL;
6739    ResetAcknowledge_t     *f1ResetAck = NULLP;
6740    asn_enc_rval_t         encRetVal;
6741    DU_LOG("\nINFO  -->  F1AP : Building F1 Reset Acknowledgment \n");
6742
6743    do{
6744       /* Allocate the memory for F1ResetRequest_t */
6745       CU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
6746       if(f1apMsg == NULLP)
6747       {
6748          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
6749          break;
6750       }
6751
6752       f1apMsg->present =  F1AP_PDU_PR_successfulOutcome;
6753
6754       CU_ALLOC(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
6755       if(f1apMsg->choice.successfulOutcome == NULLP)
6756       {
6757          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
6758          break;
6759       }
6760
6761       f1apMsg->choice.successfulOutcome->procedureCode = ProcedureCode_id_Reset;
6762       f1apMsg->choice.successfulOutcome->criticality   = Criticality_reject;
6763       f1apMsg->choice.successfulOutcome->value.present = SuccessfulOutcome__value_PR_ResetAcknowledge;
6764       f1ResetAck = &f1apMsg->choice.successfulOutcome->value.choice.ResetAcknowledge;
6765
6766       elementCnt = 1;
6767
6768       f1ResetAck->protocolIEs.list.count = elementCnt;
6769       f1ResetAck->protocolIEs.list.size = elementCnt*sizeof(ResetAcknowledgeIEs_t *);
6770
6771       CU_ALLOC(f1ResetAck->protocolIEs.list.array, f1ResetAck->protocolIEs.list.size );
6772       if(f1ResetAck->protocolIEs.list.array == NULLP)
6773       {
6774          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1ResetAckIEs failed");
6775          break;
6776       }
6777
6778       for(idx=0; idx<elementCnt; idx++)
6779       {
6780          CU_ALLOC(f1ResetAck->protocolIEs.list.array[idx], sizeof(ResetAcknowledgeIEs_t));
6781          if(f1ResetAck->protocolIEs.list.array[idx] == NULLP)
6782          {
6783             break;
6784          }
6785       }
6786       /*TransactionID*/
6787       idx = 0;
6788       f1ResetAck->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_TransactionID;
6789       f1ResetAck->protocolIEs.list.array[idx]->criticality = Criticality_reject;
6790       f1ResetAck->protocolIEs.list.array[idx]->value.present = ResetAcknowledgeIEs__value_PR_TransactionID;
6791       f1ResetAck->protocolIEs.list.array[idx]->value.choice.TransactionID = TRANS_ID;
6792
6793       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
6794
6795       /* Encode the F1SetupRequest type as UPER */
6796       memset(encBuf, 0, ENC_BUF_MAX_LEN);
6797       encBufSize = 0;
6798       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
6799
6800       /* Check encode results */
6801       if(encRetVal.encoded == ENCODE_FAIL)
6802       {
6803          DU_LOG("\nERROR  -->  F1AP : Could not encode F1ResetAck structure (at %s)\n",\
6804                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
6805          break;
6806       }
6807       else
6808       {
6809          DU_LOG("\nDEBUG  -->  F1AP : Created APER encodedbuffer for F1ResetAck \n");
6810          for(int i=0; i< encBufSize; i++)
6811          {
6812             DU_LOG("%x",encBuf[i]);
6813          }
6814       }
6815       /* Sending msg */
6816       if(SendF1APMsg(CU_APP_MEM_REG, CU_POOL) != ROK)
6817       {
6818          DU_LOG("\nERROR  -->  F1AP : Sending F1 Reset Response failed");
6819          break;
6820       }
6821
6822       ret = ROK;
6823       break;
6824    }while(true);
6825
6826    FreeF1ResetAck(f1apMsg);
6827    return ret;
6828 }
6829 void FreeUlTnlInfoforDrb2(ULUPTNLInformation_ToBeSetup_List_t *ulInfo)
6830 {
6831    uint8_t arrIdx =0;
6832
6833    if(ulInfo->list.array)
6834    {
6835       for(arrIdx=0; arrIdx<ulInfo->list.count ; arrIdx++)
6836       {
6837          if(ulInfo->list.array[arrIdx])
6838          {
6839             if(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel )
6840             {
6841                if(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf)
6842                {
6843                   if(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf)
6844                   {
6845                      CU_FREE(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
6846                      gTP_TEID.buf,ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.\
6847                      gTPTunnel->gTP_TEID.size);
6848                   }
6849                   CU_FREE(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
6850                   transportLayerAddress.buf,ulInfo->list.array[arrIdx]->\
6851                   uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.size);
6852                }
6853                CU_FREE(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel,\
6854                sizeof(GTPTunnel_t));
6855             }
6856             CU_FREE(ulInfo->list.array[arrIdx],sizeof(ULUPTNLInformation_ToBeSetup_Item_t));
6857          }
6858       }
6859       CU_FREE(ulInfo->list.array,ulInfo->list.size);
6860    }
6861 }
6862 /*******************************************************************
6863 *
6864 * @brief Builds the Uplink Tunnel Info
6865 *
6866 * @details
6867 *
6868 *    Function : BuildUlTnlInfoforDrb2
6869 *
6870 *    Functionality: Constructs the UL TnlInfo For DRB list
6871 *
6872 * @params[in] ULUPTNLInformation_ToBeSetup_List_t *ulInfo
6873 *
6874 * @return ROK     - success
6875 *         RFAILED - failure
6876 *
6877 * ****************************************************************/
6878 uint8_t BuildUlTnlInfoforDrb2(ULUPTNLInformation_ToBeSetup_List_t *ulInfo)
6879 {
6880    uint8_t arrIdx;
6881    uint8_t ulCnt;
6882
6883    ulCnt = 1;
6884    ulInfo->list.count = ulCnt;
6885    ulInfo->list.size = ulCnt * sizeof(ULUPTNLInformation_ToBeSetup_Item_t *);
6886    CU_ALLOC(ulInfo->list.array,ulInfo->list.size);
6887    if(ulInfo->list.array == NULLP)
6888    {
6889       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildUlTnlInfoforDrb2");
6890       return RFAILED;
6891    }
6892    for(arrIdx=0; arrIdx<ulCnt; arrIdx++)
6893    {
6894       CU_ALLOC(ulInfo->list.array[arrIdx],sizeof(ULUPTNLInformation_ToBeSetup_Item_t));
6895       if(ulInfo->list.array[arrIdx] == NULLP)
6896       {
6897          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildUlTnlInfoforDrb2");
6898          return RFAILED;
6899       }
6900    }
6901
6902    arrIdx = 0;
6903    ulInfo->list.array[arrIdx]->uLUPTNLInformation.present = \
6904    UPTransportLayerInformation_PR_gTPTunnel;
6905
6906    /*GTP TUNNEL*/
6907    CU_ALLOC(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel,\
6908          sizeof(GTPTunnel_t));
6909    if(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel == NULLP)
6910    {
6911       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildUlTnlInfoforDrb2");
6912       return RFAILED;
6913    }
6914    ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
6915       transportLayerAddress.size        = 4*sizeof(uint8_t);
6916    CU_ALLOC(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
6917          transportLayerAddress.buf,ulInfo->list.array[arrIdx]->\
6918          uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.size);
6919    if(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
6920          transportLayerAddress.buf == NULLP)
6921    {
6922       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildUlTnlInfoforDrb2");
6923       return RFAILED;
6924    }
6925
6926    ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
6927       transportLayerAddress.buf[0] = 192;
6928    ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
6929       transportLayerAddress.buf[1] = 168;
6930    ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
6931       transportLayerAddress.buf[2] = 130;
6932    ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
6933       transportLayerAddress.buf[3] = 82;
6934    ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
6935       transportLayerAddress.bits_unused = 0;
6936
6937    /*GTP TEID*/
6938    ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.size\
6939       = 4 * sizeof(uint8_t);
6940    CU_ALLOC(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
6941          gTP_TEID.buf,ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.\
6942          gTPTunnel->gTP_TEID.size);
6943    if(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf\
6944          == NULLP)
6945    {
6946       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildUlTnlInfoforDrb2");
6947       return RFAILED;
6948    }
6949    ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
6950       gTP_TEID.buf[0] = 0;
6951    ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
6952       gTP_TEID.buf[1] = 0;
6953    ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
6954       gTP_TEID.buf[2] = 0;
6955    ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
6956       gTP_TEID.buf[3] = 2;
6957
6958    return ROK;
6959 }/*End of BuildULTnlInfo*/
6960 /*******************************************************************
6961 *
6962 * @brief freeing the DRB 2 item
6963 *
6964 * @details
6965 *
6966 *    Function : FreeDrb2Item
6967 *
6968 *    Functionality: freeing the DRB 2 item
6969 *
6970 * @params[in] DRBs_ToBeSetupMod_Item_t *drbItem
6971 *
6972 * @return ROK     - success
6973 *         RFAILED - failure
6974 *
6975 * ****************************************************************/
6976
6977 void FreeDrb2Item(DRBs_ToBeSetupMod_Item_t *drbItem)
6978 {
6979    uint8_t arrIdx =0;
6980    SNSSAI_t *snssai =NULLP;
6981    Flows_Mapped_To_DRB_List_t *flowMap = NULLP;
6982
6983    drbItem->qoSInformation.present = QoSInformation_PR_choice_extension;
6984    switch(drbItem->qoSInformation.present)
6985    {
6986       case QoSInformation_PR_NOTHING:
6987          break;
6988       case QoSInformation_PR_eUTRANQoS:
6989          {
6990             if(drbItem->qoSInformation.choice.eUTRANQoS)
6991             {
6992                CU_FREE(drbItem->qoSInformation.choice.eUTRANQoS, sizeof(EUTRANQoS_t));
6993             }
6994             break;
6995          }
6996       case QoSInformation_PR_choice_extension:
6997          {
6998             if(drbItem->qoSInformation.choice.choice_extension)
6999             {
7000                FreeQOSInfo(&drbItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS);
7001
7002                snssai = &drbItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI;
7003                if(snssai->sST.buf)
7004                {
7005                   CU_FREE(snssai->sST.buf,snssai->sST.size);
7006                }
7007                if(snssai->sD)
7008                {
7009                   if(snssai->sD->buf)
7010                   {
7011                      CU_FREE(snssai->sD->buf,snssai->sD->size);
7012                   }
7013                   CU_FREE(snssai->sD,sizeof(OCTET_STRING_t));
7014                }
7015
7016                flowMap = &drbItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.flows_Mapped_To_DRB_List;
7017                if(flowMap->list.array)
7018                {
7019                   for(arrIdx=0; arrIdx<flowMap->list.count; arrIdx++)
7020                   {
7021                      if(flowMap->list.array[arrIdx] )
7022                      {
7023                         FreeQOSInfo(&flowMap->list.array[arrIdx]->qoSFlowLevelQoSParameters);
7024                         CU_FREE(flowMap->list.array[arrIdx],sizeof(Flows_Mapped_To_DRB_Item_t));
7025                      }
7026                   }
7027                   CU_FREE(flowMap->list.array,flowMap->list.size);
7028                }
7029
7030                CU_FREE(drbItem->qoSInformation.choice.choice_extension,sizeof(QoSInformation_ExtIEs_t));
7031             }
7032             break;
7033          }
7034
7035    }
7036    FreeUlTnlInfoforDrb2(&drbItem->uLUPTNLInformation_ToBeSetup_List);
7037    if(drbItem->uLConfiguration)
7038    {
7039       CU_FREE(drbItem->uLConfiguration,sizeof(ULConfiguration_t));
7040    }
7041 }
7042 /*******************************************************************
7043 *
7044 * @brief filling the DRB 2 item
7045 *
7046 * @details
7047 *
7048 *    Function : FillDrb2Item
7049 *
7050 *    Functionality: filling the DRB 2 item
7051 *
7052 * @params[in] DRBs_ToBeSetupMod_Item_t *drbItem
7053 *
7054 * @return ROK     - success
7055 *         RFAILED - failure
7056 *
7057 * ****************************************************************/
7058
7059 uint8_t FillDrb2Item(DRBs_ToBeSetupMod_Item_t *drbItem)
7060 {
7061    uint8_t ret = ROK;
7062
7063    /*Drb Id */
7064    drbItem->dRBID = DRB2;
7065
7066    /*qoSInformation*/
7067    drbItem->qoSInformation.present = QoSInformation_PR_choice_extension;
7068
7069    switch(drbItem->qoSInformation.present)
7070    {
7071       case QoSInformation_PR_NOTHING:
7072       {
7073          break;
7074       }
7075       case QoSInformation_PR_eUTRANQoS:
7076       {
7077
7078          CU_ALLOC(drbItem->qoSInformation.choice.eUTRANQoS, sizeof(EUTRANQoS_t));
7079          if(drbItem->qoSInformation.choice.eUTRANQoS)
7080          {
7081             DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in FillDrb2Item");
7082             return RFAILED;
7083          }
7084          drbItem->qoSInformation.choice.eUTRANQoS->qCI = QCI;
7085          drbItem->qoSInformation.choice.eUTRANQoS->allocationAndRetentionPriority.priorityLevel =
7086             PriorityLevel_no_priority;
7087
7088          drbItem->qoSInformation.choice.eUTRANQoS->allocationAndRetentionPriority.pre_emptionCapability =
7089             Pre_emptionCapability_may_trigger_pre_emption;
7090
7091          drbItem->qoSInformation.choice.eUTRANQoS->allocationAndRetentionPriority.pre_emptionVulnerability =
7092             Pre_emptionVulnerability_pre_emptable;
7093
7094          break;
7095       }
7096       case QoSInformation_PR_choice_extension:
7097       {
7098          CU_ALLOC(drbItem->qoSInformation.choice.choice_extension,sizeof(QoSInformation_ExtIEs_t));
7099          if(drbItem->qoSInformation.choice.choice_extension == NULLP)
7100          {
7101             DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in FillDrb2Item");
7102             return RFAILED;
7103          }
7104
7105          drbItem->qoSInformation.choice.choice_extension->id = ProtocolIE_ID_id_DRB_Information;
7106          drbItem->qoSInformation.choice.choice_extension->criticality = Criticality_ignore;
7107          drbItem->qoSInformation.choice.choice_extension->value.present = QoSInformation_ExtIEs__value_PR_DRB_Information;
7108          ret =  BuildQOSInfo(&drbItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS);
7109          if(ret != ROK)
7110          {
7111             DU_LOG("\nERROR  -->  F1AP : BuildQOSInfo failed");
7112             return RFAILED;
7113          }
7114
7115          /*SNSSAI*/
7116          ret = BuildSNSSAI(&drbItem->qoSInformation.choice.\
7117                choice_extension->value.choice.DRB_Information.sNSSAI);
7118          if(ret != ROK)
7119          {
7120             DU_LOG("\nERROR  -->  F1AP : BuildSNSSAI failed");
7121             return RFAILED;
7122          }
7123
7124          /*Flows mapped to DRB List*/
7125          ret = BuildFlowsMap(&drbItem->qoSInformation.choice.\
7126                choice_extension->value.choice.DRB_Information.flows_Mapped_To_DRB_List);
7127          if(ret != ROK)
7128          {
7129             DU_LOG("\nERROR  -->  F1AP : BuildFlowsMap failed");
7130             return RFAILED;
7131          }
7132       }
7133    }
7134
7135    /*ULUPTNLInformation To Be Setup List*/
7136    ret = BuildUlTnlInfoforDrb2(&drbItem->uLUPTNLInformation_ToBeSetup_List);
7137    if(ret != ROK)
7138    {
7139       DU_LOG("\nERROR  -->  F1AP : BuildUlTnlInfoforDrb2 failed");
7140       return RFAILED;
7141    }
7142
7143    /*RLCMode*/
7144    drbItem->rLCMode = RLCMode_rlc_um_bidirectional;
7145
7146    /*UL Configuration*/
7147    CU_ALLOC(drbItem->uLConfiguration,sizeof(ULConfiguration_t));
7148    if(drbItem->uLConfiguration == NULLP)
7149    {
7150       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in FillDrb2Item");
7151       return RFAILED;
7152    }
7153    drbItem->uLConfiguration->uLUEConfiguration = ULUEConfiguration_no_data;
7154    return ROK;
7155 }
7156 /*******************************************************************
7157 *
7158 * @brief Builds the DRB to be Setup Mod ItemIes
7159 *
7160 * @details
7161 *
7162 *    Function : FillDrbItemList
7163 *
7164 *    Functionality: Constructs the DRB to be Setup Mod Item Ies
7165 *
7166 * @params[in] struct DRBs_ToBeSetupMod_ItemIEs *drbItemIe
7167 *
7168 * @return ROK     - success
7169 *         RFAILED - failure
7170 *
7171 * ****************************************************************/
7172
7173 uint8_t FillDrbItemList(struct DRBs_ToBeSetupMod_ItemIEs *drbItemIe)
7174 {
7175    drbItemIe->id = ProtocolIE_ID_id_DRBs_ToBeSetupMod_Item;
7176    drbItemIe->criticality = Criticality_reject;
7177    drbItemIe->value.present = DRBs_ToBeSetupMod_ItemIEs__value_PR_DRBs_ToBeSetupMod_Item;
7178
7179    if(FillDrb2Item(&(drbItemIe->value.choice.DRBs_ToBeSetupMod_Item)) != ROK)
7180    {
7181       DU_LOG("\nERROR  -->  F1AP : FillDrb2Item failed");
7182       return RFAILED;
7183    }
7184    return ROK;
7185 }
7186 /*******************************************************************
7187 *
7188 * @brief free the DRB to be Setup Mod list
7189 *
7190 * @details
7191 *
7192 *    Function : FreeDrbToBeSetupModList
7193 *
7194 *    Functionality: free the DRB to be Setup Mod list
7195 *
7196 * @params[in] DRBs_ToBeSetupMod_List_t *drbSet
7197 *
7198 * @return ROK     - success
7199 *         RFAILED - failure
7200 *
7201 * ****************************************************************/
7202 void FreeDrbToBeSetupModList(DRBs_ToBeSetupMod_List_t *drbSet)
7203 {
7204    uint8_t arrIdx =0;
7205    struct DRBs_ToBeSetupMod_ItemIEs *drbItemIe;
7206
7207    if(drbSet->list.array)
7208    {
7209       for(arrIdx=0; arrIdx<drbSet->list.count ; arrIdx++)
7210       {
7211          if(drbSet->list.array[arrIdx] != NULLP)
7212          {
7213             if(arrIdx == 0)
7214             {
7215                drbItemIe = (DRBs_ToBeSetupMod_ItemIEs_t *)drbSet->list.array[arrIdx];
7216                FreeDrb2Item(&(drbItemIe->value.choice.DRBs_ToBeSetupMod_Item));
7217             }
7218             CU_FREE(drbSet->list.array[arrIdx], sizeof(DRBs_ToBeSetupMod_ItemIEs_t));
7219          }
7220       }
7221       CU_FREE(drbSet->list.array, drbSet->list.size);
7222    }
7223
7224 }
7225
7226
7227 /*******************************************************************
7228 *
7229 * @brief Builds the DRB to be Setup Mod list
7230 *
7231 * @details
7232 *
7233 *    Function : BuildDrbToBeSetupModList
7234 *
7235 *    Functionality: Constructs the DRB to be Setup Mod list
7236 *
7237 * @params[in] DRBs_ToBeSetupMod_List_t *drbSet
7238 *
7239 * @return ROK     - success
7240 *         RFAILED - failure
7241 *
7242 * ****************************************************************/
7243
7244 uint8_t BuildDrbToBeSetupModList(DRBs_ToBeSetupMod_List_t *drbSet)
7245 {
7246    uint8_t ret = ROK;
7247    uint8_t arrIdx =0;
7248    uint8_t drbCnt =0;
7249
7250    drbCnt = 1;
7251    drbSet->list.count = drbCnt;
7252    drbSet->list.size = drbCnt * sizeof(DRBs_ToBeSetupMod_ItemIEs_t *);
7253    CU_ALLOC(drbSet->list.array, drbSet->list.size);
7254    if(drbSet->list.array == NULLP)
7255    {
7256       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDrbToBeSetupModList");
7257       return  RFAILED;
7258    }
7259    for(arrIdx=0; arrIdx<drbCnt; arrIdx++)
7260    {
7261       CU_ALLOC(drbSet->list.array[arrIdx], sizeof(DRBs_ToBeSetupMod_ItemIEs_t));
7262       if(drbSet->list.array[arrIdx] == NULLP)
7263       {
7264          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDrbToBeSetupModList");
7265          return  RFAILED;
7266       }
7267    }
7268
7269    arrIdx=0;
7270    ret = FillDrbItemList((DRBs_ToBeSetupMod_ItemIEs_t *)drbSet->list.array[arrIdx]);
7271    if(ret != ROK)
7272    {
7273       DU_LOG("\nERROR  -->  F1AP : FillDrbItemList failed");
7274    }
7275
7276    return ret;
7277 }
7278 /*******************************************************************
7279  *
7280  * @brief  free the UeContextModification Request
7281  *
7282  * @details
7283  *
7284  *    Function : FreeUeContextModicationRequest
7285  *
7286  *    Functionality : deallocation of memory allocated in UeContextModiification
7287  request
7288  *
7289  * @params[in] F1AP_PDU_t *f1apMsg
7290  *
7291  * @return void
7292 *
7293 * ****************************************************************/
7294 void FreeUeContextModicationRequest(F1AP_PDU_t *f1apMsg)
7295 {
7296    uint8_t arrIdx =0 , ieId=0;
7297    UEContextModificationRequest_t *UeContextModifyReq = NULLP;
7298
7299    if(f1apMsg)
7300    {
7301       if(f1apMsg->choice.initiatingMessage)
7302       {
7303          UeContextModifyReq =&f1apMsg->choice.initiatingMessage->value.choice.UEContextModificationRequest;
7304          if(UeContextModifyReq->protocolIEs.list.array)
7305          {
7306             for( arrIdx = 0 ; arrIdx<UeContextModifyReq->protocolIEs.list.count ; arrIdx++)
7307             {
7308                if(UeContextModifyReq->protocolIEs.list.array[arrIdx])
7309                {
7310                   ieId = UeContextModifyReq->protocolIEs.list.array[arrIdx]->id;
7311                   switch(ieId)
7312                   {
7313                      case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
7314                         break;
7315                      case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
7316                         break;
7317                      case ProtocolIE_ID_id_DRBs_ToBeSetupMod_List:
7318                         {
7319                            FreeDrbToBeSetupModList(&UeContextModifyReq->protocolIEs.list.array[arrIdx]->value.\
7320                            choice.DRBs_ToBeSetupMod_List);
7321                            break;
7322                         }
7323                   }
7324                   CU_FREE(UeContextModifyReq->protocolIEs.list.array[arrIdx], sizeof(UEContextModificationRequest_t));
7325                }
7326             }
7327             CU_FREE(UeContextModifyReq->protocolIEs.list.array, UeContextModifyReq->protocolIEs.list.size);
7328          }
7329          CU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
7330       }
7331       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
7332    }
7333 }
7334 /*******************************************************************
7335  *
7336  * @brief Builds the Ue Context Modification Req
7337  *
7338  * @details
7339  *
7340  *    Function : BuildAndSendUeContextModificationReq
7341  *
7342  *    Functionality: Constructs the Ue Context Modification Req
7343  *
7344  * @params[in]
7345  *
7346  * @return ROK     - success
7347  *         RFAILED - failure
7348  *
7349  * ****************************************************************/
7350 uint8_t BuildAndSendUeContextModificationReq()
7351 {
7352    uint8_t    ieIdx = 0;
7353    uint8_t    elementCnt = 0;
7354    uint8_t    ret = RFAILED;
7355    F1AP_PDU_t *f1apMsg = NULLP;
7356    UEContextModificationRequest_t *ueContextModifyReq = NULLP;
7357
7358    asn_enc_rval_t         encRetVal;
7359    DU_LOG("\nINFO  -->  F1AP : Building Ue context modification request\n");
7360
7361    while(1)
7362    {
7363       CU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
7364       if(f1apMsg == NULLP)
7365       {
7366          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed Ue context modification");
7367          break;
7368       }
7369
7370       f1apMsg->present =  F1AP_PDU_PR_initiatingMessage;
7371
7372       CU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
7373       if(f1apMsg->choice.initiatingMessage == NULLP)
7374       {
7375          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed Ue context modification");
7376          break;
7377       }
7378       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_UEContextModification;
7379       f1apMsg->choice.initiatingMessage->criticality = Criticality_reject;
7380       f1apMsg->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_UEContextModificationRequest;
7381
7382       ueContextModifyReq =&f1apMsg->choice.initiatingMessage->value.choice.UEContextModificationRequest;
7383
7384       elementCnt = 3;
7385       ueContextModifyReq->protocolIEs.list.count = elementCnt;
7386       ueContextModifyReq->protocolIEs.list.size = elementCnt*sizeof(UEContextModificationRequest_t *);
7387
7388       /* Initialize the UE context modification members */
7389       CU_ALLOC(ueContextModifyReq->protocolIEs.list.array, ueContextModifyReq->protocolIEs.list.size);
7390       if(ueContextModifyReq->protocolIEs.list.array == NULLP)
7391       {
7392          DU_LOG("\nERROR  -->  F1AP : Memory allocation for UE context modifcation Request failed");
7393          break;
7394       }
7395
7396       for(ieIdx=0 ; ieIdx<elementCnt; ieIdx++)
7397       {
7398          CU_ALLOC(ueContextModifyReq->protocolIEs.list.array[ieIdx], sizeof(UEContextModificationRequest_t));
7399          if(ueContextModifyReq->protocolIEs.list.array[ieIdx] == NULLP)
7400          {
7401             DU_LOG("\nERROR  -->  F1AP : Memory allocation for UE context modifcation Request failed");
7402             break;
7403          }
7404       }
7405
7406
7407       ieIdx=0;
7408       ueContextModifyReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
7409       ueContextModifyReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
7410       ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present = \
7411       UEContextModificationRequestIEs__value_PR_GNB_CU_UE_F1AP_ID;
7412       ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID =CU_ID;
7413
7414       ieIdx++;
7415       ueContextModifyReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
7416       ueContextModifyReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
7417       ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present=\
7418       UEContextModificationRequestIEs__value_PR_GNB_DU_UE_F1AP_ID;
7419       ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID =DU_ID;
7420
7421       ieIdx++;
7422       ueContextModifyReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_DRBs_ToBeSetupMod_List;
7423       ueContextModifyReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
7424       ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present =\
7425          UEContextModificationRequestIEs__value_PR_DRBs_ToBeSetupMod_List;
7426       ret = BuildDrbToBeSetupModList(&(ueContextModifyReq->protocolIEs.list.array[ieIdx]->\
7427          value.choice.DRBs_ToBeSetupMod_List));
7428       if(ret != ROK)
7429       {
7430          break;
7431       }
7432       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
7433
7434       /* Encode the F1SetupRequest type as APER */
7435       memset(encBuf, 0, ENC_BUF_MAX_LEN);
7436       encBufSize = 0;
7437       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
7438             encBuf);
7439
7440       /* Encode results */
7441       if(encRetVal.encoded == ENCODE_FAIL)
7442       {
7443          DU_LOG("\nERROR  -->  F1AP : Could not encode ueContextModifyReq structure (at %s)\n",\
7444                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
7445          break;
7446       }
7447       else
7448       {
7449          DU_LOG("\nDEBUG  -->  F1AP : Created APER encodedbuffer for ueContextModifyReq\n");
7450          for(ieIdx=0; ieIdx< encBufSize; ieIdx++)
7451          {
7452             DU_LOG("%x",encBuf[ieIdx]);
7453          }
7454       }
7455
7456       if(SendF1APMsg(CU_APP_MEM_REG, CU_POOL) != ROK)
7457       {
7458          DU_LOG("\nERROR  -->  F1AP : Sending Ue context modification request  failed");
7459          break;
7460       }
7461
7462       ret = ROK;
7463       break;
7464
7465    }
7466    FreeUeContextModicationRequest(f1apMsg);
7467    return ret;
7468 }
7469 /*****************************************************************i
7470 *
7471 * @brief Free memory allocated for UE Context Release Command
7472 *
7473 * @details
7474 *
7475 *    Function : FreeUeContextReleaseCommand
7476 *
7477 *    Functionality:
7478 *         - Free memory allocated for UE Context Release Command
7479 *
7480 * @params[in] F1AP_PDU_t *f1apMsg
7481 * @return void
7482 *
7483 * *************************************************************/
7484 void FreeUeContextReleaseCommand(F1AP_PDU_t *f1apMsg)
7485 {
7486    uint8_t ieIdx;
7487    UEContextReleaseCommand_t *ueReleaseCommand = NULLP;
7488
7489    if(f1apMsg)
7490    {
7491       if(f1apMsg->choice.initiatingMessage)
7492       {
7493          ueReleaseCommand =&f1apMsg->choice.initiatingMessage->value.choice.UEContextReleaseCommand;
7494          if(ueReleaseCommand->protocolIEs.list.array)
7495          {
7496             for(ieIdx=0 ; ieIdx<ueReleaseCommand->protocolIEs.list.count; ieIdx++)
7497             {
7498                CU_FREE(ueReleaseCommand->protocolIEs.list.array[ieIdx], sizeof(UEContextReleaseCommand_t));
7499             }
7500             CU_FREE(ueReleaseCommand->protocolIEs.list.array, ueReleaseCommand->protocolIEs.list.size);
7501          }
7502          CU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
7503       }
7504       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
7505    }
7506 }
7507 /*******************************************************************
7508  *
7509  * @brief Builds the Ue Context Release Command
7510  *
7511  * @details
7512 *
7513 *    Function : BuildAndSendUeContextReleaseCommand
7514 *
7515 *    Functionality: Constructs the Ue Context Release Command
7516 *
7517 * @params[in]
7518 *
7519 * @return ROK     - success
7520 *         RFAILED - failure
7521 *
7522 * ****************************************************************/
7523 uint8_t BuildAndSendUeContextReleaseCommand(uint8_t cuUeF1apId, uint8_t duUeF1apId)
7524 {
7525    bool       memAllocFailed = false;
7526    uint8_t    ieIdx = 0,elementCnt = 0, ret = RFAILED, bufLen=0;
7527    F1AP_PDU_t *f1apMsg = NULLP;
7528    UEContextReleaseCommand_t *ueContextReleaseCommand = NULLP;
7529
7530    asn_enc_rval_t         encRetVal;
7531    DU_LOG("\nINFO  -->  F1AP : Building Ue context release command\n");
7532
7533    while(true)
7534    {
7535       CU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
7536       if(f1apMsg == NULLP)
7537       {
7538          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseCommand(): Memory allocation for F1AP-PDU");
7539          break;
7540       }
7541
7542       f1apMsg->present =  F1AP_PDU_PR_initiatingMessage;
7543
7544       CU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
7545       if(f1apMsg->choice.initiatingMessage == NULLP)
7546       {
7547          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseCommand(): Memory allocation for F1AP-PDU failed ");
7548          break;
7549       }
7550       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_UEContextRelease;
7551       f1apMsg->choice.initiatingMessage->criticality = Criticality_reject;
7552       f1apMsg->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_UEContextReleaseCommand;
7553
7554       ueContextReleaseCommand =&f1apMsg->choice.initiatingMessage->value.choice.UEContextReleaseCommand;
7555
7556       elementCnt = 4;
7557       ueContextReleaseCommand->protocolIEs.list.count = elementCnt;
7558       ueContextReleaseCommand->protocolIEs.list.size = elementCnt*sizeof(UEContextReleaseCommand_t*);
7559
7560       /* Initialize the UE context modification members */
7561       CU_ALLOC(ueContextReleaseCommand->protocolIEs.list.array, ueContextReleaseCommand->protocolIEs.list.size);
7562       if(ueContextReleaseCommand->protocolIEs.list.array == NULLP)
7563       {
7564          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseCommand():Memory allocation failed");
7565          break;
7566       }
7567
7568       for(ieIdx=0 ; ieIdx<elementCnt; ieIdx++)
7569       {
7570          CU_ALLOC(ueContextReleaseCommand->protocolIEs.list.array[ieIdx], sizeof(UEContextReleaseCommand_t));
7571          if(ueContextReleaseCommand->protocolIEs.list.array[ieIdx] == NULLP)
7572          {
7573             DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseCommand(): Memory allocation failed ");
7574             memAllocFailed = true;
7575             break;
7576          }
7577       }
7578
7579       if(memAllocFailed == true)
7580       {
7581          break;
7582       }
7583       ieIdx=0;
7584       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
7585       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
7586       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.present = \
7587       UEContextReleaseCommandIEs__value_PR_GNB_CU_UE_F1AP_ID;
7588       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID =cuUeF1apId;
7589
7590       ieIdx++;
7591       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
7592       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
7593       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.present=\
7594       UEContextReleaseCommandIEs__value_PR_GNB_DU_UE_F1AP_ID;
7595       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID =duUeF1apId;
7596
7597       ieIdx++;
7598       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_Cause;
7599       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->criticality = Criticality_ignore;
7600       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.present=\
7601       UEContextReleaseCommandIEs__value_PR_Cause;
7602       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.Cause.present = Cause_PR_radioNetwork;
7603       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.Cause.choice.radioNetwork=\
7604       CauseRadioNetwork_normal_release;
7605
7606       /* RRC Container for RRC release */
7607       ieIdx++;
7608       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_RRCContainer;
7609       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->criticality = Criticality_ignore;
7610       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.present = \
7611       UEContextReleaseCommandIEs__value_PR_RRCContainer;
7612       char secModeBuf[7]={ 0x00, 0x05, 0x13, 0x00, 0x00, 0x00, 0x00};
7613       bufLen =7;
7614       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.size = bufLen;
7615       CU_ALLOC(ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf,
7616       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.size);
7617       if(!ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf)
7618       {
7619       DU_LOG("\nERROR  -->  F1AP : Memory allocation for BuildAndSendUeContextSetupReq failed");
7620       break;
7621       }
7622       memset(ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf, 0, bufLen);
7623       memcpy(ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf, secModeBuf, bufLen);
7624
7625       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
7626
7627       /* Encode the UE Context Release Command type as APER */
7628       memset(encBuf, 0, ENC_BUF_MAX_LEN);
7629       encBufSize = 0;
7630       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
7631             encBuf);
7632
7633       /* Encode results */
7634       if(encRetVal.encoded == ENCODE_FAIL)
7635       {
7636          DU_LOG("\nERROR  -->  F1AP : Could not encode Release Command structure (at %s)\n",\
7637                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
7638          break;
7639       }
7640       else
7641       {
7642          DU_LOG("\nDEBUG  -->  F1AP : Created APER encoded buffer for Ue Context Release Command\n");
7643          for(ieIdx=0; ieIdx< encBufSize; ieIdx++)
7644          {
7645             DU_LOG("%x",encBuf[ieIdx]);
7646          }
7647       }
7648
7649       if(SendF1APMsg(CU_APP_MEM_REG, CU_POOL) != ROK)
7650       {
7651          DU_LOG("\nERROR  -->  F1AP : Sending Ue context Release Command failed");
7652          break;
7653       }
7654
7655       ret = ROK;
7656       break;
7657
7658    }
7659    FreeUeContextReleaseCommand(f1apMsg);
7660    return ret;
7661 }
7662 /*******************************************************************
7663 *
7664 * @brief process Ue context release request
7665 *
7666 * @details
7667 *
7668 *    Function : procUeContextReleaseReq
7669 *
7670 *    Functionality:
7671 *         - process Ue context release request
7672 *
7673 * @params[in] F1AP_PDU_t *f1apMsg
7674 * @return ROK     - success
7675 *         RFAILED - failure
7676 *
7677 * ****************************************************************/
7678 uint8_t procUeContextReleaseReq(F1AP_PDU_t *f1apMsg)
7679 {
7680    uint8_t ieIdx=0, duUeF1apId=0,cuUeF1apId=0;
7681
7682    UEContextReleaseRequest_t *ueReleaseReq = NULLP;
7683    ueReleaseReq = &f1apMsg->choice.initiatingMessage->value.choice.UEContextReleaseRequest;
7684
7685    for(ieIdx=0; ieIdx < ueReleaseReq->protocolIEs.list.count; ieIdx++)
7686    {
7687       switch(ueReleaseReq->protocolIEs.list.array[ieIdx]->id)
7688       {
7689          case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
7690             {
7691                cuUeF1apId = ueReleaseReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID;
7692                break;
7693             }
7694          case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
7695             {
7696                duUeF1apId = ueReleaseReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID;
7697                break;
7698             }
7699          default:
7700               break;
7701       }
7702    }
7703    if(BuildAndSendUeContextReleaseCommand(cuUeF1apId, duUeF1apId) != ROK)
7704    {
7705       DU_LOG("\nERROR  -->  F1AP : procUeContextReleaseReq(): Failed to build Ue Context Release Command ");
7706       return RFAILED;
7707    }
7708    return ROK;
7709 }
7710 /*******************************************************************
7711 *
7712 * @brief processing of Gnb-DU config update
7713 *
7714 * @details
7715 *
7716 *    Function : procGnbDuUpdate
7717 *
7718 *    Functionality:
7719 *         - processing of Gnb-DU config update
7720 *
7721 * @params[in] F1AP_PDU_t *f1apMsg
7722 * @return ROK     - success
7723 *         RFAILED - failure
7724 *
7725 * ****************************************************************/
7726 uint8_t procGnbDuUpdate(F1AP_PDU_t *f1apMsg)
7727 {
7728    bool cellToBeDelete = false;
7729    uint8_t ieIdx = 0;
7730    GNBDUConfigurationUpdate_t *duCfgUpdate = NULLP;
7731
7732    duCfgUpdate = &f1apMsg->choice.initiatingMessage->value.choice.GNBDUConfigurationUpdate;
7733
7734    for(ieIdx=0; ieIdx < duCfgUpdate->protocolIEs.list.count; ieIdx++)
7735    {
7736       switch(duCfgUpdate->protocolIEs.list.array[ieIdx]->id)
7737       {
7738          case ProtocolIE_ID_id_TransactionID:
7739             break;
7740          case ProtocolIE_ID_id_Served_Cells_To_Modify_List:
7741             break;
7742          case ProtocolIE_ID_id_Served_Cells_To_Delete_List:
7743             {
7744                cellToBeDelete = true;
7745                break;
7746             }
7747          case ProtocolIE_ID_id_gNB_DU_ID:
7748             break;
7749       }
7750    }
7751    if(BuildAndSendDUUpdateAck() != ROK)
7752    {
7753       DU_LOG("ERROR  -->  F1AP : Failed to build and send DUUpdateAck");
7754       return RFAILED;
7755    }
7756
7757    if(cellToBeDelete == false)
7758    {
7759       DU_LOG("\nINFO  -->  F1AP : Sending F1 reset request");
7760       if(BuildAndSendF1ResetReq() != ROK)
7761       {
7762          DU_LOG("ERROR  -->  F1AP : Failed to build and send F1 reset request");
7763          return RFAILED;
7764       }
7765    }
7766    else
7767    {
7768       memset(&f1apMsgDb, 0, sizeof(F1apMsgDb));
7769    }
7770
7771    return ROK;
7772 }
7773 /*******************************************************************
7774  *
7775  * @brief Handles received F1AP message and sends back response
7776  *
7777  * @details
7778  *
7779  *    Function : F1APMsgHdlr
7780  *
7781  *    Functionality:
7782  *         - Decodes received F1AP control message
7783  *         - Prepares response message, encodes and sends to SCTP
7784  *
7785  * @params[in]
7786  * @return ROK     - success
7787  *         RFAILED - failure
7788  *
7789  * ****************************************************************/
7790 void F1APMsgHdlr(Buffer *mBuf)
7791 {
7792    int i;
7793    char *recvBuf;
7794    MsgLen copyCnt;
7795    MsgLen recvBufLen;
7796    F1AP_PDU_t *f1apMsg = NULLP;
7797    asn_dec_rval_t rval; /* Decoder return value */
7798    F1AP_PDU_t f1apasnmsg ;
7799
7800    DU_LOG("\nINFO  -->  F1AP : Received F1AP message buffer");
7801    ODU_PRINT_MSG(mBuf, 0,0);
7802
7803    /* Copy mBuf into char array to decode it */
7804    ODU_GET_MSG_LEN(mBuf, &recvBufLen);
7805    CU_ALLOC(recvBuf, (Size)recvBufLen);
7806
7807    if(recvBuf == NULLP)
7808    {
7809       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed");
7810       return;
7811    }
7812    if(ODU_COPY_MSG_TO_FIX_BUF(mBuf, 0, recvBufLen, (Data *)recvBuf, &copyCnt) != ROK)
7813    {
7814       DU_LOG("\nERROR  -->  F1AP : Failed while copying %d", copyCnt);
7815       return;
7816    }
7817
7818    DU_LOG("\nDEBUG  -->  F1AP : Received flat buffer to be decoded : ");
7819    for(i=0; i< recvBufLen; i++)
7820    {
7821       DU_LOG("%x",recvBuf[i]);
7822    }
7823
7824    /* Decoding flat buffer into F1AP messsage */
7825    f1apMsg = &f1apasnmsg;
7826    memset(f1apMsg, 0, sizeof(F1AP_PDU_t));
7827
7828    rval = aper_decode(0, &asn_DEF_F1AP_PDU, (void **)&f1apMsg, recvBuf, recvBufLen, 0, 0);
7829    CU_FREE(recvBuf, (Size)recvBufLen);
7830
7831    if(rval.code == RC_FAIL || rval.code == RC_WMORE)
7832    {
7833       DU_LOG("\nERROR  -->  F1AP : ASN decode failed");
7834       return;
7835    }
7836    DU_LOG("\n");
7837    xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
7838
7839    switch(f1apMsg->present)
7840    {
7841       case F1AP_PDU_PR_initiatingMessage:
7842          {
7843             switch(f1apMsg->choice.initiatingMessage->value.present)
7844             {
7845                case InitiatingMessage__value_PR_Reset:
7846                   {
7847                      DU_LOG("\nINFO  -->  F1AP : F1 reset request received ");
7848                      BuildAndSendF1ResetAck();
7849                      break;
7850                   }
7851
7852                case InitiatingMessage__value_PR_F1SetupRequest:
7853                   {
7854                      DU_LOG("\nINFO  -->  F1AP : F1 setup request received");
7855                      BuildAndSendF1SetupRsp();
7856                      break;
7857                   }
7858
7859                case InitiatingMessage__value_PR_GNBDUConfigurationUpdate:
7860                   {
7861                      DU_LOG("\nINFO  -->  F1AP : GNB-DU config update received");
7862                      procGnbDuUpdate(f1apMsg);
7863                      break;
7864                   }
7865                case InitiatingMessage__value_PR_InitialULRRCMessageTransfer:
7866                   {
7867                      DU_LOG("\nINFO  -->  F1AP : Received InitialULRRCMessageTransfer");
7868                      procInitULRRCMsg(f1apMsg);
7869                      break;
7870                   }
7871                case InitiatingMessage__value_PR_ULRRCMessageTransfer:
7872                   {
7873                      DU_LOG("\nINFO  -->  F1AP : Received ULRRCMessageTransfer");
7874                      procUlRrcMsg(f1apMsg);
7875                      break;
7876                   }
7877
7878                case InitiatingMessage__value_PR_RRCDeliveryReport:
7879                   {
7880                      DU_LOG("\nINFO  -->  F1AP : Received RRC delivery report");
7881                      break;
7882                   }
7883                case InitiatingMessage__value_PR_UEContextReleaseRequest:
7884                   {
7885                      DU_LOG("\nINFO  -->  F1AP : Received UE Context Release Request");
7886                      procUeContextReleaseReq(f1apMsg);
7887                      break;
7888                   }
7889                default:
7890                   {
7891                      DU_LOG("\nERROR  -->  F1AP : Invalid type of intiating message [%d]",\
7892                            f1apMsg->choice.initiatingMessage->value.present);
7893                      return;
7894                   }
7895             }/* End of switch(initiatingMessage) */
7896             break;
7897          }
7898
7899       case F1AP_PDU_PR_successfulOutcome:
7900          {
7901             switch(f1apMsg->choice.successfulOutcome->value.present)
7902             {
7903                case SuccessfulOutcome__value_PR_ResetAcknowledge:
7904                   {
7905                      DU_LOG("\nINFO  -->  F1Reset Acknowledgement is received successfully ");
7906                      break;
7907                   }
7908                case SuccessfulOutcome__value_PR_UEContextSetupResponse:
7909                   {
7910                      DU_LOG("\nINFO  -->  F1AP : UE ContextSetupResponse received");
7911                      f1apMsgDb.dlRrcMsgCount++; /* keeping DL RRC Msg Count */
7912                      break;
7913                   }
7914                case SuccessfulOutcome__value_PR_UEContextModificationResponse:
7915                   {
7916                      DU_LOG("\nINFO  -->  F1AP : UE Context Modification Response received");
7917                      break;
7918                   }
7919                case SuccessfulOutcome__value_PR_UEContextReleaseComplete:
7920                   {
7921                       DU_LOG("\nINFO  -->  F1AP : UE Context release complete received");
7922                       break;
7923                   }
7924                default:
7925                   {
7926                      DU_LOG("\nERROR  -->  F1AP : Invalid type of successful outcome message [%d]",\
7927                            f1apMsg->choice.successfulOutcome->value.present);
7928                      return;
7929                   }
7930             }/* End of switch(successfulOutcome) */
7931             break;
7932          }
7933       default:
7934          {
7935             DU_LOG("\nERROR  -->  F1AP : Invalid type of f1apMsg->present [%d]",f1apMsg->present);
7936             return;
7937          }
7938    }/* End of switch(f1apMsg->present) */
7939
7940 } /* End of F1APMsgHdlr */
7941
7942 /**********************************************************************
7943   End of file
7944  **********************************************************************/