src/cu_stub/cu_f1ap_msg_hdl.c

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