src/cu_stub/cu_f1ap_msg_hdl.c

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