src/cu_stub/cu_f1ap_msg_hdl.c

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