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