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