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