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