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