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 SECURITY_MODE_COMPLETE:
1749         rrcMsgType = SECURITY_MODE_COMPLETE;
1750         break;
1751       case RRC_RECONFIG:
1752         rrcMsgType = RRC_RECONFIG;
1753         break;
1754       default:
1755         break;
1756    }
1757    return rrcMsgType;
1758 }
1759
1760 /*******************************************************************
1761  *
1762  * @brief Function to build Initial UL RRC Message
1763  *
1764  * @details
1765  *
1766  *    Function : procInitULRRCMsg
1767  *
1768  *    Functionality: Function to build Initial UL RRC Message
1769  *
1770  * @params[in]
1771  *
1772  * @return ROK     - success
1773  *         RFAILED - failure
1774  *
1775  * ****************************************************************/
1776
1777 uint8_t procInitULRRCMsg(F1AP_PDU_t *f1apMsg)
1778 {
1779    uint8_t idx, rrcMsgType;
1780    uint8_t ret =ROK;
1781    InitialULRRCMessageTransfer_t *initULRRCMsg = NULLP;
1782    DU_LOG("\n filling the required values in DB in procInitULRRCMsg");
1783
1784    initULRRCMsg = &f1apMsg->choice.initiatingMessage->value.choice.InitialULRRCMessageTransfer;
1785
1786    for(idx=0; idx < initULRRCMsg->protocolIEs.list.count; idx++)
1787    {
1788       switch(initULRRCMsg->protocolIEs.list.array[idx]->id)
1789       {
1790          case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
1791             break;
1792          case ProtocolIE_ID_id_NRCGI:
1793             break;
1794          case ProtocolIE_ID_id_C_RNTI:
1795             break;
1796          case ProtocolIE_ID_id_RRCContainer:
1797             break;
1798          case ProtocolIE_ID_id_DUtoCURRCContainer:
1799             {
1800                if((initULRRCMsg->protocolIEs.list.array[idx]->value.choice\
1801                         .DUtoCURRCContainer.size > 0) && (initULRRCMsg->protocolIEs\
1802                            .list.array[idx]->value.choice.DUtoCURRCContainer.buf != NULLP))
1803                {
1804                   DU_LOG("\n Received Du to Cu RRC Container ");
1805                   f1apMsgDb.duToCuContainer.size = initULRRCMsg->protocolIEs\
1806                                                    .list.array[idx]->value.choice.DUtoCURRCContainer.size;
1807                   CU_ALLOC(f1apMsgDb.duToCuContainer.buf, \
1808                         f1apMsgDb.duToCuContainer.size);
1809                   if(f1apMsgDb.duToCuContainer.buf != NULLP)
1810                   {
1811                      memcpy(f1apMsgDb.duToCuContainer.buf, initULRRCMsg->protocolIEs\
1812                            .list.array[idx]->value.choice.DUtoCURRCContainer.buf, f1apMsgDb\
1813                            .duToCuContainer.size);
1814                   }
1815                }
1816                else
1817                {
1818                   DU_LOG("\n Failed to receive Du to Cu RRC Container ");
1819                   ret = RFAILED;
1820                }
1821                break;
1822             }
1823          default:
1824             DU_LOG("\n Invalid Event %ld", initULRRCMsg->protocolIEs.list.array[idx]->id);
1825             break;
1826       }
1827    }
1828    if(ret == ROK)
1829    {
1830       f1apMsgDb.dlRrcMsgCount++;
1831       rrcMsgType = setDlRRCMsgType();
1832       ret = BuildAndSendDLRRCMessageTransfer(SRB0, rrcMsgType);
1833    }
1834    return ret;
1835 }
1836
1837 /*******************************************************************
1838  *
1839  * @brief Builds Nrcgi
1840  *
1841  * @details
1842  *
1843  *    Function : BuildNrcgi
1844  *
1845  *    Functionality: Building the PLMN ID and NR Cell id
1846  *
1847  * @params[in] NRCGI_t *nrcgi
1848  * @return ROK     - success
1849  *         RFAILED - failure
1850  *
1851  * ****************************************************************/
1852 uint8_t BuildNrcgi(NRCGI_t *nrcgi)
1853 {
1854    uint8_t ret;
1855    uint8_t unused_bits = 4;
1856    uint8_t byteSize = 5;
1857    uint8_t val = 1;
1858    /* Allocate Buffer Memory */
1859    nrcgi->pLMN_Identity.size = 3 * sizeof(uint8_t);
1860    CU_ALLOC(nrcgi->pLMN_Identity.buf, nrcgi->pLMN_Identity.size);
1861    if(nrcgi->pLMN_Identity.buf == NULLP)
1862    {
1863       return RFAILED;
1864    }
1865    ret = buildPlmnId(cuCfgParams.plmn , nrcgi->pLMN_Identity.buf);
1866
1867    if(ret != ROK)
1868    {
1869       return RFAILED;
1870    }
1871    nrcgi->nRCellIdentity.size = byteSize * sizeof(uint8_t);
1872    CU_ALLOC(nrcgi->nRCellIdentity.buf, nrcgi->nRCellIdentity.size);
1873    if(nrcgi->nRCellIdentity.buf == NULLP)
1874    {
1875       return RFAILED;
1876    }
1877 #if 0
1878    ret = fillBitString(&nrcgi->nRCellIdentity, unused, byteSize, val);
1879    if(ret != ROK)
1880    {
1881       return RFAILED;
1882    }
1883 #endif
1884    memset(nrcgi->nRCellIdentity.buf, 0, nrcgi->nRCellIdentity.size);
1885    nrcgi->nRCellIdentity.buf[0] |= val;
1886    nrcgi->nRCellIdentity.bits_unused = unused_bits;
1887
1888    return ROK;
1889 }
1890 /*******************************************************************
1891  *
1892  * @brief Builds Special cell list for UE Setup Request
1893  *
1894  * @details
1895  *
1896  *    Function : BuildSplCellList
1897  *
1898  *    Functionality: Constructs the Special Cell list for UESetReq
1899  *
1900  * @params[in] SCell_ToBeSetup_List_t *spCellLst
1901  *
1902  * @return ROK     - success
1903  *         RFAILED - failure
1904  *
1905  * ****************************************************************/
1906 uint8_t BuildSplCellList(SCell_ToBeSetup_List_t *spCellLst)
1907 {
1908    uint8_t  cellCnt;
1909    uint8_t  idx;
1910    uint8_t  ret;
1911    cellCnt = 1;
1912    spCellLst->list.count = cellCnt;
1913    spCellLst->list.size = cellCnt * sizeof(SCell_ToBeSetup_ItemIEs_t *);
1914    CU_ALLOC(spCellLst->list.array,spCellLst->list.size);
1915    if(spCellLst->list.array == NULLP)
1916    {
1917       return RFAILED;
1918    }
1919    for(idx=0; idx<cellCnt; idx++)
1920    {
1921       CU_ALLOC(spCellLst->list.array[idx],sizeof(SCell_ToBeSetup_ItemIEs_t));
1922       if(spCellLst->list.array[idx] == NULLP)
1923       {
1924          return RFAILED;
1925       }
1926    }
1927    idx = 0;
1928    spCellLst->list.array[idx]->id = ProtocolIE_ID_id_SCell_ToBeSetup_Item;
1929    spCellLst->list.array[idx]->criticality = Criticality_ignore;
1930    spCellLst->list.array[idx]->value.present =\
1931                                               SCell_ToBeSetup_ItemIEs__value_PR_SCell_ToBeSetup_Item;
1932    /* Special Cell ID -NRCGI */
1933    ret = BuildNrcgi(&spCellLst->list.array[idx]->value.choice.SCell_ToBeSetup_Item.sCell_ID);
1934    if(ret != ROK)
1935    {
1936       return RFAILED;
1937    }
1938    /*Special Cell Index*/
1939    spCellLst->list.array[idx]->value.choice.SCell_ToBeSetup_Item.sCellIndex = 1;
1940    return ROK;
1941 }/* End of BuildSplCellList*/
1942
1943 /*******************************************************************
1944  *
1945  * @brief Builds SRBS to be setup
1946  *
1947  * @details
1948  *
1949  *    Function : BuildSRBSetup
1950  *
1951  *    Functionality: Constructs the SRB's for UESetReq
1952  *
1953  * @params[in] SRBs_ToBeSetup_List_t *srbSet
1954  *
1955  * @return ROK     - success
1956  *         RFAILED - failure
1957  *
1958  * ****************************************************************/
1959 uint8_t BuildSRBSetup(SRBs_ToBeSetup_List_t *srbSet)
1960 {
1961    uint8_t idx;
1962    uint8_t srbCnt;
1963    srbCnt = 1;
1964    srbSet->list.count = srbCnt;
1965    srbSet->list.size = srbCnt*sizeof(SRBs_ToBeSetup_ItemIEs_t *);
1966    CU_ALLOC(srbSet->list.array,srbSet->list.size);
1967    if(srbSet->list.array == NULLP)
1968    {
1969       return RFAILED;
1970    }
1971    for(idx=0; idx<srbCnt; idx++)
1972    {
1973       CU_ALLOC(srbSet->list.array[idx],sizeof(SRBs_ToBeSetup_ItemIEs_t));
1974       if(srbSet->list.array[idx] == NULLP)
1975       {
1976          return RFAILED;
1977       }
1978    }
1979    idx = 0;
1980    srbSet->list.array[idx]->id = ProtocolIE_ID_id_SRBs_ToBeSetup_Item;
1981    srbSet->list.array[idx]->criticality = Criticality_ignore;
1982    srbSet->list.array[idx]->value.present = \
1983       SRBs_ToBeSetup_ItemIEs__value_PR_SRBs_ToBeSetup_Item;
1984    srbSet->list.array[idx]->value.choice.SRBs_ToBeSetup_Item.sRBID = 2;
1985    return ROK;
1986 }/* End of BuildSRBSetup*/
1987
1988 /*******************************************************************
1989  *
1990  * @brief Builds QOS Info for DRB Setum Item
1991  *
1992  * @details
1993  *
1994  *    Function : BuildQOSInfo
1995  *
1996  *    Functionality: Constructs the QOS Info for DRB Setup Item
1997  *
1998  * @params[in] QoSInformation_t *qosinfo
1999  *
2000  * @return ROK     - success
2001  *         RFAILED - failure
2002  *
2003  * ****************************************************************/
2004 uint8_t BuildQOSInfo(QoSFlowLevelQoSParameters_t *drbQos)
2005 {
2006    /* NonDynamic5QIDescriptor */
2007    drbQos->qoS_Characteristics.present = QoS_Characteristics_PR_non_Dynamic_5QI;
2008    CU_ALLOC(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI,sizeof(NonDynamic5QIDescriptor_t));
2009    if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI == NULLP)
2010    {
2011       return RFAILED;
2012    }
2013    /*FiveQI*/
2014    drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->fiveQI = 0;
2015    /*AveragingWindow*/
2016    CU_ALLOC(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow,\
2017          sizeof(AveragingWindow_t));
2018    if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow == \
2019          NULLP)
2020    {
2021       return RFAILED;
2022    }
2023    *(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow) = 0;
2024    /*MaxDataBurstVolume*/
2025    CU_ALLOC(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume,\
2026          sizeof(MaxDataBurstVolume_t));
2027    if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume == \
2028          NULLP)
2029    {
2030       return RFAILED;
2031    }
2032    *(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume) = 0;
2033
2034    /*nRGRAN Allocation Retention Priority*/
2035    drbQos->nGRANallocationRetentionPriority.priorityLevel = PriorityLevel_highest;
2036    drbQos->nGRANallocationRetentionPriority.pre_emptionCapability = Pre_emptionCapability_may_trigger_pre_emption;
2037    drbQos->nGRANallocationRetentionPriority.pre_emptionVulnerability = Pre_emptionVulnerability_not_pre_emptable;
2038
2039    /* TO DO: GBR_QoSFlowInformation */
2040    return ROK;
2041 }/*End of BuildQOSInfo*/
2042
2043 /*******************************************************************
2044  *
2045  * @brief Builds SNSSAI
2046  *
2047  * @details
2048  *
2049  *    Function : BuildSNSSAI
2050  *
2051  *    Functionality: Constructs the SNSSAI For DRB list
2052  *
2053  * @params[in] SNSSAI_t *snssai
2054  *
2055  * @return ROK     - success
2056  *         RFAILED - failure
2057  *
2058  * ****************************************************************/
2059 uint8_t BuildSNSSAI(SNSSAI_t *snssai)
2060 {
2061    /*SNSSAI*/
2062    /*ssT*/
2063    snssai->sST.size = sizeof(uint8_t);
2064    CU_ALLOC(snssai->sST.buf,snssai->sST.size);
2065    if(snssai->sST.buf == NULLP)
2066    {
2067       return RFAILED;
2068    }
2069    snssai->sST.buf[0] = 3;
2070    /*sD*/
2071    CU_ALLOC(snssai->sD,sizeof(OCTET_STRING_t));
2072    if(snssai->sD == NULLP)
2073    {
2074       return RFAILED;
2075    }
2076    snssai->sD->size = 3*sizeof(uint8_t);
2077    CU_ALLOC(snssai->sD->buf,snssai->sD->size);
2078    if(snssai->sD->buf == NULLP)
2079    {
2080       return RFAILED;
2081    }
2082    snssai->sD->buf[0] = 3;
2083    snssai->sD->buf[1] = 6;
2084    snssai->sD->buf[2] = 9;
2085    return ROK;
2086 }/*End of BuildSNSSAI*/
2087
2088 /*******************************************************************
2089  *
2090  * @brief Builds the flow map.
2091  *
2092  * @details
2093  *
2094  *    Function : BuildFlowsMap
2095  *
2096  *    Functionality: Constructs the flowmap For DRB list
2097  *
2098  * @params[in] Flows_Mapped_To_DRB_List_t *flowMap
2099  *
2100  * @return ROK     - success
2101  *         RFAILED - failure
2102  *
2103  * ****************************************************************/
2104 uint8_t BuildFlowsMap(Flows_Mapped_To_DRB_List_t *flowMap)
2105 {
2106    uint8_t  ret;
2107    uint8_t  idx;
2108    uint8_t  flowCnt;
2109    flowCnt = 1;
2110    flowMap->list.count = flowCnt;
2111    flowMap->list.size = flowCnt * sizeof(Flows_Mapped_To_DRB_Item_t *);
2112    CU_ALLOC(flowMap->list.array,flowMap->list.size);
2113    if(flowMap->list.array == NULLP)
2114    {
2115       return RFAILED;
2116    }
2117    for(idx=0; idx<flowCnt; idx++)
2118    {
2119       CU_ALLOC(flowMap->list.array[idx],sizeof(Flows_Mapped_To_DRB_Item_t));
2120       if(flowMap->list.array[idx] == NULLP)
2121       {
2122          return RFAILED;
2123       }
2124    }
2125    idx = 0;
2126    flowMap->list.array[idx]->qoSFlowIdentifier = 0;
2127    ret = BuildQOSInfo(&flowMap->list.array[idx]->qoSFlowLevelQoSParameters);
2128    if(ret != ROK)
2129    {
2130       return RFAILED;
2131    }
2132    return ROK;
2133 }/*End of BuildFlowsMap*/
2134
2135 /*******************************************************************
2136  *
2137  * @brief Builds the Uplink Tunnel Info
2138  *
2139  * @details
2140  *
2141  *    Function : BuildULTnlInfo
2142  *
2143  *    Functionality: Constructs the UL TnlInfo For DRB list
2144  *
2145  * @params[in] ULUPTNLInformation_ToBeSetup_List_t *ulInfo
2146  *
2147  * @return ROK     - success
2148  *         RFAILED - failure
2149  *
2150  * ****************************************************************/
2151 uint8_t BuildULTnlInfo(ULUPTNLInformation_ToBeSetup_List_t *ulInfo)
2152 {
2153    uint8_t idx;
2154    uint8_t ulCnt;
2155    ulCnt = 1;
2156    ulInfo->list.count = ulCnt;
2157    ulInfo->list.size = ulCnt * sizeof(ULUPTNLInformation_ToBeSetup_Item_t *);
2158    CU_ALLOC(ulInfo->list.array,ulInfo->list.size);
2159    if(ulInfo->list.array == NULLP)
2160    {
2161       return RFAILED;
2162    }
2163    for(idx=0; idx<ulCnt; idx++)
2164    {
2165       CU_ALLOC(ulInfo->list.array[idx],sizeof(ULUPTNLInformation_ToBeSetup_Item_t));
2166       if(ulInfo->list.array[idx] == NULLP)
2167       {
2168          return RFAILED;
2169       }
2170    }
2171    idx = 0;
2172    ulInfo->list.array[idx]->uLUPTNLInformation.present = \
2173                                                          UPTransportLayerInformation_PR_gTPTunnel;
2174    /*GTP TUNNEL*/
2175    CU_ALLOC(ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel,\
2176          sizeof(GTPTunnel_t));
2177    if(ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel == NULLP)
2178    {
2179       return RFAILED;
2180    }
2181    ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->\
2182       transportLayerAddress.size        = 4*sizeof(uint8_t);
2183    CU_ALLOC(ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->\
2184          transportLayerAddress.buf,ulInfo->list.array[idx]->\
2185          uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.size);
2186    if(ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->\
2187          transportLayerAddress.buf == NULLP)
2188    {
2189       return RFAILED;
2190    }
2191    ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->\
2192       transportLayerAddress.buf[0] = 4;
2193    ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->\
2194       transportLayerAddress.buf[1] = 4;
2195    ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->\
2196       transportLayerAddress.buf[2] = 4;
2197    ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->\
2198       transportLayerAddress.buf[3] = 5;
2199    ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->\
2200       transportLayerAddress.bits_unused = 0;
2201    /*GTP TEID*/
2202    ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.size\
2203       = 4 * sizeof(uint8_t);
2204    CU_ALLOC(ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->\
2205          gTP_TEID.buf,ulInfo->list.array[idx]->uLUPTNLInformation.choice.\
2206          gTPTunnel->gTP_TEID.size);
2207    if(ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf\
2208          == NULLP)
2209    {
2210       return RFAILED;
2211    }
2212    ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->\
2213       gTP_TEID.buf[0] = 11;
2214    ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->\
2215       gTP_TEID.buf[1] = 0;
2216    ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->\
2217       gTP_TEID.buf[2] = 0;
2218    ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->\
2219       gTP_TEID.buf[3] = 1;
2220
2221    return ROK;
2222 }/*End of BuildULTnlInfo*/
2223
2224 /*******************************************************************
2225  *
2226  * @brief Builds DRBS to be setup
2227  *
2228  * @details
2229  *
2230  *    Function : BuildDRBSetup
2231  *
2232  *    Functionality: Constructs the DRB's for UESetReq
2233  *
2234  * @params[in] DRBs_ToBeSetup_List_t *drbSet
2235  *
2236  * @return ROK     - success
2237  *         RFAILED - failure
2238  *
2239  * ****************************************************************/
2240 uint8_t BuildDRBSetup(DRBs_ToBeSetup_List_t *drbSet)
2241 {
2242    uint8_t BuildQOSInforet;
2243    uint8_t BuildSNSSAIret;
2244    uint8_t BuildFlowsMapret;
2245    uint8_t BuildULTnlInforet;
2246    uint8_t idx;
2247    uint8_t drbCnt;
2248    DRBs_ToBeSetup_Item_t *drbSetItem;
2249    drbCnt = 1;
2250    drbSet->list.count = drbCnt;
2251    drbSet->list.size = drbCnt*sizeof(DRBs_ToBeSetup_ItemIEs_t *);
2252    CU_ALLOC(drbSet->list.array,drbSet->list.size);
2253    if(drbSet->list.array == NULLP)
2254    {
2255       return RFAILED;
2256    }
2257    for(idx=0; idx<drbCnt; idx++)
2258    {
2259       CU_ALLOC(drbSet->list.array[idx],sizeof(DRBs_ToBeSetup_ItemIEs_t));
2260       if(drbSet->list.array[idx] == NULLP)
2261       {
2262          return RFAILED;
2263       }
2264    }
2265    idx = 0;
2266    drbSet->list.array[idx]->id = ProtocolIE_ID_id_DRBs_ToBeSetup_Item;
2267    drbSet->list.array[idx]->criticality = Criticality_ignore;
2268    drbSet->list.array[idx]->value.present = \
2269                                             DRBs_ToBeSetup_ItemIEs__value_PR_DRBs_ToBeSetup_Item;
2270    drbSetItem = &drbSet->list.array[idx]->value.choice.DRBs_ToBeSetup_Item;
2271    /*dRBID*/
2272    drbSetItem->dRBID = 1;
2273    /*qoSInformation*/
2274    drbSetItem->qoSInformation.present = QoSInformation_PR_choice_extension;
2275    CU_ALLOC(drbSetItem->qoSInformation.choice.choice_extension,sizeof(QoSInformation_ExtIEs_t));
2276    if(drbSetItem->qoSInformation.choice.choice_extension == NULLP)
2277    {
2278       return RFAILED;
2279    }
2280    drbSetItem->qoSInformation.choice.choice_extension->id = \
2281                                                             ProtocolIE_ID_id_DRB_Information;
2282    drbSetItem->qoSInformation.choice.choice_extension->criticality = \
2283                                                                      Criticality_ignore;
2284    drbSetItem->qoSInformation.choice.choice_extension->value.present = \
2285                                                                        QoSInformation_ExtIEs__value_PR_DRB_Information;
2286   BuildQOSInforet =  BuildQOSInfo(&drbSetItem->qoSInformation.choice.\
2287          choice_extension->value.choice.DRB_Information.dRB_QoS);
2288    if(BuildQOSInforet != ROK)
2289    {
2290       return RFAILED;
2291    }
2292    /*SNSSAI*/
2293    BuildSNSSAIret = BuildSNSSAI(&drbSetItem->qoSInformation.choice.\
2294          choice_extension->value.choice.DRB_Information.sNSSAI);
2295    if(BuildSNSSAIret != ROK)
2296    {
2297       return RFAILED;
2298    }
2299    /*Flows mapped to DRB List*/
2300    BuildFlowsMapret = BuildFlowsMap(&drbSetItem->qoSInformation.choice.\
2301          choice_extension->value.choice.DRB_Information.flows_Mapped_To_DRB_List);
2302    if(BuildFlowsMapret != ROK)
2303    {
2304       return RFAILED;
2305    }
2306    /*ULUPTNLInformation To Be Setup List*/
2307    BuildULTnlInforet = BuildULTnlInfo(&drbSetItem->uLUPTNLInformation_ToBeSetup_List);
2308    if(BuildULTnlInforet != ROK)
2309    {
2310       return RFAILED;
2311    }
2312    /*RLCMode*/
2313    drbSetItem->rLCMode = RLCMode_rlc_um_bidirectional;
2314
2315    /*UL Configuration*/
2316    CU_ALLOC(drbSetItem->uLConfiguration,sizeof(ULConfiguration_t));
2317    if(drbSetItem->uLConfiguration == NULLP)
2318    {
2319       return RFAILED;
2320    }
2321    drbSetItem->uLConfiguration->uLUEConfiguration = ULUEConfiguration_no_data;
2322    return ROK;
2323 }/* End of BuildDRBSetup*/
2324
2325 /*******************************************************************
2326  *
2327  * @brief Deallocating memory of function BuildAndSendUESetReq
2328  *
2329  * @details
2330  *
2331  *    Function : FreeNrcgi
2332  *
2333  *    Functionality: Deallocating memory for function BuildNrcgi
2334  *
2335  * @params[in] NRCGI_t *nrcgi
2336  *
2337  * @return void
2338  *
2339  *******************************************************************/
2340 void FreeNrcgi(NRCGI_t *nrcgi)
2341 {
2342    if(nrcgi->pLMN_Identity.buf != NULLP)
2343    {
2344       if(nrcgi->nRCellIdentity.buf != NULLP)
2345       {
2346          CU_FREE(nrcgi->nRCellIdentity.buf, nrcgi->nRCellIdentity.size);
2347       }
2348       CU_FREE(nrcgi->pLMN_Identity.buf, nrcgi->pLMN_Identity.size);
2349    }
2350 }
2351 /*******************************************************************
2352  *
2353  * @brief  Deallocating memory of function BuildAndSendUESetReq
2354  *
2355  * @details
2356  *
2357  *    Function : FreeSplCellList
2358  *
2359  *    Functionality: Deallocating memory for function BuildSplCellList
2360  *
2361  * @params[in] SCell_ToBeSetup_List_t *spCellLst
2362  *
2363  * @return void
2364  *
2365  *
2366  * *****************************************************************/
2367 void FreeSplCellList(SCell_ToBeSetup_List_t *spCellLst)
2368 {
2369    uint8_t  cellidx;
2370    if(spCellLst->list.array != NULLP)
2371    {
2372       for(cellidx=0; cellidx<spCellLst->list.count; cellidx++)
2373       {
2374          if(cellidx==0&&spCellLst->list.array[cellidx]!=NULLP)
2375          {
2376             FreeNrcgi(&spCellLst->list.array[cellidx]->value.choice.SCell_ToBeSetup_Item.sCell_ID);
2377          }
2378          if(spCellLst->list.array[cellidx]!=NULLP)
2379          {
2380             CU_FREE(spCellLst->list.array[cellidx],sizeof(SCell_ToBeSetup_ItemIEs_t));
2381          }
2382       }
2383       CU_FREE(spCellLst->list.array,spCellLst->list.size);
2384    }
2385 }
2386 /*******************************************************************
2387  *
2388  * @brief Deallocating memory of function BuildAndSendUESetReq
2389  *
2390  * @details
2391  *
2392  *    Function : FreeSRBSetup
2393  *
2394  *    Functionality: Deallocating memory for function BuildSRBSetup
2395  *
2396  * @params[in] SRBs_ToBeSetup_List_t *srbSet
2397  *
2398  * @return void
2399  *
2400  *
2401  * ******************************************************************/
2402 void FreeSRBSetup(SRBs_ToBeSetup_List_t *srbSet)
2403 {
2404    uint8_t srbidx;
2405    if(srbSet->list.array != NULLP)
2406    {
2407       for(srbidx=0; srbidx<srbSet->list.count; srbidx++)
2408       {
2409          if(srbSet->list.array[srbidx]!=NULLP)
2410          {
2411             CU_FREE(srbSet->list.array[srbidx],sizeof(SRBs_ToBeSetup_ItemIEs_t));
2412          }
2413       }
2414       CU_FREE(srbSet->list.array,srbSet->list.size);
2415    }
2416 }
2417 /*******************************************************************
2418  *
2419  * @brief Deallocating memory of function BuildAndSendUESetReq
2420  *
2421  * @details
2422  *
2423  *    Function : FreeQOSInfo
2424  *
2425  *    Functionality:  Deallocating memory for function BuildQOSInfo
2426  *
2427  * @params[in] QoSFlowLevelQoSParameters_t *drbQos
2428  *
2429  * @return void
2430  *
2431  * ****************************************************************/
2432 void FreeQOSInfo(QoSFlowLevelQoSParameters_t *drbQos)
2433 {
2434    if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI != NULLP)
2435    {
2436       if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow!=NULLP)
2437       {
2438          if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume!=NULLP)
2439          {
2440             CU_FREE(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume,\
2441                   sizeof(MaxDataBurstVolume_t));
2442          }
2443          CU_FREE(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow,\
2444                sizeof(AveragingWindow_t));
2445       }
2446       CU_FREE(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI,\
2447             sizeof(NonDynamic5QIDescriptor_t));
2448    }
2449 }
2450 /*******************************************************************
2451  *
2452  * @brief Deallocating memory of function BuildAndSendUESetReq
2453  *
2454  * @details
2455  *
2456  *    Function : FreeULTnlInfo
2457  *
2458  *    Functionality:  Deallocating memory for function BuildULTnlInfo
2459  *
2460  * @params[in] ULUPTNLInformation_ToBeSetup_List_t *ulInfo
2461  *
2462  * @return void
2463  *
2464
2465  * ****************************************************************/
2466 void FreeULTnlInfo(ULUPTNLInformation_ToBeSetup_List_t *ulInfo)
2467 {
2468    uint8_t ulidx=0;
2469    if(ulInfo->list.array != NULLP)
2470    {
2471       for(ulidx=0; ulidx<ulInfo->list.count; ulidx++)
2472       {
2473          if(ulidx==0&&ulInfo->list.array[ulidx]!=NULLP)
2474          {
2475             if(ulInfo->list.array[ulidx]->uLUPTNLInformation.choice.gTPTunnel!=NULLP)
2476             {
2477                if(ulInfo->list.array[ulidx]->uLUPTNLInformation.choice.gTPTunnel->\
2478                      transportLayerAddress.buf != NULLP)
2479                {
2480                   if(ulInfo->list.array[ulidx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf\
2481                         !=NULLP)
2482                   {
2483                      CU_ALLOC(ulInfo->list.array[ulidx]->uLUPTNLInformation.choice.gTPTunnel->\
2484                            gTP_TEID.buf,ulInfo->list.array[ulidx]->uLUPTNLInformation.choice.\
2485                            gTPTunnel->gTP_TEID.size);
2486                   }
2487                   CU_FREE(ulInfo->list.array[ulidx]->uLUPTNLInformation.choice.gTPTunnel->\
2488                         transportLayerAddress.buf,ulInfo->list.array[ulidx]->\
2489                         uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.size);
2490                }
2491                CU_FREE(ulInfo->list.array[ulidx]->uLUPTNLInformation.choice.gTPTunnel,\
2492                      sizeof(GTPTunnel_t));
2493             }
2494          }
2495          if(ulInfo->list.array[ulidx]!=NULLP)
2496          {
2497             CU_FREE(ulInfo->list.array[ulidx],sizeof(ULUPTNLInformation_ToBeSetup_Item_t));
2498          }
2499       }
2500       CU_FREE(ulInfo->list.array,ulInfo->list.size);
2501    }
2502 }
2503 /*******************************************************************
2504  *
2505  * @brief Deallocating memory for BuildAndSendUESetReq
2506  *
2507  * @details
2508  *
2509  *    Function : FreeDRBSetup
2510  *
2511  *    Functionality:  Deallocating memory for BuildDRBSetup
2512  *
2513  * @params[in] DRBs_ToBeSetup_List_t *drbSet
2514  *
2515  * @return void
2516  *
2517  * ****************************************************************/
2518 void FreeDRBSetup(DRBs_ToBeSetup_List_t *drbSet)
2519 {
2520    DRBs_ToBeSetup_Item_t *drbSetItem;
2521    uint8_t  flowidx;
2522    uint8_t  drbidx;
2523    if(drbSet->list.array == NULLP)
2524    {
2525       for(drbidx=0; drbidx<drbSet->list.count; drbidx++)
2526       {
2527          if(drbidx==0&&drbSet->list.array[drbidx] != NULLP)
2528          {
2529             drbSetItem =&drbSet->list.array[drbidx]->value.choice.DRBs_ToBeSetup_Item;
2530             if(drbSetItem->qoSInformation.choice.choice_extension != NULLP)
2531             {
2532                if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
2533                      qoS_Characteristics.choice.non_Dynamic_5QI !=NULLP)
2534                {
2535                   if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
2536                         qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow!=NULLP)
2537                   {
2538                      if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
2539                            qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume!=NULLP)
2540                      {
2541                         if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sST.buf!=NULLP)
2542                         {
2543                            if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD!=NULLP)
2544                            {
2545                               if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD->buf!=NULLP)
2546                               {
2547                                  if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.\
2548                                        flows_Mapped_To_DRB_List.list.array != NULLP)
2549                                  {
2550                                     for(flowidx=0;flowidx<drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.\
2551                                           flows_Mapped_To_DRB_List.list.count; flowidx++)
2552                                     {
2553                                        if(flowidx==0&&drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
2554                                              DRB_Information.flows_Mapped_To_DRB_List.list.array[flowidx]!=NULLP)
2555                                        {
2556                                           if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
2557                                                 DRB_Information.flows_Mapped_To_DRB_List.list.array[flowidx]->qoSFlowLevelQoSParameters.\
2558                                                 qoS_Characteristics.choice.non_Dynamic_5QI!=NULLP)
2559                                           {
2560                                              if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
2561                                                    DRB_Information.flows_Mapped_To_DRB_List.list.array[flowidx]->qoSFlowLevelQoSParameters.\
2562                                                    qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow!=NULLP)
2563                                              {
2564                                                 if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
2565                                                       DRB_Information.flows_Mapped_To_DRB_List.list.array[flowidx]->qoSFlowLevelQoSParameters.\
2566                                                       qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume!=NULLP)
2567                                                 {
2568                                                    FreeULTnlInfo(&drbSetItem->uLUPTNLInformation_ToBeSetup_List);
2569                                                    CU_FREE(drbSetItem->uLConfiguration,sizeof(ULConfiguration_t));
2570
2571                                                    CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
2572                                                          DRB_Information.flows_Mapped_To_DRB_List.list.array[flowidx]->qoSFlowLevelQoSParameters.\
2573                                                          qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume,\
2574                                                          sizeof(MaxDataBurstVolume_t));
2575                                                 }
2576                                                 CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
2577                                                       DRB_Information.flows_Mapped_To_DRB_List.list.array[flowidx]->qoSFlowLevelQoSParameters.\
2578                                                       qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow,sizeof(AveragingWindow_t));
2579                                              }
2580                                              CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
2581                                                    DRB_Information.flows_Mapped_To_DRB_List.list.array[flowidx]->qoSFlowLevelQoSParameters.\
2582                                                    qoS_Characteristics.choice.non_Dynamic_5QI,sizeof(NonDynamic5QIDescriptor_t));
2583                                           }
2584                                        }
2585                                        if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
2586                                              DRB_Information.flows_Mapped_To_DRB_List.list.array[flowidx]!=NULLP)
2587                                        {
2588                                           CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
2589                                                 DRB_Information.flows_Mapped_To_DRB_List.list.array[flowidx],sizeof(Flows_Mapped_To_DRB_Item_t));
2590                                        }
2591                                     }
2592                                     CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.\
2593                                           flows_Mapped_To_DRB_List.list.array,drbSetItem->qoSInformation.choice.choice_extension->value.\
2594                                           choice.DRB_Information.flows_Mapped_To_DRB_List.list.size);
2595                                  }
2596                                  CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD->buf,\
2597                                        drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD->size);
2598                               }
2599                               CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD,\
2600                                     sizeof(OCTET_STRING_t));
2601                            }
2602                            CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sST.buf,\
2603                                  drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sST.size);
2604                         }
2605                         CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
2606                               qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume,sizeof(MaxDataBurstVolume_t));
2607                      }
2608                      CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
2609                            qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow,sizeof(AveragingWindow_t));
2610                   }
2611                   CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
2612                         qoS_Characteristics.choice.non_Dynamic_5QI, sizeof(NonDynamic5QIDescriptor_t));
2613                }
2614                CU_FREE(drbSetItem->qoSInformation.choice.choice_extension,sizeof(QoSInformation_ExtIEs_t));
2615             }
2616          }
2617          if(drbSet->list.array[drbidx]!=NULLP)
2618          {
2619             CU_FREE(drbSet->list.array[drbidx],sizeof(DRBs_ToBeSetup_ItemIEs_t));
2620          }
2621       }
2622       CU_FREE(drbSet->list.array,drbSet->list.size);
2623    }
2624 }
2625
2626
2627 /*******************************************************************
2628  *
2629  * @brief Free the UE Setup Request
2630  *
2631  * @details
2632  *
2633  *    Function : FreeUeContextSetupReq
2634  *
2635  *    Functionality: Deallocate the memory of BuildUESetReq
2636  *
2637  * @params[in]  F1AP_PDU_t  *f1apMsg
2638  *
2639  * @return void
2640  *
2641  *
2642  * ****************************************************************/
2643 void FreeUeContextSetupReq(F1AP_PDU_t  *f1apMsg)
2644 {
2645    uint8_t idx, ieId;
2646    UEContextSetupRequest_t  *ueSetReq = NULLP;
2647
2648    if(f1apMsg != NULLP)
2649    {
2650       if(f1apMsg->choice.initiatingMessage != NULLP)
2651       {
2652          ueSetReq = &f1apMsg->choice.initiatingMessage->value.choice.UEContextSetupRequest;
2653          if(ueSetReq->protocolIEs.list.array != NULLP)
2654          {
2655             for(idx = 0; idx < ueSetReq->protocolIEs.list.count; idx++)
2656             {
2657                if(ueSetReq->protocolIEs.list.array[idx])
2658                {
2659                   switch(ueSetReq->protocolIEs.list.array[idx]->id)
2660                   {
2661                      case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
2662                         break;
2663                      case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
2664                         break;
2665                      case ProtocolIE_ID_id_SpCell_ID:
2666                         FreeNrcgi(&ueSetReq->protocolIEs.list.array[idx]->value.choice.NRCGI);
2667                         break;
2668                      case ProtocolIE_ID_id_ServCellIndex:
2669                         break;
2670                      case ProtocolIE_ID_id_SpCellULConfigured:
2671                         break;
2672                      case ProtocolIE_ID_id_CUtoDURRCInformation:
2673                         FreeCuToDuInfo(&ueSetReq->protocolIEs.list.array[idx]->value.choice.CUtoDURRCInformation);
2674                         break;
2675                      case ProtocolIE_ID_id_SCell_ToBeSetup_List:
2676                         FreeSplCellList(&ueSetReq->protocolIEs.list.array[idx]->value.choice.SCell_ToBeSetup_List);
2677                         break;
2678                      case ProtocolIE_ID_id_SRBs_ToBeSetup_List:
2679                         FreeSRBSetup(&ueSetReq->protocolIEs.list.array[idx]->value.choice.SRBs_ToBeSetup_List);
2680                         break;
2681                      case ProtocolIE_ID_id_DRBs_ToBeSetup_List:
2682                         FreeDRBSetup(&ueSetReq->protocolIEs.list.array[idx]->value.choice.DRBs_ToBeSetup_List);
2683                         break;
2684                      case ProtocolIE_ID_id_RRCContainer:
2685                         if(ueSetReq->protocolIEs.list.array[idx]->value.choice.RRCContainer.buf != NULLP)
2686                         {
2687                           CU_ALLOC(ueSetReq->protocolIEs.list.array[idx]->value.choice.RRCContainer.buf, \
2688                           ueSetReq->protocolIEs.list.array[idx]->value.choice.RRCContainer.size);
2689                         }
2690                         break;
2691                      default:
2692                         printf("\nF1AP: Invalid event type %ld", ueSetReq->protocolIEs.list.array[idx]->id);
2693                   }
2694                }
2695                break;
2696             }
2697             for(ieId=0; ieId<idx; ieId++)
2698             {
2699                if(ueSetReq->protocolIEs.list.array[ieId] != NULLP)
2700                {
2701                   CU_FREE(ueSetReq->protocolIEs.list.array[ieId],sizeof(UEContextSetupRequestIEs_t));
2702                }
2703             }
2704             CU_FREE(ueSetReq->protocolIEs.list.array,ueSetReq->protocolIEs.list.size);
2705          }
2706          CU_FREE(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
2707       }
2708       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
2709    }
2710 }
2711
2712 /**Filling cell group info **/
2713 /*******************************************************************
2714  *
2715  * @brief Build Control resource set to add/modify list
2716  *
2717  * @details
2718  *
2719  *    Function : BuildControlRSetToAddModList
2720  *
2721  *    Functionality: Build Control resource set to add/modify list
2722  *
2723  * @params[in]
2724  * struct PDCCH_Config__controlResourceSetToAddModList *controlRSetList
2725  *
2726  * @return ROK     - success
2727  *         RFAILED - failure
2728  *
2729  * ****************************************************************/
2730 uint8_t BuildControlRSetToAddModList
2731 (
2732 struct PDCCH_Config__controlResourceSetToAddModList *controlRSetList
2733 )
2734 {
2735    uint8_t idx;
2736    uint8_t elementCnt;
2737    uint8_t numBytes, bitsUnused;
2738    struct ControlResourceSet *controlRSet;
2739    uint8_t freqDomainResource[FREQ_DOM_RSRC_SIZE] = {0};
2740    uint8_t coreset0EndPrb, coreset1StartPrb, coreset1NumPrb;
2741
2742    elementCnt = 1;
2743    controlRSetList->list.count = elementCnt;
2744    controlRSetList->list.size = \
2745        elementCnt * sizeof(struct ControlResourceSet *);
2746
2747    controlRSetList->list.array = NULLP;
2748    CU_ALLOC(controlRSetList->list.array, controlRSetList->list.size);
2749    if(!controlRSetList->list.array)
2750    {
2751       DU_LOG("\nF1AP : Memory allocation failed in BuildControlRSetToAddModList");
2752       return RFAILED;
2753    }
2754
2755    for(idx = 0; idx < elementCnt; idx++)
2756    {
2757       controlRSetList->list.array[idx] = NULLP;
2758       CU_ALLOC(controlRSetList->list.array[idx], sizeof(struct ControlResourceSet));
2759       if(!controlRSetList->list.array[idx])
2760       {
2761          DU_LOG("\nF1AP : Memory allocation failed in BuildControlRSetToAddModList");
2762          return RFAILED;
2763       }
2764    }
2765
2766    idx=0;
2767    controlRSet = controlRSetList->list.array[idx];
2768    controlRSet->controlResourceSetId = PDCCH_CTRL_RSRC_SET_ONE_ID;
2769
2770    /* Values harcoded according to our design:
2771     * size 6 bytes
2772     * 3 LSBs unsued
2773     * Bit string stored ff0000000000
2774     */
2775    numBytes = 6;
2776    bitsUnused = 3;
2777    controlRSet->frequencyDomainResources.size = numBytes * sizeof(uint8_t);
2778    controlRSet->frequencyDomainResources.buf = NULLP;
2779         CU_ALLOC(controlRSet->frequencyDomainResources.buf, \
2780            controlRSet->frequencyDomainResources.size);
2781         if(!controlRSet->frequencyDomainResources.buf)
2782         {
2783            DU_LOG("\nF1AP : Memory allocation failed in BuildControlRSetToAddModList");
2784                 return RFAILED;
2785    }
2786
2787    memset(controlRSet->frequencyDomainResources.buf, 0, FREQ_DOM_RSRC_SIZE);
2788    coreset0EndPrb = CORESET0_END_PRB;
2789    coreset1StartPrb = coreset0EndPrb + 6;
2790    coreset1NumPrb = CORESET1_NUM_PRB;
2791    /* calculate the PRBs */
2792    freqDomRscAllocType0(((coreset1StartPrb)/6), (coreset1NumPrb/6), freqDomainResource);
2793    memcpy(controlRSet->frequencyDomainResources.buf, freqDomainResource, FREQ_DOM_RSRC_SIZE);
2794    controlRSet->frequencyDomainResources.bits_unused = bitsUnused;
2795
2796    controlRSet->duration = PDCCH_CTRL_RSRC_SET_ONE_DURATION;
2797    controlRSet->cce_REG_MappingType.present = \
2798       ControlResourceSet__cce_REG_MappingType_PR_nonInterleaved;
2799
2800    controlRSet->precoderGranularity = PDCCH_CTRL_RSRC_SET_ONE_PRECOD_GRANULARITY;
2801    controlRSet->tci_StatesPDCCH_ToAddList = NULLP;
2802         controlRSet->tci_StatesPDCCH_ToReleaseList = NULLP;
2803         controlRSet->tci_PresentInDCI = NULLP;
2804 #if 0
2805    uint8_t tciStateIdx;
2806
2807    CU_ALLOC(controlRset->tci_StatesPDCCH_ToAddList, \
2808       sizeof(struct ControlResourceSet__tci_StatesPDCCH_ToAddList));
2809    if(!controlRset->tci_StatesPDCCH_ToAddList)
2810    {
2811       DU_LOG("\nF1AP : Memory allocation failed in BuildControlRSetToAddModList");
2812       return RFAILED;
2813    }
2814
2815    elementCnt = 1;
2816    controlRset->tci_StatesPDCCH_ToAddList->list.count = elementCnt;
2817    controlRset->tci_StatesPDCCH_ToAddList->list.size = elementCnt * sizeof(TCI_StateId_t *);
2818    CU_ALLOC(controlRset->tci_StatesPDCCH_ToAddList->list.array, \
2819       controlRset->tci_StatesPDCCH_ToAddList->list.size)
2820    if(!controlRset->tci_StatesPDCCH_ToAddList->list.array)
2821    {
2822       DU_LOG("\nF1AP : Memory allocation failed in BuildControlRSetToAddModList");
2823       return RFAILED;
2824    }
2825
2826    for(tciStateIdx = 0; tciStateIdx <elementCntl; tciStateIdx++)
2827    {
2828       CU_ALLOC(controlRset->tci_StatesPDCCH_ToAddList->list.array[tciStateIdx], sizeof(TCI_StateId_t));
2829       if(!controlRset->tci_StatesPDCCH_ToAddList->list.array[tciStateIdx])
2830       {
2831          DU_LOG("\nF1AP : Memory allocation failed in BuildControlRSetToAddModList");
2832          return RFAILED;
2833       }
2834    }
2835
2836    tciStateIdx = 0;
2837    /* TODO */
2838    *(controlRset->tci_StatesPDCCH_ToAddList->list.array[tciStateIdx]);
2839
2840    CU_ALLOC(controlRset->tci_PresentInDCI, sizeof(long));
2841    if(!controlRset->tci_PresentInDCI)
2842    {
2843       DU_LOG("\nF1AP : Memory allocation failed in BuildControlRSetToAddModList");
2844       return RFAILED;
2845    }
2846    /* TODO */
2847    *(controlRset->tci_PresentInDCI);
2848 #endif
2849
2850    controlRSet->pdcch_DMRS_ScramblingID = NULLP;
2851    CU_ALLOC(controlRSet->pdcch_DMRS_ScramblingID, sizeof(long));
2852    if(!controlRSet->pdcch_DMRS_ScramblingID)
2853    {
2854       DU_LOG("\nF1AP : Memory allocation failed in BuildControlRSetToAddModList");
2855       return RFAILED;
2856    }
2857    *(controlRSet->pdcch_DMRS_ScramblingID) = SCRAMBLING_ID;
2858
2859    return ROK;
2860 } /* End BuildControlRSetToAddModList */
2861
2862 /*******************************************************************
2863  *
2864  * @brief Build search space to add/modify list
2865  *
2866  * @details
2867  *
2868  *    Function : BuildSearchSpcToAddModList
2869  *
2870  *    Functionality: Build search space to add/modify list
2871  *
2872  * @params[in]
2873  * @return ROK     - success
2874  *         RFAILED - failure
2875  *
2876  * ****************************************************************/
2877 uint8_t BuildSearchSpcToAddModList
2878 (
2879 struct PDCCH_Config__searchSpacesToAddModList *searchSpcList
2880 )
2881 {
2882    uint8_t idx;
2883         uint8_t numBytes;
2884         uint8_t byteIdx;
2885         uint8_t bitsUnused;
2886    uint8_t elementCnt;
2887    struct SearchSpace *searchSpc;
2888
2889    elementCnt = 1;
2890    searchSpcList->list.count = elementCnt;
2891    searchSpcList->list.size = elementCnt * sizeof(struct SearchSpace *);
2892
2893         searchSpcList->list.array = NULLP;
2894    CU_ALLOC(searchSpcList->list.array, searchSpcList->list.size);
2895    if(!searchSpcList->list.array)
2896    {
2897       DU_LOG("\nF1AP : Memory allocation failed in BuildSearchSpcToAddModList");
2898       return RFAILED;
2899    }
2900
2901    for(idx = 0; idx < elementCnt; idx++)
2902    {
2903            searchSpcList->list.array[idx] = NULLP;
2904       CU_ALLOC(searchSpcList->list.array[idx], sizeof(struct SearchSpace));
2905       if(!searchSpcList->list.array[idx])
2906       {
2907          DU_LOG("\nF1AP : Memory allocation failed in BuildSearchSpcToAddModList");
2908          return RFAILED;
2909       }
2910    }
2911
2912    idx = 0;
2913    searchSpc = searchSpcList->list.array[idx];
2914
2915    searchSpc->searchSpaceId = PDCCH_SRCH_SPC_TWO_ID;
2916
2917    searchSpc->controlResourceSetId = NULLP;
2918    CU_ALLOC(searchSpc->controlResourceSetId, sizeof(ControlResourceSetId_t));
2919    if(!searchSpc->controlResourceSetId)
2920    {
2921       DU_LOG("\nF1AP : Memory allocation failed in BuildSearchSpcToAddModList");
2922       return RFAILED;
2923    }
2924    *(searchSpc->controlResourceSetId) = PDCCH_CTRL_RSRC_SET_ONE_ID;
2925
2926    searchSpc->monitoringSlotPeriodicityAndOffset = NULLP;
2927    CU_ALLOC(searchSpc->monitoringSlotPeriodicityAndOffset, \
2928       sizeof(struct SearchSpace__monitoringSlotPeriodicityAndOffset));
2929    if(!searchSpc->monitoringSlotPeriodicityAndOffset)
2930         {
2931            DU_LOG("\nF1AP : Memory allocation failed in BuildSearchSpcToAddModList");
2932                 return RFAILED;
2933         }
2934    searchSpc->monitoringSlotPeriodicityAndOffset->present = \
2935            SearchSpace__monitoringSlotPeriodicityAndOffset_PR_sl1;
2936
2937    searchSpc->duration = NULLP;
2938    searchSpc->monitoringSymbolsWithinSlot = NULLP;
2939         CU_ALLOC(searchSpc->monitoringSymbolsWithinSlot, sizeof(BIT_STRING_t));
2940         if(!searchSpc->monitoringSymbolsWithinSlot)
2941         {
2942            DU_LOG("\nF1AP : Memory allocation failed in BuildSearchSpcToAddModList");
2943                 return RFAILED;
2944         }
2945
2946         /* Values taken from reference logs :
2947          * size 2 bytes
2948          * 2 LSBs unsued
2949          * Bit string stores 8000
2950          */
2951    numBytes = 2;
2952         bitsUnused = 2;
2953
2954    searchSpc->monitoringSymbolsWithinSlot->size = numBytes * sizeof(uint8_t);
2955         searchSpc->monitoringSymbolsWithinSlot->buf = NULLP;
2956         CU_ALLOC(searchSpc->monitoringSymbolsWithinSlot->buf, \
2957            searchSpc->monitoringSymbolsWithinSlot->size);
2958         if(!searchSpc->monitoringSymbolsWithinSlot->buf)
2959         {
2960            DU_LOG("\nF1AP : Memory allocation failed in BuildSearchSpcToAddModList");
2961                 return RFAILED;
2962         }
2963
2964         byteIdx = 0;
2965         searchSpc->monitoringSymbolsWithinSlot->buf[byteIdx++] = \
2966          PDCCH_SYMBOL_WITHIN_SLOT /* setting MSB to 128 i.e. 0x80 */;
2967         searchSpc->monitoringSymbolsWithinSlot->buf[byteIdx++] = 0;
2968         searchSpc->monitoringSymbolsWithinSlot->bits_unused = bitsUnused;
2969
2970    searchSpc->nrofCandidates = NULLP;
2971    CU_ALLOC(searchSpc->nrofCandidates, sizeof(struct SearchSpace__nrofCandidates));
2972    if(!searchSpc->nrofCandidates)
2973    {
2974       DU_LOG("\nF1AP : Memory allocation failed in BuildSearchSpcToAddModList");
2975       return RFAILED;
2976    }
2977
2978    searchSpc->nrofCandidates->aggregationLevel1 = \
2979            PDCCH_SRCH_SPC_TWO_AGG_LVL1_CANDIDATE;
2980    searchSpc->nrofCandidates->aggregationLevel2 = \
2981            PDCCH_SRCH_SPC_TWO_AGG_LVL2_CANDIDATE;
2982    searchSpc->nrofCandidates->aggregationLevel4 = \
2983            PDCCH_SRCH_SPC_TWO_AGG_LVL4_CANDIDATE;
2984    searchSpc->nrofCandidates->aggregationLevel8 = \
2985            PDCCH_SRCH_SPC_TWO_AGG_LVL8_CANDIDATE;
2986    searchSpc->nrofCandidates->aggregationLevel16 = \
2987            PDCCH_SRCH_SPC_TWO_AGG_LVL16_CANDIDATE;
2988
2989    searchSpc->searchSpaceType = NULLP;
2990    CU_ALLOC(searchSpc->searchSpaceType, sizeof(struct SearchSpace__searchSpaceType));
2991    if(!searchSpc->searchSpaceType)
2992    {
2993       DU_LOG("\nF1AP : Memory allocation failed in BuildSearchSpcToAddModList");
2994       return RFAILED;
2995    }
2996
2997    searchSpc->searchSpaceType->present = SearchSpace__searchSpaceType_PR_ue_Specific;
2998
2999    searchSpc->searchSpaceType->choice.ue_Specific = NULLP;
3000    CU_ALLOC(searchSpc->searchSpaceType->choice.ue_Specific, \
3001       sizeof(struct SearchSpace__searchSpaceType__ue_Specific));
3002    if(!searchSpc->searchSpaceType->choice.ue_Specific)
3003    {
3004       DU_LOG("\nF1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3005       return RFAILED;
3006    }
3007    searchSpc->searchSpaceType->choice.ue_Specific->dci_Formats = \
3008            PDCCH_SRCH_SPC_TWO_UE_SPEC_DCI_FORMAT;
3009
3010    return ROK;
3011 }/* End BuildSearchSpcToAddModList */
3012
3013 /*******************************************************************
3014  *
3015  * @brief Builds BWP DL dedicated PDCCH config
3016  *
3017  * @details
3018  *
3019  *    Function : BuildBWPDlDedPdcchCfg
3020  *
3021  *    Functionality: Builds BWP DL dedicated PDCCH config
3022  *
3023  * @params[in] struct PDCCH_Config *pdcchCfg
3024  *
3025  * @return ROK     - success
3026  *         RFAILED - failure
3027  *
3028  * ****************************************************************/
3029 uint8_t BuildBWPDlDedPdcchCfg(struct PDCCH_Config *pdcchCfg)
3030 {
3031    pdcchCfg->controlResourceSetToAddModList = NULLP;
3032    CU_ALLOC(pdcchCfg->controlResourceSetToAddModList, \
3033       sizeof(struct PDCCH_Config__controlResourceSetToAddModList));
3034    if(!pdcchCfg->controlResourceSetToAddModList)
3035    {
3036       DU_LOG("\nF1AP : Memory allocation failed in BuildBWPDlDedPdcchCfg");
3037       return RFAILED;
3038    }
3039
3040         if(BuildControlRSetToAddModList(pdcchCfg->controlResourceSetToAddModList) != ROK)
3041         {
3042            return RFAILED;
3043         }
3044
3045    pdcchCfg->controlResourceSetToReleaseList = NULLP;
3046
3047    pdcchCfg->searchSpacesToAddModList = NULLP;
3048         CU_ALLOC(pdcchCfg->searchSpacesToAddModList, \
3049            sizeof(struct PDCCH_Config__searchSpacesToAddModList));
3050         if(!pdcchCfg->searchSpacesToAddModList)
3051         {
3052            DU_LOG("\nF1AP : Memory allocation failed in BuildBWPDlDedPdcchCfg");
3053                 return RFAILED;
3054         }
3055
3056         if(BuildSearchSpcToAddModList(pdcchCfg->searchSpacesToAddModList) != ROK)
3057         {
3058            return RFAILED;
3059         }
3060
3061    pdcchCfg->searchSpacesToReleaseList = NULLP;
3062         pdcchCfg->downlinkPreemption = NULLP;
3063         pdcchCfg->tpc_PUSCH = NULLP;
3064         pdcchCfg->tpc_PUCCH = NULLP;
3065         pdcchCfg->tpc_SRS = NULLP;
3066
3067    return ROK;
3068 }
3069
3070 /*******************************************************************
3071  *
3072  * @brief Builds DMRS DL PDSCH Mapping type A
3073  *
3074  * @details
3075  *
3076  *    Function : BuildDMRSDLPdschMapTypeA
3077  *
3078  *    Functionality: Builds DMRS DL PDSCH Mapping type A
3079  *
3080  * @params[in]
3081  * struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA *dmrsDlCfg
3082  * @return ROK     - success
3083  *         RFAILED - failure
3084  *
3085  * ****************************************************************/
3086 uint8_t BuildDMRSDLPdschMapTypeA
3087 (
3088 struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA *dmrsDlCfg
3089 )
3090 {
3091    dmrsDlCfg->present = PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA_PR_setup;
3092         dmrsDlCfg->choice.setup = NULLP;
3093    CU_ALLOC(dmrsDlCfg->choice.setup, sizeof(struct DMRS_DownlinkConfig));
3094    if(!dmrsDlCfg->choice.setup)
3095    {
3096       DU_LOG("\nF1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
3097       return RFAILED;
3098    }
3099
3100         dmrsDlCfg->choice.setup->dmrs_Type = NULLP;
3101         dmrsDlCfg->choice.setup->dmrs_AdditionalPosition = NULLP;
3102    CU_ALLOC(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition, sizeof(long));
3103    if(!dmrsDlCfg->choice.setup->dmrs_AdditionalPosition)
3104    {
3105       DU_LOG("\nF1AP : Memory allocation failed in BuildDMRSDLPdschMapTypeA");
3106       return RFAILED;
3107    }
3108    *(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition) = DMRS_ADDITIONAL_POS;
3109
3110         dmrsDlCfg->choice.setup->maxLength = NULLP;
3111         dmrsDlCfg->choice.setup->scramblingID0 = NULLP;
3112         dmrsDlCfg->choice.setup->scramblingID1 = NULLP;
3113         dmrsDlCfg->choice.setup->phaseTrackingRS = NULLP;
3114
3115    return ROK;
3116 }
3117
3118 /*******************************************************************
3119  *
3120  * @brief Builds TCI states to add/modify list
3121  *
3122  * @details
3123  *
3124  *    Function : BuildTCIStatesToAddModList
3125  *
3126  *    Functionality:Builds TCI states to add/modify list
3127  *
3128  * @params[in]
3129  * struct PDSCH_Config__tci_StatesToAddModList *tciStatesList
3130  *
3131  * @return ROK     - success
3132  *         RFAILED - failure
3133  *
3134  * ****************************************************************/
3135 uint8_t BuildTCIStatesToAddModList(struct PDSCH_Config__tci_StatesToAddModList *tciStatesList)
3136 {
3137    return ROK;
3138 }
3139
3140 /*******************************************************************
3141  *
3142  * @brief Builds PDSCH time domain allocation list
3143  *
3144  * @details
3145  *
3146  *    Function : BuildPdschTimeDomAllocList
3147  *
3148  *    Functionality: Builds PDSCH time domain allocation list
3149  *
3150  * @params[in]
3151  * struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList
3152  *
3153  * @return ROK     - success
3154  *         RFAILED - failure
3155  *
3156  * ****************************************************************/
3157 uint8_t BuildPdschTimeDomAllocList
3158 (
3159 struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList
3160 )
3161 {
3162    uint8_t idx;
3163    uint8_t elementCnt;
3164         struct PDSCH_TimeDomainResourceAllocation *timeDomAlloc;
3165
3166    timeDomAllocList->present = \
3167            PDSCH_Config__pdsch_TimeDomainAllocationList_PR_setup;
3168
3169    timeDomAllocList->choice.setup = NULLP;
3170    CU_ALLOC(timeDomAllocList->choice.setup, \
3171            sizeof(struct PDSCH_TimeDomainResourceAllocationList));
3172    if(!timeDomAllocList->choice.setup)
3173         {
3174            DU_LOG("\nF1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
3175                 return RFAILED;
3176         }
3177
3178         elementCnt = 1;
3179         timeDomAllocList->choice.setup->list.count = elementCnt;
3180         timeDomAllocList->choice.setup->list.size = \
3181            elementCnt * sizeof(struct PDSCH_TimeDomainResourceAllocation *);
3182
3183         timeDomAllocList->choice.setup->list.array = NULLP;
3184         CU_ALLOC(timeDomAllocList->choice.setup->list.array, \
3185            timeDomAllocList->choice.setup->list.size);
3186         if(!timeDomAllocList->choice.setup->list.array)
3187         {
3188            DU_LOG("\nF1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
3189                 return RFAILED;
3190         }
3191
3192         for(idx = 0; idx < elementCnt; idx++)
3193         {
3194            timeDomAllocList->choice.setup->list.array[idx] = NULLP;
3195            CU_ALLOC(timeDomAllocList->choice.setup->list.array[idx], \
3196                    sizeof(struct PDSCH_TimeDomainResourceAllocation));
3197                 if(!timeDomAllocList->choice.setup->list.array[idx])
3198                 {
3199                    DU_LOG("\nF1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
3200                         return RFAILED;
3201                 }
3202         }
3203
3204         idx = 0;
3205         timeDomAlloc = timeDomAllocList->choice.setup->list.array[idx];
3206
3207    timeDomAlloc->k0 = NULLP;
3208    timeDomAlloc->mappingType = PDSCH_MAPPING_TYPE_A;
3209    timeDomAlloc->startSymbolAndLength = 53;
3210
3211    return ROK;
3212 }
3213
3214 /*******************************************************************
3215  *
3216  * @brief Builds PDSCH PRB Bundling type
3217  *
3218  * @details
3219  *
3220  *    Function : BuildPdschPrbBundlingType
3221  *
3222  *    Functionality: Builds PDSCH PRB Bundling type
3223  *
3224  * @params[in]
3225  * struct PDSCH_Config__prb_BundlingType *prbBndlType
3226  *
3227  * @return ROK     - success
3228  *         RFAILED - failure
3229  *
3230  * ****************************************************************/
3231 uint8_t BuildPdschPrbBundlingType
3232 (
3233 struct PDSCH_Config__prb_BundlingType *prbBndlType
3234 )
3235 {
3236    prbBndlType->present = PDSCH_Config__prb_BundlingType_PR_staticBundling;
3237
3238    prbBndlType->choice.staticBundling = NULLP;
3239         CU_ALLOC(prbBndlType->choice.staticBundling, \
3240            sizeof(struct PDSCH_Config__prb_BundlingType__staticBundling));
3241         if(!prbBndlType->choice.staticBundling)
3242         {
3243            DU_LOG("\nF1AP : Memory allocation failed in BuildPdschPrbBundlingType");
3244                 return RFAILED;
3245         }
3246         prbBndlType->choice.staticBundling->bundleSize = NULLP;
3247
3248    return ROK;
3249 }
3250
3251 /*******************************************************************
3252  *
3253  * @brief Builds BWP DL dedicated PDSCH config
3254  *
3255  * @details
3256  *
3257  *    Function : BuildBWPDlDedPdschCfg
3258  *
3259  *    Functionality: Builds BWP DL dedicated PDSCH config
3260  *
3261  * @params[in] struct PDSCH_Config *pdschCfg
3262  *
3263  * @return ROK     - success
3264  *         RFAILED - failure
3265  *
3266  * ****************************************************************/
3267 uint8_t BuildBWPDlDedPdschCfg(struct PDSCH_Config *pdschCfg)
3268 {
3269    pdschCfg->dataScramblingIdentityPDSCH = NULLP;
3270
3271    pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA = NULLP;
3272    CU_ALLOC(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA, \
3273       sizeof(struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA));
3274    if(!pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA)
3275    {
3276       DU_LOG("\nF1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
3277       return RFAILED;
3278    }
3279
3280    if(BuildDMRSDLPdschMapTypeA(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA) != ROK)
3281    {
3282       return RFAILED;
3283    }
3284
3285    pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeB = NULLP;
3286    pdschCfg->tci_StatesToAddModList = NULLP;
3287    pdschCfg->tci_StatesToReleaseList = NULLP;
3288         pdschCfg->vrb_ToPRB_Interleaver = NULLP;
3289 #if 0
3290    CU_ALLOC(pdschCfg->tci_StatesToAddModList, sizeof(struct PDSCH_Config__tci_StatesToAddModList));
3291    if(!pdschCfg->tci_StatesToAddModList)
3292    {
3293       DU_LOG("\nF1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
3294       return RFAILED;
3295    }
3296    if(BuildTCIStatesToAddModList(pdschCfg->tci_StatesToAddModList) != ROK)
3297    {
3298       return RFAILED;
3299    }
3300 #endif
3301
3302         pdschCfg->resourceAllocation = RES_ALLOC_TYPE;
3303
3304    pdschCfg->pdsch_TimeDomainAllocationList = NULLP;
3305         CU_ALLOC(pdschCfg->pdsch_TimeDomainAllocationList, \
3306            sizeof(struct PDSCH_Config__pdsch_TimeDomainAllocationList));
3307    if(!pdschCfg->pdsch_TimeDomainAllocationList)
3308         {
3309       DU_LOG("\nF1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
3310                 return RFAILED;
3311         }
3312         if(BuildPdschTimeDomAllocList(pdschCfg->pdsch_TimeDomainAllocationList) != ROK)
3313         {
3314            return RFAILED;
3315         }
3316    pdschCfg->pdsch_AggregationFactor = NULLP;
3317         pdschCfg->rateMatchPatternToAddModList = NULLP;
3318         pdschCfg->rateMatchPatternToReleaseList = NULLP;
3319         pdschCfg->rateMatchPatternGroup1 = NULLP;
3320         pdschCfg->rateMatchPatternGroup2 = NULLP;
3321         pdschCfg->rbg_Size = PDSCH_RBG_SIZE;
3322         pdschCfg->mcs_Table = NULLP;
3323
3324         pdschCfg->maxNrofCodeWordsScheduledByDCI = NULLP;
3325         CU_ALLOC(pdschCfg->maxNrofCodeWordsScheduledByDCI, sizeof(long));
3326         if(!pdschCfg->maxNrofCodeWordsScheduledByDCI)
3327         {
3328            DU_LOG("\nF1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
3329                 return RFAILED;
3330         }
3331         *(pdschCfg->maxNrofCodeWordsScheduledByDCI) = PDSCH_MAX_CODEWORD_SCH_BY_DCI;
3332
3333         if(BuildPdschPrbBundlingType(&pdschCfg->prb_BundlingType) != ROK)
3334         {
3335            return RFAILED;
3336         }
3337
3338         pdschCfg->zp_CSI_RS_ResourceToAddModList = NULLP;
3339         pdschCfg->zp_CSI_RS_ResourceToReleaseList = NULLP;
3340         pdschCfg->aperiodic_ZP_CSI_RS_ResourceSetsToAddModList = NULLP;
3341         pdschCfg->aperiodic_ZP_CSI_RS_ResourceSetsToReleaseList = NULLP;
3342         pdschCfg->sp_ZP_CSI_RS_ResourceSetsToAddModList = NULLP;
3343         pdschCfg->sp_ZP_CSI_RS_ResourceSetsToReleaseList = NULLP;
3344    pdschCfg->p_ZP_CSI_RS_ResourceSet = NULLP;
3345
3346    return ROK;
3347 }
3348
3349 /*******************************************************************
3350  *
3351  * @brief Builds intitial DL BWP
3352  * @details
3353  *
3354  *    Function : BuildInitialDlBWP
3355  *
3356  *    Functionality: Builds intitial DL BWP in spCellCfgDed
3357  *
3358  * @params[in] BWP_DownlinkDedicated_t *dlBwp
3359  *
3360  * @return ROK     - success
3361  *         RFAILED - failure
3362  *
3363  * ****************************************************************/
3364 uint8_t BuildInitialDlBWP(BWP_DownlinkDedicated_t *dlBwp)
3365 {
3366    dlBwp->pdcch_Config = NULLP;
3367    CU_ALLOC(dlBwp->pdcch_Config, sizeof(struct BWP_DownlinkDedicated__pdcch_Config));
3368         if(!dlBwp->pdcch_Config)
3369         {
3370            DU_LOG("\nF1AP : Memory Allocation failure in BuildInitialDlBWP");
3371       return RFAILED;
3372         }
3373         dlBwp->pdcch_Config->present = BWP_DownlinkDedicated__pdcch_Config_PR_setup;
3374
3375    dlBwp->pdcch_Config->choice.setup = NULLP;
3376         CU_ALLOC(dlBwp->pdcch_Config->choice.setup, sizeof(struct PDCCH_Config));
3377    if(!dlBwp->pdcch_Config->choice.setup)
3378    {
3379            DU_LOG("\nF1AP : Memory Allocation failure in BuildInitialDlBWP");
3380                 return RFAILED;
3381         }
3382    if(BuildBWPDlDedPdcchCfg(dlBwp->pdcch_Config->choice.setup) != ROK)
3383         {
3384            return RFAILED;
3385         }
3386
3387    dlBwp->pdsch_Config = NULLP;
3388         CU_ALLOC(dlBwp->pdsch_Config, sizeof(struct BWP_DownlinkDedicated__pdsch_Config));
3389         if(!dlBwp->pdsch_Config)
3390         {
3391            DU_LOG("\nF1AP : Memory Allocation failure in BuildInitialDlBWP");
3392                 return RFAILED;
3393         }
3394         dlBwp->pdsch_Config->present = BWP_DownlinkDedicated__pdsch_Config_PR_setup;
3395
3396    dlBwp->pdsch_Config->choice.setup = NULLP;
3397    CU_ALLOC(dlBwp->pdsch_Config->choice.setup, sizeof(struct PDSCH_Config));
3398    if(!dlBwp->pdsch_Config->choice.setup)
3399    {
3400       DU_LOG("\nF1AP : Memory Allocation failure in BuildInitialDlBWP");
3401                 return RFAILED;
3402         }
3403
3404    if(BuildBWPDlDedPdschCfg(dlBwp->pdsch_Config->choice.setup) != ROK)
3405         {
3406            return RFAILED;
3407         }
3408
3409    dlBwp->sps_Config = NULLP;
3410    dlBwp->radioLinkMonitoringConfig = NULLP;
3411    return ROK;
3412 }
3413
3414 /*******************************************************************
3415  *
3416  * @brief Builds DMRS UL Pusch Mapping type A
3417  *
3418  * @details
3419  *
3420  *    Function : BuildDMRSULPuschMapTypeA
3421  *
3422  *    Functionality: Builds DMRS UL Pusch Mapping type A
3423  *
3424  * @params[in]
3425  *    struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA *dmrsUlCfg
3426  * @return ROK     - success
3427  *         RFAILED - failure
3428  *
3429  * ****************************************************************/
3430 uint8_t BuildDMRSULPuschMapTypeA
3431 (
3432 struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA *dmrsUlCfg
3433 )
3434 {
3435    dmrsUlCfg->present = PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA_PR_setup;
3436    dmrsUlCfg->choice.setup= NULLP;
3437    CU_ALLOC(dmrsUlCfg->choice.setup, sizeof(DMRS_UplinkConfig_t));
3438    if(!dmrsUlCfg->choice.setup)
3439    {
3440       DU_LOG("\nF1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
3441       return RFAILED;
3442    }
3443
3444    dmrsUlCfg->choice.setup->dmrs_Type = NULLP;
3445         dmrsUlCfg->choice.setup->dmrs_AdditionalPosition = NULLP;
3446    CU_ALLOC(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition, sizeof(long));
3447    if(!dmrsUlCfg->choice.setup->dmrs_AdditionalPosition)
3448    {
3449       DU_LOG("\nF1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
3450       return RFAILED;
3451    }
3452    *(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition) = DMRS_ADDITIONAL_POS;
3453
3454         dmrsUlCfg->choice.setup->phaseTrackingRS = NULLP;
3455         dmrsUlCfg->choice.setup->maxLength = NULLP;
3456    dmrsUlCfg->choice.setup->transformPrecodingDisabled = NULLP;
3457    CU_ALLOC(dmrsUlCfg->choice.setup->transformPrecodingDisabled, \
3458       sizeof(struct DMRS_UplinkConfig__transformPrecodingDisabled));
3459    if(!dmrsUlCfg->choice.setup->transformPrecodingDisabled)
3460    {
3461       DU_LOG("\nF1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
3462       return RFAILED;
3463    }
3464
3465    dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0 = NULLP;
3466    CU_ALLOC(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0,\
3467       sizeof(long));
3468    if(!dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0)
3469    {
3470       DU_LOG("\nF1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
3471       return RFAILED;
3472    }
3473    *(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0) = SCRAMBLING_ID;
3474
3475         dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID1 = NULLP;
3476         dmrsUlCfg->choice.setup->transformPrecodingEnabled = NULLP;
3477    return ROK;
3478 }
3479
3480 /*******************************************************************
3481  *
3482  * @brief Build PUSCH time domain allocation list
3483  *
3484  * @details
3485  *
3486  *    Function : BuildPuschTimeDomAllocList
3487  *
3488  *    Functionality: Build PUSCH time domain allocation list
3489  *
3490  * @params[in]
3491  * struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList
3492  *
3493  * @return ROK     - success
3494  *         RFAILED - failure
3495  *
3496  * ****************************************************************/
3497 uint8_t BuildPuschTimeDomAllocList
3498 (
3499 struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList
3500 )
3501 {
3502    uint8_t idx;
3503    uint8_t elementCnt;
3504    PUSCH_TimeDomainResourceAllocation_t  *timeDomAlloc;
3505
3506    timeDomAllocList->present = PUSCH_Config__pusch_TimeDomainAllocationList_PR_setup;
3507    timeDomAllocList->choice.setup = NULLP;
3508    CU_ALLOC(timeDomAllocList->choice.setup, \
3509       sizeof(struct PUSCH_TimeDomainResourceAllocationList));
3510    if(!timeDomAllocList->choice.setup)
3511    {
3512       DU_LOG("\nF1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
3513       return RFAILED;
3514    }
3515
3516    elementCnt = 1;
3517    timeDomAllocList->choice.setup->list.count = elementCnt;
3518    timeDomAllocList->choice.setup->list.size = \
3519       elementCnt * sizeof(PUSCH_TimeDomainResourceAllocation_t *);
3520         timeDomAllocList->choice.setup->list.array = NULLP;
3521    CU_ALLOC(timeDomAllocList->choice.setup->list.array, \
3522       timeDomAllocList->choice.setup->list.size);
3523    if(!timeDomAllocList->choice.setup->list.array)
3524    {
3525       DU_LOG("\nF1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
3526       return RFAILED;
3527    }
3528
3529    for(idx = 0; idx < elementCnt; idx++)
3530    {
3531            timeDomAllocList->choice.setup->list.array[idx] = NULLP;
3532       CU_ALLOC(timeDomAllocList->choice.setup->list.array[idx],\
3533          sizeof(PUSCH_TimeDomainResourceAllocation_t));
3534       if(!timeDomAllocList->choice.setup->list.array[idx])
3535       {
3536          DU_LOG("\nF1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
3537          return RFAILED;
3538       }
3539    }
3540
3541    idx = 0;
3542    timeDomAlloc = timeDomAllocList->choice.setup->list.array[idx];
3543    CU_ALLOC(timeDomAlloc->k2, sizeof(long));
3544    if(!timeDomAlloc->k2)
3545    {
3546       DU_LOG("\nF1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
3547       return RFAILED;
3548    }
3549    *(timeDomAlloc->k2) = PUSCH_K2;
3550    timeDomAlloc->mappingType = PUSCH_MAPPING_TYPE_A;
3551    timeDomAlloc->startSymbolAndLength = 27;
3552    return ROK;
3553 }
3554
3555 /*******************************************************************
3556  *
3557  * @brief Builds BWP UL dedicated PUSCH Config
3558  *
3559  * @details
3560  *
3561  *    Function : BuildBWPUlDedPuschCfg
3562  *
3563  *    Functionality:
3564  *      Builds BWP UL dedicated PUSCH Config
3565  *
3566  * @params[in] : PUSCH_Config_t *puschCfg
3567  *
3568  * @return ROK     - success
3569  *         RFAILED - failure
3570  *
3571  * ****************************************************************/
3572 uint8_t BuildBWPUlDedPuschCfg(PUSCH_Config_t *puschCfg)
3573 {
3574    puschCfg->dataScramblingIdentityPUSCH = NULLP;
3575    CU_ALLOC(puschCfg->dataScramblingIdentityPUSCH, sizeof(long));
3576    if(!puschCfg->dataScramblingIdentityPUSCH)
3577    {
3578       DU_LOG("\nF1AP: Memory allocation failed in BuildBWPUlDedPuschCfg");
3579       return RFAILED;
3580    }
3581    *(puschCfg->dataScramblingIdentityPUSCH) = SCRAMBLING_ID;
3582
3583    puschCfg->txConfig = NULLP;
3584         puschCfg->dmrs_UplinkForPUSCH_MappingTypeA = NULLP;
3585    CU_ALLOC(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA, \
3586       sizeof(struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA));
3587    if(!puschCfg->dmrs_UplinkForPUSCH_MappingTypeA)
3588    {
3589       DU_LOG("\nF1AP: Memory allocation failed in BuildBWPUlDedPuschCfg");
3590       return RFAILED;
3591    }
3592
3593    if(BuildDMRSULPuschMapTypeA(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA) != ROK)
3594    {
3595       return RFAILED;
3596    }
3597
3598    puschCfg->dmrs_UplinkForPUSCH_MappingTypeB = NULLP;
3599         puschCfg->pusch_PowerControl = NULLP;
3600         puschCfg->frequencyHopping = NULLP;
3601         puschCfg->frequencyHoppingOffsetLists = NULLP;
3602    puschCfg->resourceAllocation = RES_ALLOC_TYPE;
3603
3604    puschCfg->pusch_TimeDomainAllocationList = NULLP;
3605    CU_ALLOC(puschCfg->pusch_TimeDomainAllocationList, \
3606       sizeof(struct PUSCH_Config__pusch_TimeDomainAllocationList));
3607    if(!puschCfg->pusch_TimeDomainAllocationList)
3608    {
3609       DU_LOG("\nF1AP: Memory allocation failed in BuildBWPUlDedPuschCfg");
3610       return RFAILED;
3611    }
3612
3613    if(BuildPuschTimeDomAllocList(puschCfg->pusch_TimeDomainAllocationList) != ROK)
3614    {
3615       return RFAILED;
3616    }
3617
3618    puschCfg->pusch_AggregationFactor = NULLP;
3619         puschCfg->mcs_Table = NULLP;
3620         puschCfg->mcs_TableTransformPrecoder = NULLP;
3621    puschCfg->transformPrecoder = NULLP;
3622    CU_ALLOC(puschCfg->transformPrecoder, sizeof(long));
3623    if(!puschCfg->transformPrecoder)
3624    {
3625       DU_LOG("\nF1AP: Memory allocation failed in BuildBWPUlDedPuschCfg");
3626       return RFAILED;
3627    }
3628    *(puschCfg->transformPrecoder) = PUSCH_TRANSFORM_PRECODER;
3629
3630         puschCfg->codebookSubset = NULLP;
3631         puschCfg->maxRank = NULLP;
3632         puschCfg->rbg_Size = NULLP;
3633         puschCfg->uci_OnPUSCH = NULLP;
3634         puschCfg->tp_pi2BPSK = NULLP;
3635
3636    return ROK;
3637 }
3638
3639 /*******************************************************************
3640  *
3641  * @brief Fills SRS resource to add/modify list
3642  *
3643  * @details
3644  *
3645  *    Function : BuildSrsRsrcAddModList
3646  *
3647  *    Functionality: Fills SRS resource to add/modify list
3648  *
3649  * @params[in]
3650  * @return ROK     - success
3651  *         RFAILED - failure
3652  *
3653  * ****************************************************************/
3654 uint8_t BuildSrsRsrcAddModList(struct SRS_Config__srs_ResourceToAddModList *resourceList)
3655 {
3656    uint8_t   elementCnt;
3657    uint8_t   rsrcIdx;
3658
3659    elementCnt = 1;
3660    resourceList->list.count = elementCnt;
3661    resourceList->list.size = elementCnt * sizeof(SRS_Resource_t *);
3662    resourceList->list.array = NULLP;
3663    CU_ALLOC(resourceList->list.array, resourceList->list.size);
3664    if(!resourceList->list.array)
3665    {
3666       DU_LOG("\nF1AP: Memory allocation failed in BuildSrsRsrcAddModList");
3667       return RFAILED;
3668    }
3669
3670    for(rsrcIdx = 0; rsrcIdx < resourceList->list.count; rsrcIdx++)
3671    {
3672       CU_ALLOC(resourceList->list.array[rsrcIdx], sizeof(SRS_Resource_t));
3673       if(!resourceList->list.array[rsrcIdx])
3674       {
3675          DU_LOG("\nF1AP: Memory allocation failed in BuildSrsRsrcAddModList");
3676          return RFAILED;
3677       }
3678    }
3679
3680    rsrcIdx = 0;
3681    resourceList->list.array[rsrcIdx]->srs_ResourceId = SRS_RSRC_ID;
3682    resourceList->list.array[rsrcIdx]->nrofSRS_Ports = SRS_Resource__nrofSRS_Ports_port1;
3683    resourceList->list.array[rsrcIdx]->transmissionComb.present = SRS_Resource__transmissionComb_PR_n2;
3684
3685    resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2 = NULLP;
3686    CU_ALLOC(resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2, \
3687       sizeof(struct SRS_Resource__transmissionComb__n2));
3688    if(!resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2)
3689    {
3690       DU_LOG("\nF1AP: Memory allocation failed in BuildSrsRsrcAddModList");
3691       return RFAILED;
3692    }
3693    resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2->combOffset_n2\
3694            = SRS_COMB_OFFSET_N2;
3695    resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2->cyclicShift_n2\
3696            = SRS_CYCLIC_SHIFT_N2;
3697
3698    resourceList->list.array[rsrcIdx]->resourceMapping.startPosition = \
3699            0;
3700    resourceList->list.array[rsrcIdx]->resourceMapping.nrofSymbols =  \
3701       SRS_Resource__resourceMapping__nrofSymbols_n1;
3702    resourceList->list.array[rsrcIdx]->resourceMapping.repetitionFactor = \
3703       SRS_Resource__resourceMapping__repetitionFactor_n1;
3704
3705    resourceList->list.array[rsrcIdx]->freqDomainPosition = SRS_FREQ_DOM_POS;
3706    resourceList->list.array[rsrcIdx]->freqDomainShift = SRS_FREQ_DOM_SHIFT;
3707    resourceList->list.array[rsrcIdx]->freqHopping.c_SRS = C_SRS;
3708    resourceList->list.array[rsrcIdx]->freqHopping.b_SRS = B_SRS;
3709    resourceList->list.array[rsrcIdx]->freqHopping.b_hop = B_HOP;
3710    resourceList->list.array[rsrcIdx]->groupOrSequenceHopping = \
3711       SRS_Resource__groupOrSequenceHopping_neither;
3712
3713    /* Setting resource type to aperiodic for intergration purposes */
3714    resourceList->list.array[rsrcIdx]->resourceType.present = \
3715            SRS_Resource__resourceType_PR_aperiodic;
3716    resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic = NULLP;
3717    CU_ALLOC(resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic,
3718       sizeof(struct SRS_Resource__resourceType__aperiodic));
3719    if(!resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic)
3720    {
3721       DU_LOG("\nF1AP: Memory allocation failed in BuildSrsRsrcAddModList");
3722       return RFAILED;
3723    }
3724    resourceList->list.array[rsrcIdx]->sequenceId = SRS_SEQ_ID;
3725
3726    return ROK;
3727 }
3728
3729 /*******************************************************************
3730  *
3731  * @brief Build SRS resource set Add/mod list
3732  *
3733  * @details
3734  *
3735  *    Function : BuildSrsRsrcSetAddModList
3736  *
3737  *    Functionality: Build SRS resource set Add/mod list
3738  *
3739  * @params[in]
3740  * @return ROK     - success
3741  *         RFAILED - failure
3742  *
3743  * ****************************************************************/
3744 uint8_t BuildSrsRsrcSetAddModList
3745 (
3746 struct SRS_Config__srs_ResourceSetToAddModList *rsrcSetList
3747 )
3748 {
3749    uint8_t  elementCnt;
3750    uint8_t  rSetIdx;
3751         uint8_t  rsrcIdx;
3752         struct SRS_ResourceSet__srs_ResourceIdList *rsrcIdList;
3753
3754    elementCnt = 1;
3755    rsrcSetList->list.count = elementCnt;
3756    rsrcSetList->list.size = elementCnt * sizeof(SRS_ResourceSet_t *);
3757    rsrcSetList->list.array = NULLP;
3758    CU_ALLOC(rsrcSetList->list.array, rsrcSetList->list.size);
3759    if(!rsrcSetList->list.array)
3760    {
3761       DU_LOG("\nF1AP: Memory allocation failed in BuildSrsRsrcSetAddModList");
3762       return RFAILED;
3763    }
3764
3765    for(rSetIdx = 0; rSetIdx < rsrcSetList->list.count; rSetIdx++)
3766    {
3767       CU_ALLOC(rsrcSetList->list.array[rSetIdx], sizeof(SRS_ResourceSet_t));
3768       if(!rsrcSetList->list.array[rSetIdx])
3769       {
3770          DU_LOG("\nF1AP: Memory allocation failed in BuildSrsRsrcSetAddModList");
3771          return RFAILED;
3772       }
3773    }
3774
3775    rSetIdx = 0;
3776    rsrcSetList->list.array[rSetIdx]->srs_ResourceSetId = SRS_RSET_ID;
3777
3778         /* Fill Resource Id list in resource set */
3779         rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList = NULLP;
3780         CU_ALLOC(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList,\
3781            sizeof(struct SRS_ResourceSet__srs_ResourceIdList));
3782         if(!rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList)
3783         {
3784            DU_LOG("\nF1AP: Memory allocation failed in BuildSrsRsrcSetAddModList");
3785                 return RFAILED;
3786         }
3787
3788         elementCnt = 1;
3789         rsrcIdList = rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList;
3790         rsrcIdList->list.count = elementCnt;
3791         rsrcIdList->list.size = elementCnt * sizeof(SRS_ResourceId_t *);
3792         rsrcIdList->list.array = NULLP;
3793         CU_ALLOC(rsrcIdList->list.array, rsrcIdList->list.size);
3794         if(!rsrcIdList->list.array)
3795         {
3796            DU_LOG("\nF1AP: Memory allocation failed in BuildSrsRsrcSetAddModList");
3797                 return RFAILED;
3798         }
3799
3800         for(rsrcIdx = 0; rsrcIdx < rsrcIdList->list.count; rsrcIdx++)
3801         {
3802            CU_ALLOC(rsrcIdList->list.array[rsrcIdx], sizeof(SRS_ResourceId_t));
3803                 if(!rsrcIdList->list.array[rsrcIdx])
3804                 {
3805                    DU_LOG("\nF1AP: Memory allocation failed in BuildSrsRsrcSetAddModList");
3806                         return RFAILED;
3807                 }
3808         }
3809
3810         rsrcIdx = 0;
3811         *rsrcIdList->list.array[rsrcIdx] = SRS_RSRC_ID;
3812
3813         /* Fill resource type */
3814    rsrcSetList->list.array[rSetIdx]->resourceType.present = \
3815       SRS_ResourceSet__resourceType_PR_aperiodic;
3816
3817    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic = NULLP;
3818    CU_ALLOC(rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic, \
3819       sizeof(struct SRS_ResourceSet__resourceType__aperiodic));
3820    if(!rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic)
3821    {
3822            DU_LOG("\nF1AP: Memory allocation failed in BuildSrsRsrcSetAddModList");
3823                 return RFAILED;
3824         }
3825    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic->aperiodicSRS_ResourceTrigger \
3826            = APERIODIC_SRS_RESRC_TRIGGER;
3827
3828         /* TODO : Fill values for below IEs as expected by Viavi */
3829         rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic->csi_RS = NULLP;
3830    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic->slotOffset = NULLP;
3831
3832
3833    rsrcSetList->list.array[rSetIdx]->usage = SRS_ResourceSet__usage_codebook;
3834         rsrcSetList->list.array[rSetIdx]->alpha = NULLP;
3835         rsrcSetList->list.array[rSetIdx]->p0 = NULLP;
3836         rsrcSetList->list.array[rSetIdx]->pathlossReferenceRS = NULLP;
3837         rsrcSetList->list.array[rSetIdx]->srs_PowerControlAdjustmentStates = NULLP;
3838
3839    return ROK;
3840 }
3841
3842 /*******************************************************************
3843  *
3844  * @brief Builds BWP UL dedicated SRS Config
3845  *
3846  * @details
3847  *
3848  *    Function : BuildBWPUlDedSrsCfg
3849  *
3850  *    Functionality: Builds BWP UL dedicated SRS Config
3851  *
3852  * @params[in] SRS Config
3853  * @return ROK     - success
3854  *         RFAILED - failure
3855  *
3856  * ****************************************************************/
3857 uint8_t BuildBWPUlDedSrsCfg(SRS_Config_t *srsCfg)
3858 {
3859    srsCfg->srs_ResourceSetToReleaseList = NULLP;
3860    srsCfg->srs_ResourceSetToAddModList = NULLP;
3861    CU_ALLOC(srsCfg->srs_ResourceSetToAddModList, \
3862       sizeof(struct SRS_Config__srs_ResourceSetToAddModList));
3863    if(!srsCfg->srs_ResourceSetToAddModList)
3864    {
3865       DU_LOG("\nF1AP: Memory allocation failed in BuildBWPUlDedSrsCfg");
3866       return RFAILED;
3867    }
3868    if(BuildSrsRsrcSetAddModList(srsCfg->srs_ResourceSetToAddModList) != ROK)
3869    {
3870       return RFAILED;
3871    }
3872
3873    srsCfg->srs_ResourceToReleaseList = NULLP;
3874
3875    /* Resource to Add/Modify list */
3876    srsCfg->srs_ResourceToAddModList = NULLP;
3877    CU_ALLOC(srsCfg->srs_ResourceToAddModList, \
3878       sizeof(struct SRS_Config__srs_ResourceToAddModList));
3879    if(!srsCfg->srs_ResourceToAddModList)
3880    {
3881       DU_LOG("\nF1AP: Memory allocation failed in BuildBWPUlDedSrsCfg");
3882       return RFAILED;
3883    }
3884
3885    if(BuildSrsRsrcAddModList(srsCfg->srs_ResourceToAddModList) != ROK)
3886    {
3887       return RFAILED;
3888    }
3889
3890    srsCfg->tpc_Accumulation = NULLP;
3891
3892    return ROK;
3893 }
3894
3895 /*******************************************************************
3896  *
3897  * @brief Builds inital UL BWP
3898  *
3899  * @details
3900  *
3901  *    Function : BuildInitialUlBWP
3902  *
3903  *    Functionality: Builds initial UL BWP
3904  *
3905  * @params[in] BWP_UplinkDedicated_t *ulBwp
3906  * @return ROK     - success
3907  *         RFAILED - failure
3908  *
3909  * ****************************************************************/
3910 uint8_t BuildInitialUlBWP(BWP_UplinkDedicated_t *ulBwp)
3911 {
3912    ulBwp->pucch_Config = NULLP;
3913
3914    /* Fill BWP UL dedicated PUSCH config */
3915         ulBwp->pusch_Config = NULLP;
3916    CU_ALLOC(ulBwp->pusch_Config, sizeof(struct BWP_UplinkDedicated__pusch_Config));
3917    if(!ulBwp->pusch_Config)
3918    {
3919       DU_LOG("\nF1AP : Memory allocation failed in BuildInitialUlBWP");
3920       return RFAILED;
3921    }
3922
3923    ulBwp->pusch_Config->present = BWP_UplinkDedicated__pusch_Config_PR_setup;
3924    ulBwp->pusch_Config->choice.setup = NULLP;
3925    CU_ALLOC(ulBwp->pusch_Config->choice.setup, sizeof(PUSCH_Config_t));
3926    if(!ulBwp->pusch_Config->choice.setup)
3927    {
3928       DU_LOG("\nF1AP : Memory allocation failed in BuildInitialUlBWP");
3929       return RFAILED;
3930    }
3931
3932    if(BuildBWPUlDedPuschCfg(ulBwp->pusch_Config->choice.setup) != ROK)
3933    {
3934       return RFAILED;
3935    }
3936
3937         ulBwp->configuredGrantConfig = NULLP;
3938
3939    /* Fill BPW UL dedicated SRS config */
3940         ulBwp->srs_Config = NULLP;
3941    CU_ALLOC(ulBwp->srs_Config, sizeof(struct BWP_UplinkDedicated__srs_Config));
3942    if(!ulBwp->srs_Config)
3943    {
3944       DU_LOG("\nF1AP : Memory allocation failed in BuildInitialUlBWP");
3945       return RFAILED;
3946    }
3947
3948    ulBwp->srs_Config->present = BWP_UplinkDedicated__srs_Config_PR_setup;
3949    ulBwp->srs_Config->choice.setup = NULLP;
3950    CU_ALLOC(ulBwp->srs_Config->choice.setup, sizeof(SRS_Config_t));
3951    if(!ulBwp->srs_Config->choice.setup)
3952    {
3953       DU_LOG("\nF1AP : Memory allocation failed in BuildInitialUlBWP");
3954       return RFAILED;
3955    }
3956
3957    if(BuildBWPUlDedSrsCfg(ulBwp->srs_Config->choice.setup) != ROK)
3958    {
3959       return RFAILED;
3960    }
3961
3962         ulBwp->beamFailureRecoveryConfig = NULLP;
3963
3964    return ROK;
3965 }
3966
3967 /*******************************************************************
3968 *
3969 * @brief Builds Pusch Serving cell Config
3970 *
3971 * @details
3972 *
3973 *    Function : BuildPuschSrvCellCfg
3974 *
3975 *    Functionality: Builds Pusch Serving cell Config
3976 *
3977 * @params[in] struct UplinkConfig__pusch_ServingCellConfig *puschCfg
3978 *
3979 * @return ROK     - success
3980 *         RFAILED - failure
3981 *
3982 * ****************************************************************/
3983 uint8_t BuildPuschSrvCellCfg(struct UplinkConfig__pusch_ServingCellConfig *puschCfg)
3984 {
3985    puschCfg->present = UplinkConfig__pusch_ServingCellConfig_PR_setup;
3986    puschCfg->choice.setup = NULLP;
3987    CU_ALLOC(puschCfg->choice.setup, sizeof(struct PUSCH_ServingCellConfig));
3988    if(!puschCfg->choice.setup)
3989    {
3990       DU_LOG("\nF1AP : Memory allocation failed in BuildPuschSrvCellCfg");
3991       return RFAILED;
3992    }
3993
3994    puschCfg->choice.setup->codeBlockGroupTransmission = NULLP;
3995         puschCfg->choice.setup->rateMatching = NULLP;
3996         puschCfg->choice.setup->xOverhead = NULLP;
3997    puschCfg->choice.setup->ext1 = NULLP;
3998    CU_ALLOC(puschCfg->choice.setup->ext1, sizeof(struct PUSCH_ServingCellConfig__ext1));
3999    if(!puschCfg->choice.setup->ext1)
4000    {
4001       DU_LOG("\nF1AP : Memory allocation failed in BuildPuschSrvCellCfg");
4002       return RFAILED;
4003    }
4004
4005    puschCfg->choice.setup->ext1->maxMIMO_Layers = NULLP;
4006    CU_ALLOC(puschCfg->choice.setup->ext1->maxMIMO_Layers, sizeof(long));
4007    if(!puschCfg->choice.setup->ext1->maxMIMO_Layers)
4008    {
4009       DU_LOG("\nF1AP : Memory allocation failed in BuildPuschSrvCellCfg");
4010       return RFAILED;
4011    }
4012    *(puschCfg->choice.setup->ext1->maxMIMO_Layers) = PUSCH_MAX_MIMO_LAYERS;
4013
4014    puschCfg->choice.setup->ext1->processingType2Enabled= NULLP;
4015    CU_ALLOC(puschCfg->choice.setup->ext1->processingType2Enabled,sizeof(BOOLEAN_t));
4016    if(!puschCfg->choice.setup->ext1->processingType2Enabled)
4017    {
4018       DU_LOG("\nF1AP : Memory allocation failed in BuildPuschSrvCellCfg");
4019       return RFAILED;
4020    }
4021    *(puschCfg->choice.setup->ext1->processingType2Enabled) = PUSCH_PROCESS_TYPE2_ENABLED;
4022    return ROK;
4023 }
4024
4025 /*******************************************************************
4026  *
4027  * @brief Builds UL config
4028  * @details
4029  *
4030  *    Function : BuildUlCfg
4031  *
4032  *    Functionality: Builds UL config in spCellCfgDed
4033  *
4034  * @params[in] UplinkConfig_t *ulCfg
4035  *
4036  * @return ROK     - success
4037  *         RFAILED - failure
4038  *
4039  * ****************************************************************/
4040 uint8_t BuildUlCfg(UplinkConfig_t *ulCfg)
4041 {
4042    ulCfg->initialUplinkBWP = NULLP;
4043    CU_ALLOC(ulCfg->initialUplinkBWP, sizeof(BWP_UplinkDedicated_t));
4044         if(!ulCfg->initialUplinkBWP)
4045         {
4046            DU_LOG("\nF1AP : Memory Allocation failed in BuildUlCfg");
4047                 return RFAILED;
4048         }
4049
4050    if(BuildInitialUlBWP(ulCfg->initialUplinkBWP) != ROK)
4051         {
4052            return RFAILED;
4053         }
4054
4055    ulCfg->uplinkBWP_ToReleaseList = NULLP;
4056         ulCfg->uplinkBWP_ToAddModList = NULLP;
4057         ulCfg->firstActiveUplinkBWP_Id = NULLP;
4058    CU_ALLOC(ulCfg->firstActiveUplinkBWP_Id, sizeof(BWP_Id_t));
4059    if(!ulCfg->firstActiveUplinkBWP_Id)
4060    {
4061       DU_LOG("\nF1AP : Memory Allocation failed in BuildUlCfg");
4062       return RFAILED;
4063    }
4064    *(ulCfg->firstActiveUplinkBWP_Id) = ACTIVE_UL_BWP_ID;
4065
4066    ulCfg->pusch_ServingCellConfig = NULLP;
4067    CU_ALLOC(ulCfg->pusch_ServingCellConfig, \
4068       sizeof(struct UplinkConfig__pusch_ServingCellConfig));
4069    if(!ulCfg->pusch_ServingCellConfig)
4070    {
4071       DU_LOG("\nF1AP : Memory Allocation failed in BuildUlCfg");
4072       return RFAILED;
4073    }
4074
4075    if(BuildPuschSrvCellCfg(ulCfg->pusch_ServingCellConfig) != ROK)
4076    {
4077       return RFAILED;
4078    }
4079
4080         ulCfg->carrierSwitching = NULLP;
4081         ulCfg->ext1 = NULLP;
4082         return ROK;
4083 }
4084
4085 /*******************************************************************
4086  *
4087  * @brief Builds PDSCH serving cell config
4088  * @details
4089  *
4090  *    Function : BuildPdschSrvCellCfg
4091  *
4092  *    Functionality: Builds PDSCH serving cell config in spCellCfgDed
4093  *
4094  * @params[in] struct ServingCellConfig__pdsch_ServingCellConfig *pdschCfg
4095  *
4096  * @return ROK     - success
4097  *         RFAILED - failure
4098  *
4099  * ****************************************************************/
4100 uint8_t BuildPdschSrvCellCfg(struct ServingCellConfig__pdsch_ServingCellConfig *pdschCfg)
4101 {
4102    pdschCfg->present =  ServingCellConfig__pdsch_ServingCellConfig_PR_setup;
4103    pdschCfg->choice.setup = NULLP;
4104    CU_ALLOC(pdschCfg->choice.setup, sizeof( struct PDSCH_ServingCellConfig));
4105    if(!pdschCfg->choice.setup)
4106    {
4107       DU_LOG("\nF1AP : Memory allocation failed in BuildPdschSrvCellCfg");
4108       return RFAILED;
4109    }
4110
4111    pdschCfg->choice.setup->codeBlockGroupTransmission = NULLP;
4112         pdschCfg->choice.setup->xOverhead = NULLP;
4113    pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH = NULLP;
4114    CU_ALLOC(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH, sizeof(long));
4115    if(!pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH)
4116    {
4117       DU_LOG("\nF1AP : Memory allocation failed in BuildPdschSrvCellCfg");
4118       return RFAILED;
4119    }
4120    *(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH)= PDSCH_NUM_HARQ_PROC;
4121         pdschCfg->choice.setup->pucch_Cell = NULLP;
4122         pdschCfg->choice.setup->ext1 = NULLP;
4123
4124    return ROK;
4125 }
4126
4127 /*******************************************************************
4128  *
4129  * @brief Builds CSI Meas config
4130  * @details
4131  *
4132  *    Function : BuildCsiMeasCfg
4133  *
4134  *    Functionality: Builds CSI Meas config in spCellCfgDed
4135  *
4136  * @params[in] struct ServingCellConfig__csi_MeasConfig *csiMeasCfg
4137  *
4138  * @return ROK     - success
4139  *         RFAILED - failure
4140  *
4141  * ****************************************************************/
4142 uint8_t BuildCsiMeasCfg(struct ServingCellConfig__csi_MeasConfig *csiMeasCfg)
4143 {
4144
4145    return ROK;
4146 }
4147
4148 /*******************************************************************
4149  *
4150  * @brief Builds Spcell config dedicated
4151  * @details
4152  *
4153  *    Function : BuildSpCellCfgDed
4154  *
4155  *    Functionality: Builds sp cell config dedicated in spCellCfg
4156  *
4157  * @params[in] ServingCellConfig_t srvCellCfg
4158  *
4159  * @return ROK     - success
4160  *         RFAILED - failure
4161  *
4162  * ****************************************************************/
4163 uint8_t BuildSpCellCfgDed(ServingCellConfig_t *srvCellCfg)
4164 {
4165    srvCellCfg->tdd_UL_DL_ConfigurationDedicated = NULLP;
4166
4167    srvCellCfg->initialDownlinkBWP = NULLP;
4168    CU_ALLOC(srvCellCfg->initialDownlinkBWP, sizeof(BWP_DownlinkDedicated_t));
4169         if(!srvCellCfg->initialDownlinkBWP)
4170         {
4171                 DU_LOG("\nF1AP : Memory allocation failure in BuildSpCellCfgDed");
4172                 return RFAILED;
4173         }
4174
4175    if(BuildInitialDlBWP(srvCellCfg->initialDownlinkBWP) != ROK)
4176         {
4177                 DU_LOG("\nF1AP : BuildInitialDlBWP failed");
4178                 return RFAILED;
4179         }
4180    srvCellCfg->downlinkBWP_ToReleaseList = NULLP;
4181         srvCellCfg->downlinkBWP_ToAddModList = NULLP;
4182
4183    srvCellCfg->firstActiveDownlinkBWP_Id = NULLP;
4184         CU_ALLOC(srvCellCfg->firstActiveDownlinkBWP_Id, sizeof(long));
4185         if(!srvCellCfg->firstActiveDownlinkBWP_Id)
4186         {
4187                 DU_LOG("\nF1AP : Memory allocation failure in BuildSpCellCfgDed");
4188                 return RFAILED;
4189         }
4190         *(srvCellCfg->firstActiveDownlinkBWP_Id) = ACTIVE_DL_BWP_ID;
4191
4192         srvCellCfg->bwp_InactivityTimer = NULLP;
4193
4194    srvCellCfg->defaultDownlinkBWP_Id = NULLP;
4195         CU_ALLOC(srvCellCfg->defaultDownlinkBWP_Id, sizeof(long));
4196         if(!srvCellCfg->defaultDownlinkBWP_Id)
4197         {
4198                 DU_LOG("\nF1AP : Memory allocation failure in BuildSpCellCfgDed");
4199                 return RFAILED;
4200         }
4201         *(srvCellCfg->defaultDownlinkBWP_Id) = ACTIVE_DL_BWP_ID;
4202
4203    srvCellCfg->uplinkConfig = NULLP;
4204    CU_ALLOC(srvCellCfg->uplinkConfig, sizeof(UplinkConfig_t));
4205         if(!srvCellCfg->uplinkConfig)
4206         {
4207                 DU_LOG("\nF1AP : Memory allocation failure in BuildSpCellCfgDed");
4208                 return RFAILED;
4209         }
4210
4211    if(BuildUlCfg(srvCellCfg->uplinkConfig) != ROK)
4212         {
4213                 DU_LOG("\nF1AP : BuildUlCfg failed");
4214                 return RFAILED;
4215         }
4216         srvCellCfg->supplementaryUplink = NULLP;
4217         srvCellCfg->pdcch_ServingCellConfig = NULLP;
4218
4219    srvCellCfg->pdsch_ServingCellConfig = NULLP;
4220         CU_ALLOC(srvCellCfg->pdsch_ServingCellConfig, sizeof(struct     ServingCellConfig__pdsch_ServingCellConfig));
4221         if(!srvCellCfg->pdsch_ServingCellConfig)
4222         {
4223                 DU_LOG("\nF1AP : Memory allocation failure in BuildSpCellCfgDed");
4224                 return RFAILED;
4225         }
4226
4227    if(BuildPdschSrvCellCfg(srvCellCfg->pdsch_ServingCellConfig) != ROK)
4228         {
4229                 DU_LOG("\nF1AP : BuildPdschSrvCellCfg failed");
4230                 return RFAILED;
4231         }
4232
4233    srvCellCfg->csi_MeasConfig = NULLP;
4234 #if 0
4235         CU_ALLOC(srvCellCfg->csi_MeasConfig, sizeof(struct      ServingCellConfig__csi_MeasConfig))
4236         if(!srvCellCfg->csi_MeasConfig)
4237         {
4238                 DU_LOG("\nF1AP : Memory allocation failure in BuildSpCellCfgDed");
4239                 return RFAILED;
4240         }
4241
4242    if(BuildCsiMeasCfg(srvCellCfg->csi_MeasConfig) != ROK)
4243         {
4244                 DU_LOG("\nF1AP : BuildCsiMeasCfg failed");
4245                 return RFAILED;
4246         }
4247 #endif
4248    srvCellCfg->sCellDeactivationTimer = NULLP;
4249         srvCellCfg->crossCarrierSchedulingConfig = NULLP;
4250         srvCellCfg->tag_Id = TAG_ID;
4251    srvCellCfg->dummy = NULLP;
4252    srvCellCfg->pathlossReferenceLinking = NULLP;
4253    srvCellCfg->servingCellMO = NULLP;
4254    srvCellCfg->ext1 = NULLP;
4255
4256         return ROK;
4257 }
4258 /*******************************************************************
4259  *
4260  * @brief Builds Spcell config
4261  *
4262  * @details
4263  *
4264  *    Function : BuildSpCellCfg
4265  *
4266  *    Functionality: Builds sp cell config in DuToCuRrcContainer
4267  *
4268  * @params[in] SpCellConfig_t spCellCfg
4269  *
4270  * @return ROK     - success
4271  *         RFAILED - failure
4272  *
4273  * ****************************************************************/
4274 uint8_t BuildSpCellCfg(SpCellConfig_t *spCellCfg)
4275 {
4276
4277    spCellCfg->servCellIndex = NULLP;
4278         CU_ALLOC(spCellCfg->servCellIndex, sizeof(long));
4279         if(!spCellCfg->servCellIndex)
4280         {
4281                 DU_LOG("\nF1AP : Memory allocation failure in BuildSpCellCfg");
4282                 return RFAILED;
4283         }
4284    *(spCellCfg->servCellIndex) = SERV_CELL_IDX;
4285
4286    spCellCfg->reconfigurationWithSync = NULLP;
4287         spCellCfg->rlf_TimersAndConstants = NULLP;
4288    spCellCfg->rlmInSyncOutOfSyncThreshold = NULLP;
4289         CU_ALLOC(spCellCfg->rlmInSyncOutOfSyncThreshold, sizeof(long));
4290         if(!spCellCfg->rlmInSyncOutOfSyncThreshold)
4291         {
4292                 DU_LOG("\nF1AP : Memory allocation failure in BuildSpCellCfg");
4293                 return RFAILED;
4294         }
4295    *(spCellCfg->rlmInSyncOutOfSyncThreshold) = RLM_SYNC_OUT_SYNC_THRESHOLD;
4296
4297    spCellCfg->spCellConfigDedicated = NULLP;
4298    CU_ALLOC(spCellCfg->spCellConfigDedicated, sizeof(ServingCellConfig_t));
4299         if(!spCellCfg->spCellConfigDedicated)
4300         {
4301                 DU_LOG("\nF1AP : Memory allocation failure in BuildSpCellCfg");
4302                 return RFAILED;
4303         }
4304    if(BuildSpCellCfgDed(spCellCfg->spCellConfigDedicated) != ROK)
4305         {
4306                 DU_LOG("\nF1AP : BuildSpCellCfgDed failed");
4307                 return RFAILED;
4308         }
4309         return ROK;
4310 }
4311 /*******************************************************************
4312 *
4313 * @brief Builds Phy cell group config
4314 *
4315 * @details
4316 *
4317 *    Function : BuildPhyCellGrpCfg
4318 *
4319 *    Functionality: Builds Phy cell group config in DuToCuRrcContainer
4320 *
4321 * @params[in] PhysicalCellGroupConfig_t *phyCellGrpCfg
4322 *
4323 * @return ROK     - success
4324 *         RFAILED - failure
4325 *
4326 * ****************************************************************/
4327 uint8_t BuildPhyCellGrpCfg(PhysicalCellGroupConfig_t *phyCellGrpCfg)
4328 {
4329    phyCellGrpCfg->harq_ACK_SpatialBundlingPUCCH = NULLP;
4330         phyCellGrpCfg->harq_ACK_SpatialBundlingPUSCH = NULLP;
4331
4332    phyCellGrpCfg->p_NR_FR1 = NULLP;
4333         CU_ALLOC(phyCellGrpCfg->p_NR_FR1, sizeof(long));
4334         if(!phyCellGrpCfg->p_NR_FR1)
4335         {
4336                 DU_LOG("\nF1AP : Memory allocation failure in BuildPhyCellGrpCfg");
4337                 return RFAILED;
4338         }
4339    *(phyCellGrpCfg->p_NR_FR1)             = P_NR_FR1;
4340         phyCellGrpCfg->pdsch_HARQ_ACK_Codebook = PDSCH_HARQ_ACK_CODEBOOK;
4341         phyCellGrpCfg->tpc_SRS_RNTI = NULLP;
4342         phyCellGrpCfg->tpc_PUCCH_RNTI = NULLP;
4343         phyCellGrpCfg->tpc_PUSCH_RNTI = NULLP;
4344         phyCellGrpCfg->sp_CSI_RNTI = NULLP;
4345         phyCellGrpCfg->cs_RNTI = NULLP;
4346         phyCellGrpCfg->ext1 = NULLP;
4347         phyCellGrpCfg->ext2 = NULLP;
4348
4349         return ROK;
4350 }
4351
4352 /*******************************************************************
4353 *
4354 * @brief Builds tag config
4355 *
4356 * @details
4357 *
4358 *    Function : BuildTagConfig
4359 *
4360 *    Functionality: Builds tag config in MacCellGroupConfig
4361 *
4362 * @params[in] TAG_Config *tag_Config
4363 *
4364 * @return ROK     - success
4365 *         RFAILED - failure
4366 *
4367 * ****************************************************************/
4368 uint8_t BuildTagConfig(struct TAG_Config *tagConfig)
4369 {
4370         struct TAG_Config__tag_ToAddModList *tagList;
4371    uint8_t                     idx, elementCnt;
4372
4373    tagConfig->tag_ToReleaseList = NULLP;
4374    tagConfig->tag_ToAddModList = NULLP;
4375    CU_ALLOC(tagConfig->tag_ToAddModList, sizeof(struct TAG_Config__tag_ToAddModList));
4376         if(!tagConfig->tag_ToAddModList)
4377         {
4378                 DU_LOG("\nF1AP : Memory allocation failure in BuildTagConfig");
4379                 return RFAILED;
4380         }
4381
4382         elementCnt = 1; //ODU_VALUE_ONE;
4383         tagList = tagConfig->tag_ToAddModList;
4384         tagList->list.count = elementCnt;
4385         tagList->list.size  =  elementCnt * sizeof(struct TAG *);
4386
4387    tagList->list.array = NULLP;
4388         CU_ALLOC(tagList->list.array, tagList->list.size);
4389         if(!tagList->list.array)
4390         {
4391                 DU_LOG("\nF1AP : Memory allocation failure in BuildTagConfig");
4392                 return RFAILED;
4393         }
4394
4395         for(idx=0; idx<tagList->list.count; idx++)
4396         {
4397            tagList->list.array[idx] = NULLP;
4398                 CU_ALLOC(tagList->list.array[idx], sizeof(struct TAG));
4399                 if(!tagList->list.array[idx])
4400                 {
4401                         DU_LOG("\nF1AP : Memory allocation failure in BuildTagConfig");
4402                         return RFAILED;
4403                 }
4404         }
4405
4406         idx = 0;
4407         tagList->list.array[idx]->tag_Id = TAG_ID;
4408         tagList->list.array[idx]->timeAlignmentTimer = TIME_ALIGNMENT_TMR;
4409
4410    return ROK;
4411 }
4412
4413 /*******************************************************************
4414 *
4415 * @brief Builds PHR Config
4416 *
4417 * @details
4418 *
4419 *    Function : BuildPhrConfig
4420 *
4421 *    Functionality: Builds phrConfig in MacCellGroupConfig
4422 *
4423 * @params[in] PHR Config *
4424 *
4425 * @return ROK     - success
4426 *         RFAILED - failure
4427 *
4428 * ****************************************************************/
4429 uint8_t BuildPhrConfig(struct MAC_CellGroupConfig__phr_Config *phrConfig)
4430 {
4431
4432    phrConfig->present = MAC_CellGroupConfig__phr_Config_PR_setup;
4433         phrConfig->choice.setup = NULLP;
4434         CU_ALLOC(phrConfig->choice.setup, sizeof(struct PHR_Config));
4435         if(!phrConfig->choice.setup)
4436         {
4437                 DU_LOG("\nF1AP : Memory allocation failure in BuildPhrConfig");
4438                 return RFAILED;
4439         }
4440
4441         phrConfig->choice.setup->phr_PeriodicTimer        = PHR_PERIODIC_TMR;
4442         phrConfig->choice.setup->phr_ProhibitTimer        = PHR_PROHIBHIT_TMR;
4443    phrConfig->choice.setup->phr_Tx_PowerFactorChange = PHR_PWR_FACTOR_CHANGE;
4444         phrConfig->choice.setup->multiplePHR              = false;
4445         phrConfig->choice.setup->dummy                    = false;
4446         phrConfig->choice.setup->phr_Type2OtherCell       = false;
4447         phrConfig->choice.setup->phr_ModeOtherCG          = PHR_MODE_OTHER_CG;
4448
4449         return ROK;
4450 }
4451
4452 /*******************************************************************
4453 *
4454 * @brief Builds BSR Config
4455 *
4456 * @details
4457 *
4458 *    Function : BuildBsrConfig
4459 *
4460 *    Functionality: Builds BuildBsrConfig in MacCellGroupConfig
4461 *
4462 * @params[in] BSR_Config *bsrConfig
4463 *
4464 * @return ROK     - success
4465 *         RFAILED - failure
4466 *
4467 * ****************************************************************/
4468 uint8_t BuildBsrConfig(struct BSR_Config *bsrConfig)
4469 {
4470    bsrConfig->periodicBSR_Timer = PERIODIC_BSR_TMR;
4471         bsrConfig->retxBSR_Timer     = RETX_BSR_TMR;
4472         bsrConfig->logicalChannelSR_DelayTimer = NULLP;
4473
4474    return ROK;
4475 }
4476
4477 /*******************************************************************
4478 *
4479 * @brief Builds scheduling request config
4480 *
4481 * @details
4482 *
4483 *    Function : BuildSchedulingReqConfig
4484 *
4485 *    Functionality: Builds BuildSchedulingReqConfig in MacCellGroupConfig
4486 *
4487 * @params[in] SchedulingRequestConfig *schedulingRequestConfig
4488 *
4489 * @return ROK     - success
4490 *         RFAILED - failure
4491 *
4492 * ****************************************************************/
4493 uint8_t BuildSchedulingReqConfig(struct SchedulingRequestConfig *schedulingRequestConfig)
4494 {
4495         struct SchedulingRequestConfig__schedulingRequestToAddModList *schReqList;
4496    uint8_t                     idx, elementCnt;
4497
4498    schedulingRequestConfig->schedulingRequestToAddModList = NULLP;
4499         CU_ALLOC(schedulingRequestConfig->schedulingRequestToAddModList,
4500                         sizeof(struct SchedulingRequestConfig__schedulingRequestToAddModList));
4501         if(!schedulingRequestConfig->schedulingRequestToAddModList)
4502         {
4503                 DU_LOG("\nF1AP : Memory allocation failure in BuildSchedulingReqConfig");
4504                 return RFAILED;
4505         }
4506
4507         elementCnt = 1; //ODU_VALUE_ONE;
4508         schReqList = schedulingRequestConfig->schedulingRequestToAddModList;
4509         schReqList->list.count = elementCnt;
4510    schReqList->list.size  = elementCnt * sizeof(struct SchedulingRequestToAddMod *);
4511
4512    schReqList->list.array = NULLP;
4513    CU_ALLOC(schReqList->list.array, schReqList->list.size);
4514         if(!schReqList->list.array)
4515         {
4516                 DU_LOG("\nF1AP : Memory allocation failure in BuildSchedulingReqConfig");
4517                 return RFAILED;
4518         }
4519
4520    for(idx=0;idx<schReqList->list.count; idx++)
4521         {
4522            schReqList->list.array[idx] = NULLP;
4523                 CU_ALLOC(schReqList->list.array[idx], sizeof(struct SchedulingRequestToAddMod));
4524                 if(!schReqList->list.array[idx])
4525                 {
4526                         DU_LOG("\nF1AP : Memory allocation failure in BuildSchedulingReqConfig");
4527                         return RFAILED;
4528                 }
4529         }
4530
4531         idx = 0;
4532         schReqList->list.array[idx]->schedulingRequestId = SCH_REQ_ID;
4533
4534    schReqList->list.array[idx]->sr_ProhibitTimer = NULLP;
4535         CU_ALLOC(schReqList->list.array[idx]->sr_ProhibitTimer, sizeof(long));
4536         if(!schReqList->list.array[idx]->sr_ProhibitTimer)
4537         {
4538                 DU_LOG("\nF1AP : Memory allocation failure in BuildSchedulingReqConfig");
4539                 return RFAILED;
4540         }
4541    *(schReqList->list.array[idx]->sr_ProhibitTimer) = SR_PROHIBIT_TMR;
4542         schReqList->list.array[idx]->sr_TransMax = SR_TRANS_MAX;
4543         schedulingRequestConfig->schedulingRequestToReleaseList = NULLP;
4544
4545         return ROK;
4546 }
4547 /*******************************************************************
4548 *
4549 * @brief Builds Mac cell group config
4550 *
4551 * @details
4552 *
4553 *    Function : BuildMacCellGrpCfg
4554 *
4555 *    Functionality: Builds Mac cell group config in DuToCuRrcContainer
4556 *
4557 * @params[in] MAC_CellGroupConfig_t *macCellGrpCfg
4558 *
4559 * @return ROK     - success
4560 *         RFAILED - failure
4561 *
4562 * ****************************************************************/
4563 uint8_t BuildMacCellGrpCfg(MAC_CellGroupConfig_t *macCellGrpCfg)
4564 {
4565    macCellGrpCfg->drx_Config = NULLP;
4566    macCellGrpCfg->schedulingRequestConfig = NULLP;
4567         CU_ALLOC(macCellGrpCfg->schedulingRequestConfig, sizeof(struct SchedulingRequestConfig));
4568         if(!macCellGrpCfg->schedulingRequestConfig)
4569         {
4570                 DU_LOG("\nF1AP : Memory allocation failure in BuildMacCellGrpCfg");
4571                 return RFAILED;
4572         }
4573
4574         if(BuildSchedulingReqConfig(macCellGrpCfg->schedulingRequestConfig) != ROK)
4575         {
4576            DU_LOG("\nF1AP : BuildSchedulingReqConfig failed");
4577                 return RFAILED;
4578         }
4579
4580    macCellGrpCfg->bsr_Config = NULLP;
4581    CU_ALLOC(macCellGrpCfg->bsr_Config, sizeof(struct BSR_Config));
4582         if(!macCellGrpCfg->bsr_Config)
4583         {
4584                 DU_LOG("\nF1AP : Memory allocation failure in BuildMacCellGrpCfg");
4585                 return RFAILED;
4586         }
4587
4588    if(BuildBsrConfig(macCellGrpCfg->bsr_Config) != ROK)
4589         {
4590       DU_LOG("\nF1AP : BuildBsrConfig failed");
4591            return RFAILED;
4592         }
4593
4594    macCellGrpCfg->tag_Config = NULLP;
4595    CU_ALLOC(macCellGrpCfg->tag_Config, sizeof(struct TAG_Config));
4596         if(!macCellGrpCfg->tag_Config)
4597         {
4598                 DU_LOG("\nF1AP : Memory allocation failure in BuildMacCellGrpCfg");
4599                 return RFAILED;
4600         }
4601
4602    if(BuildTagConfig(macCellGrpCfg->tag_Config) != ROK)
4603         {
4604            DU_LOG("\nF1AP : BuildTagConfig failed");
4605            return RFAILED;
4606    }
4607
4608    macCellGrpCfg->phr_Config = NULLP;
4609    CU_ALLOC(macCellGrpCfg->phr_Config, sizeof(struct MAC_CellGroupConfig__phr_Config));
4610         if(!macCellGrpCfg->phr_Config)
4611         {
4612                 DU_LOG("\nF1AP : Memory allocation failure in BuildMacCellGrpCfg");
4613                 return RFAILED;
4614         }
4615
4616    if(BuildPhrConfig(macCellGrpCfg->phr_Config) != ROK)
4617         {
4618            DU_LOG("\nF1AP : BuildPhrConfig failed");
4619            return RFAILED;
4620    }
4621
4622    macCellGrpCfg->skipUplinkTxDynamic = false;
4623         macCellGrpCfg->ext1 = NULLP;
4624
4625         return ROK;
4626 }
4627  /*******************************************************************
4628  *
4629  * @brief Frees memeory allocated for SearchSpcToAddModList
4630  *
4631  * @details
4632  *
4633  *    Function : FreeSearchSpcToAddModList
4634  *
4635  *    Functionality: Deallocating memory of SearchSpcToAddModList
4636  *
4637  * @params[in] struct PDCCH_Config__searchSpacesToAddModList *searchSpcList
4638  *
4639  * @return void
4640  *
4641  4221 * ****************************************************************/
4642 void FreeSearchSpcToAddModList(struct PDCCH_Config__searchSpacesToAddModList *searchSpcList)
4643 {
4644     uint8_t idx1=0;
4645     uint8_t idx2=0;
4646     struct  SearchSpace *searchSpc=NULLP;
4647
4648     if(searchSpcList->list.array)
4649          {
4650             if(searchSpcList->list.array[idx2])
4651             {
4652           searchSpc = searchSpcList->list.array[idx2];
4653                if(searchSpc->controlResourceSetId)
4654                {
4655                   if(searchSpc->monitoringSlotPeriodicityAndOffset)
4656                   {
4657                      if(searchSpc->monitoringSymbolsWithinSlot)
4658                      {
4659                         if(searchSpc->monitoringSymbolsWithinSlot->buf)
4660                         {
4661                            if(searchSpc->nrofCandidates)
4662                            {
4663                               if(searchSpc->searchSpaceType)
4664                               {
4665                                  CU_FREE(searchSpc->searchSpaceType->choice.ue_Specific,\
4666                                  sizeof(struct SearchSpace__searchSpaceType__ue_Specific));
4667                                  CU_FREE(searchSpc->searchSpaceType, sizeof(struct
4668                                                                          SearchSpace__searchSpaceType));
4669                               }
4670                               CU_FREE(searchSpc->nrofCandidates,
4671                               sizeof(struct SearchSpace__nrofCandidates));
4672                            }
4673                            CU_FREE(searchSpc->monitoringSymbolsWithinSlot->buf, \
4674                            searchSpc->monitoringSymbolsWithinSlot->size);
4675                         }
4676                         CU_FREE(searchSpc->monitoringSymbolsWithinSlot,
4677                         sizeof(BIT_STRING_t));
4678                      }
4679                      CU_FREE(searchSpc->monitoringSlotPeriodicityAndOffset, \
4680                      sizeof(struct SearchSpace__monitoringSlotPeriodicityAndOffset));
4681                   }
4682                   CU_FREE(searchSpc->controlResourceSetId,
4683                   sizeof(ControlResourceSetId_t));
4684                      }
4685                   }
4686                   for(idx1 = 0; idx1 < searchSpcList->list.count; idx1++)
4687              {
4688                  CU_FREE(searchSpcList->list.array[idx1],
4689                                 sizeof(struct SearchSpace));
4690                   }
4691                   CU_FREE(searchSpcList->list.array,searchSpcList->list.size);
4692          }
4693 }
4694  /*******************************************************************
4695  *
4696  * @brief Frees memory allocated for PdschTimeDomAllocList
4697  *
4698  * @details
4699  *
4700  *    Function : FreePdschTimeDomAllocList
4701  *
4702  *    Functionality: Deallocating memory of PdschTimeDomAllocList
4703  *
4704  * @params[in] struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList
4705  *
4706  * @return void
4707  *
4708  4221 * ****************************************************************/
4709 void FreePdschTimeDomAllocList( struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList)
4710 {
4711    uint8_t idx1=0;
4712
4713         if(timeDomAllocList->choice.setup)
4714    {
4715       if(timeDomAllocList->choice.setup->list.array)
4716       {
4717           for(idx1 = 0; idx1 <timeDomAllocList->choice.setup->list.count ; idx1++)
4718           {
4719              CU_FREE(timeDomAllocList->choice.setup->list.array[idx1],
4720              sizeof(struct PDSCH_TimeDomainResourceAllocation));
4721           }
4722           CU_FREE(timeDomAllocList->choice.setup->list.array, \
4723           timeDomAllocList->choice.setup->list.size);
4724       }
4725       CU_FREE(timeDomAllocList->choice.setup,\
4726       sizeof(struct PDSCH_TimeDomainResourceAllocationList));
4727    }
4728 }
4729  /*******************************************************************
4730  *
4731  * @brief Frees memory allocated for PuschTimeDomAllocList
4732  *
4733  *@details
4734  *
4735  *    Function : FreePuschTimeDomAllocList
4736  *
4737  *    Functionality: Deallocating memory of PuschTimeDomAllocList
4738  *
4739  * @params[in] PUSCH_Config_t *puschCfg
4740  *
4741  * @return void
4742  *
4743  ***********************************************************************/
4744 void FreePuschTimeDomAllocList(PUSCH_Config_t *puschCfg)
4745 {
4746     uint8_t idx1=0;
4747          uint8_t idx2=0;
4748     struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList_t=NULLP;
4749
4750     if(puschCfg->pusch_TimeDomainAllocationList)
4751     {
4752        timeDomAllocList_t=puschCfg->pusch_TimeDomainAllocationList;
4753        if(timeDomAllocList_t->choice.setup)
4754        {
4755           if(timeDomAllocList_t->choice.setup->list.array)
4756           {
4757              CU_FREE(timeDomAllocList_t->choice.setup->list.array[idx2]->k2, sizeof(long));
4758              for(idx1 = 0; idx1<timeDomAllocList_t->choice.setup->list.count; idx1++)
4759              {
4760                 CU_FREE(timeDomAllocList_t->choice.setup->list.array[idx1],\
4761                                     sizeof(PUSCH_TimeDomainResourceAllocation_t));
4762                                  }
4763                                  CU_FREE(timeDomAllocList_t->choice.setup->list.array, \
4764              timeDomAllocList_t->choice.setup->list.size);
4765           }
4766           CU_FREE(timeDomAllocList_t->choice.setup, \
4767                sizeof(struct PUSCH_TimeDomainResourceAllocationList));
4768        }
4769                  CU_FREE(puschCfg->transformPrecoder, sizeof(long));
4770        CU_FREE(puschCfg->pusch_TimeDomainAllocationList, \
4771                  sizeof(struct PUSCH_Config__pusch_TimeDomainAllocationList));
4772     }
4773
4774 }
4775  /*******************************************************************
4776  *
4777  * @brief Frees memory allocated for InitialUlBWP
4778  *
4779  * @details
4780  *
4781  *    Function : FreeInitialUlBWP
4782  *
4783  *    Functionality: Deallocating memory of InitialUlBWP
4784  *
4785  * @params[in] BWP_UplinkDedicated_t *ulBwp
4786  *
4787  * @return void
4788  *
4789  * ****************************************************************/
4790 void FreeInitialUlBWP(BWP_UplinkDedicated_t *ulBwp)
4791 {
4792     uint8_t  rSetIdx, rsrcIdx;
4793     SRS_Config_t   *srsCfg = NULLP;
4794     PUSCH_Config_t *puschCfg = NULLP;
4795     struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA *dmrsUlCfg = NULLP;
4796          struct SRS_Config__srs_ResourceSetToAddModList *rsrcSetList = NULLP;
4797          struct SRS_ResourceSet__srs_ResourceIdList *rsrcIdList = NULLP;
4798          struct SRS_Config__srs_ResourceToAddModList *resourceList = NULLP;
4799
4800          if(ulBwp->pusch_Config)
4801     {
4802        if(ulBwp->pusch_Config->choice.setup)
4803        {
4804           puschCfg=ulBwp->pusch_Config->choice.setup;
4805           if(puschCfg->dataScramblingIdentityPUSCH)
4806           {
4807              if(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA)
4808              {
4809                 FreePuschTimeDomAllocList(puschCfg);
4810                 dmrsUlCfg=puschCfg->dmrs_UplinkForPUSCH_MappingTypeA;
4811                                          if(dmrsUlCfg->choice.setup)
4812                 {
4813                    if(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition)
4814                    {
4815                       if(dmrsUlCfg->choice.setup->transformPrecodingDisabled)
4816                       {
4817                          CU_FREE(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0,\
4818                                                                  sizeof(long));
4819                                                                  CU_FREE(dmrsUlCfg->choice.setup->transformPrecodingDisabled,
4820                          sizeof(struct DMRS_UplinkConfig__transformPrecodingDisabled));
4821                                                          }
4822                                                          CU_FREE(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition,
4823                                                          sizeof(long));
4824                                                  }
4825                                                  CU_FREE(dmrsUlCfg->choice.setup,sizeof(DMRS_UplinkConfig_t));
4826                 }
4827                                          CU_FREE(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA, \
4828                                          sizeof(struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA));
4829                                  }
4830              CU_FREE(puschCfg->dataScramblingIdentityPUSCH, sizeof(long));
4831           }
4832           CU_FREE(ulBwp->pusch_Config->choice.setup, sizeof(PUSCH_Config_t));
4833             }
4834                  CU_FREE(ulBwp->pusch_Config, sizeof(struct BWP_UplinkDedicated__pusch_Config));
4835
4836                  /* Free SRS-Config */
4837                  if(ulBwp->srs_Config)
4838                  {
4839                     if(ulBwp->srs_Config->choice.setup)
4840                          {
4841                             srsCfg = ulBwp->srs_Config->choice.setup;
4842
4843                                  /* Free Resource Set to add/mod list */
4844                             if(srsCfg->srs_ResourceSetToAddModList)
4845                                  {
4846                                     rsrcSetList = srsCfg->srs_ResourceSetToAddModList;
4847                                          if(rsrcSetList->list.array)
4848                                          {
4849                                             rSetIdx = 0;
4850
4851                                                  /* Free SRS resource Id list in this SRS resource set */
4852                                                  if(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList)
4853                                                  {
4854                                                     rsrcIdList = rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList;
4855
4856                                                     if(rsrcIdList->list.array)
4857                                                          {
4858                                                             for(rsrcIdx = 0; rsrcIdx < rsrcIdList->list.count; rsrcIdx++)
4859                                                                  {
4860                                                                     CU_FREE(rsrcIdList->list.array[rsrcIdx], sizeof(SRS_ResourceId_t));
4861                                                             }
4862                                                             CU_FREE(rsrcIdList->list.array, rsrcIdList->list.size);
4863                                                          }
4864                                                     CU_FREE(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList,\
4865                                                             sizeof(struct SRS_ResourceSet__srs_ResourceIdList));
4866                                                  }
4867
4868                                                  /* Free resource type info for this SRS resource set */
4869                                                  CU_FREE(rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic, \
4870                                                     sizeof(struct SRS_ResourceSet__resourceType__aperiodic));
4871
4872                                                  /* Free memory for each resource set */
4873                                             for(rSetIdx = 0; rSetIdx < rsrcSetList->list.count; rSetIdx++)
4874                                                  {
4875                                                     CU_FREE(rsrcSetList->list.array[rSetIdx], sizeof(SRS_ResourceSet_t));
4876                                                  }
4877                                             CU_FREE(rsrcSetList->list.array, rsrcSetList->list.size);
4878                                          }
4879                                     CU_FREE(srsCfg->srs_ResourceSetToAddModList, \
4880                                             sizeof(struct SRS_Config__srs_ResourceSetToAddModList));
4881                                  }
4882
4883                                  /* Free resource to add/modd list */
4884                                  if(srsCfg->srs_ResourceToAddModList)
4885                                  {
4886                                     resourceList = srsCfg->srs_ResourceToAddModList;
4887                                          if(resourceList->list.array)
4888                                          {
4889                                             rsrcIdx = 0;
4890                                                  CU_FREE(resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2,\
4891                                                     sizeof(struct SRS_Resource__transmissionComb__n2));
4892                                             CU_FREE(resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic,\
4893                                                     sizeof(struct SRS_Resource__resourceType__aperiodic));
4894
4895                                             for(rsrcIdx = 0; rsrcIdx < resourceList->list.count; rsrcIdx++)
4896                                                  {
4897                                                     CU_FREE(resourceList->list.array[rsrcIdx], sizeof(SRS_Resource_t));
4898                    }
4899                                             CU_FREE(resourceList->list.array, resourceList->list.size);
4900                                          }
4901                                     CU_FREE(srsCfg->srs_ResourceToAddModList, \
4902                                             sizeof(struct SRS_Config__srs_ResourceToAddModList));
4903                                  }
4904
4905                             CU_FREE(ulBwp->srs_Config->choice.setup, sizeof(SRS_Config_t));
4906                          }
4907                     CU_FREE(ulBwp->srs_Config, sizeof(struct BWP_UplinkDedicated__srs_Config));
4908        }
4909          }
4910 }
4911  /*******************************************************************
4912  *
4913  * @brief Frees memory allocated for initialUplinkBWP
4914  *
4915  * @details
4916  *
4917  *    Function : FreeinitialUplinkBWP
4918  *
4919  *    Functionality: Deallocating memory of initialUplinkBWP
4920  *
4921  * @params[in] UplinkConfig_t *ulCfg
4922  *
4923  * @return void
4924  *
4925  *
4926  * ****************************************************************/
4927 void FreeinitialUplinkBWP(UplinkConfig_t *ulCfg)
4928 {
4929    BWP_UplinkDedicated_t *ulBwp=NULLP;
4930    struct UplinkConfig__pusch_ServingCellConfig *puschCfg=NULLP;
4931
4932         if(ulCfg->initialUplinkBWP)
4933         {
4934            ulBwp=ulCfg->initialUplinkBWP;
4935            if(ulCfg->firstActiveUplinkBWP_Id)
4936            {
4937               if(ulCfg->pusch_ServingCellConfig)
4938               {
4939                  puschCfg=ulCfg->pusch_ServingCellConfig;
4940                  if(puschCfg->choice.setup)
4941                  {
4942                     if(puschCfg->choice.setup->ext1)
4943                     {
4944                         CU_FREE(puschCfg->choice.setup->ext1->\
4945                                                  processingType2Enabled,sizeof(BOOLEAN_t));
4946                         CU_FREE(puschCfg->choice.setup->ext1->\
4947                                                  maxMIMO_Layers,sizeof(long));
4948                                                  CU_FREE(puschCfg->choice.setup->ext1, \
4949                                                  sizeof(struct PUSCH_ServingCellConfig__ext1));
4950                                         }
4951                     CU_FREE(puschCfg->choice.setup, sizeof(struct PUSCH_ServingCellConfig));
4952                  }
4953                  CU_FREE(ulCfg->pusch_ServingCellConfig, sizeof(struct UplinkConfig__pusch_ServingCellConfig));
4954               }
4955               CU_FREE(ulCfg->firstActiveUplinkBWP_Id, sizeof(BWP_Id_t));
4956            }
4957            FreeInitialUlBWP(ulBwp);
4958            CU_FREE(ulCfg->initialUplinkBWP, sizeof(BWP_UplinkDedicated_t));
4959         }
4960 }
4961  /*******************************************************************
4962  *
4963  * @brief Frees emmory allocated for BWPDlDedPdschCfg
4964  *
4965  * @details
4966  *
4967  *    Function : FreeBWPDlDedPdschCfg
4968  *
4969  *    Functionality: Deallocating memory of BWPDlDedPdschCfg
4970  *
4971  * @params[in] BWP_DownlinkDedicated_t *dlBwp
4972  *
4973  * @return void
4974  *
4975  *
4976  * ****************************************************************/
4977 void FreeBWPDlDedPdschCfg(BWP_DownlinkDedicated_t *dlBwp)
4978 {
4979    struct PDSCH_Config *pdschCfg=NULLP;
4980         struct PDSCH_Config__prb_BundlingType *prbBndlType=NULLP;
4981    struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList=NULLP;
4982    struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA *dmrsDlCfg=NULLP;
4983
4984         if(dlBwp->pdsch_Config->choice.setup)
4985    {
4986       pdschCfg=dlBwp->pdsch_Config->choice.setup;
4987       if(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA)
4988       {
4989           if(pdschCfg->pdsch_TimeDomainAllocationList)
4990           {
4991              timeDomAllocList=pdschCfg->pdsch_TimeDomainAllocationList;
4992              if(pdschCfg->maxNrofCodeWordsScheduledByDCI)
4993              {
4994                 prbBndlType=&pdschCfg->prb_BundlingType;
4995                 CU_FREE(prbBndlType->choice.staticBundling,\
4996                 sizeof(struct PDSCH_Config__prb_BundlingType__staticBundling));
4997                 CU_FREE(pdschCfg->maxNrofCodeWordsScheduledByDCI, sizeof(long));
4998              }
4999              FreePdschTimeDomAllocList(timeDomAllocList);
5000              CU_FREE(pdschCfg->pdsch_TimeDomainAllocationList, \
5001              sizeof(struct PDSCH_Config__pdsch_TimeDomainAllocationList));
5002           }
5003           dmrsDlCfg=pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA;
5004           if(dmrsDlCfg->choice.setup)
5005           {
5006              CU_FREE(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition,
5007              sizeof(long));
5008              CU_FREE(dmrsDlCfg->choice.setup, sizeof(struct DMRS_DownlinkConfig));
5009           }
5010           CU_FREE(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA, \
5011           sizeof(struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA));
5012        }
5013        CU_FREE(dlBwp->pdsch_Config->choice.setup, sizeof(struct PDSCH_Config));
5014     }
5015 }
5016  /*******************************************************************
5017  *
5018  * @brief Frees emmory allocated for BWPDlDedPdcchCfg
5019  *
5020  * @details
5021  *
5022  *    Function : FreeBWPDlDedPdcchCfg
5023  *
5024  *    Functionality: Deallocating memory of BWPDlDedPdcchCfg
5025  *
5026  * @params[in] BWP_DownlinkDedicated_t *dlBwp
5027  *
5028  * @return void
5029  *
5030  *
5031  * ****************************************************************/
5032 void FreeBWPDlDedPdcchCfg(BWP_DownlinkDedicated_t *dlBwp)
5033 {
5034    uint8_t idx1=0;
5035         uint8_t idx2=0;
5036         struct PDCCH_Config *pdcchCfg=NULLP;
5037    struct ControlResourceSet *controlRSet=NULLP;
5038         struct PDCCH_Config__controlResourceSetToAddModList *controlRSetList=NULLP;
5039
5040         if(dlBwp->pdcch_Config->choice.setup)
5041    {
5042       pdcchCfg=dlBwp->pdcch_Config->choice.setup;
5043       if(pdcchCfg->controlResourceSetToAddModList)
5044       {
5045          controlRSetList = pdcchCfg->controlResourceSetToAddModList;
5046          if(controlRSetList->list.array)
5047          {
5048             controlRSet = controlRSetList->list.array[idx2];
5049             if(controlRSet)
5050             {
5051                if(controlRSet->frequencyDomainResources.buf)
5052                {
5053                   if(controlRSet->pdcch_DMRS_ScramblingID)
5054                   {
5055                      if(pdcchCfg->searchSpacesToAddModList)
5056                      {
5057                          FreeSearchSpcToAddModList(pdcchCfg->searchSpacesToAddModList);
5058                          CU_FREE(pdcchCfg->searchSpacesToAddModList, \
5059                          sizeof(struct PDCCH_Config__searchSpacesToAddModList));
5060                      }
5061                      CU_FREE(controlRSet->pdcch_DMRS_ScramblingID, sizeof(long));
5062                   }
5063                                                 CU_FREE(controlRSet->frequencyDomainResources.buf, \
5064                                                 controlRSet->frequencyDomainResources.size);
5065                                         }
5066                                 }
5067             for(idx1 = 0; idx1 <controlRSetList->list.count; idx1++)
5068             {
5069                CU_FREE(controlRSetList->list.array[idx1], sizeof(struct ControlResourceSet));
5070             }
5071                                 CU_FREE(controlRSetList->list.array, controlRSetList->list.size);
5072                         }
5073                         CU_FREE(pdcchCfg->controlResourceSetToAddModList, \
5074                         sizeof(struct PDCCH_Config__controlResourceSetToAddModList));
5075                 }
5076                 CU_FREE(dlBwp->pdcch_Config->choice.setup, sizeof(struct PDCCH_Config));
5077         }
5078 }
5079 /*******************************************************************
5080 *
5081 * @brief Builds RLC Config
5082 *
5083 * @details
5084 *
5085 *    Function : BuildRlcConfig
5086 *
5087 *    Functionality: Builds RLC Config in BuildRlcBearerToAddModList
5088 *
5089 * @params[in] RLC_Config *rlcConfig
5090 *
5091 * @return ROK     - success
5092 *         RFAILED - failure
5093 *
5094 * ****************************************************************/
5095 uint8_t BuildRlcConfig(struct RLC_Config *rlcConfig)
5096 {
5097
5098    rlcConfig->present = RLC_Config_PR_am;
5099
5100    rlcConfig->choice.am = NULLP;
5101    CU_ALLOC(rlcConfig->choice.am, sizeof(struct RLC_Config__am));
5102         if(!rlcConfig->choice.am)
5103         {
5104                 DU_LOG("\nF1AP : Memory allocation failure in BuildRlcConfig");
5105                 return RFAILED;
5106         }
5107
5108    /* UL */
5109         rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength = NULLP;
5110    CU_ALLOC(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
5111         if(!rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength)
5112         {
5113                 DU_LOG("\nF1AP : Memory allocation failure in BuildRlcConfig");
5114                 return RFAILED;
5115         }
5116    *(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength) = SN_FIELD_LEN;
5117         rlcConfig->choice.am->ul_AM_RLC.t_PollRetransmit  = T_POLL_RETRANSMIT;
5118         rlcConfig->choice.am->ul_AM_RLC.pollPDU           = POLL_PDU;
5119         rlcConfig->choice.am->ul_AM_RLC.pollByte          = POLL_BYTE;
5120         rlcConfig->choice.am->ul_AM_RLC.maxRetxThreshold  = MAX_RETX_THRESHOLD;
5121
5122    /* DL */
5123    rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength = NULLP;
5124    CU_ALLOC(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
5125         if(!rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength)
5126         {
5127                 DU_LOG("\nF1AP : Memory allocation failure in BuildRlcConfig");
5128                 return RFAILED;
5129         }
5130         *(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength) = SN_FIELD_LEN;
5131    rlcConfig->choice.am->dl_AM_RLC.t_Reassembly      = T_REASSEMBLY;
5132         rlcConfig->choice.am->dl_AM_RLC.t_StatusProhibit  = T_STATUS_PROHIBHIT;
5133
5134    return ROK;
5135 }
5136
5137 /*******************************************************************
5138 *
5139 * @brief Builds MAC LC Config
5140 *
5141 * @details
5142 *
5143 *    Function : BuildMacLCConfig
5144 *
5145 *    Functionality: Builds MAC LC Config in BuildRlcBearerToAddModList
5146 *
5147 * @params[in] struct LogicalChannelConfig macLcConfig
5148 *
5149 * @return ROK     - success
5150 *         RFAILED - failure
5151 *
5152 * ****************************************************************/
5153 uint8_t BuildMacLCConfig(struct LogicalChannelConfig *macLcConfig)
5154 {
5155
5156    macLcConfig->ul_SpecificParameters = NULLP;
5157    CU_ALLOC(macLcConfig->ul_SpecificParameters, sizeof(struct LogicalChannelConfig__ul_SpecificParameters));
5158         if(!macLcConfig->ul_SpecificParameters)
5159         {
5160                 DU_LOG("\nF1AP : Memory allocation failure in BuildMacLCConfig");
5161                 return RFAILED;
5162         }
5163
5164    macLcConfig->ul_SpecificParameters->priority = MAC_LC_PRIORITY;
5165         macLcConfig->ul_SpecificParameters->prioritisedBitRate =        PRIORTISIED_BIT_RATE;
5166         macLcConfig->ul_SpecificParameters->bucketSizeDuration =        BUCKET_SIZE_DURATION;
5167    macLcConfig->ul_SpecificParameters->allowedServingCells = NULLP;
5168         macLcConfig->ul_SpecificParameters->allowedSCS_List = NULLP;
5169         macLcConfig->ul_SpecificParameters->maxPUSCH_Duration = NULLP;
5170    macLcConfig->ul_SpecificParameters->configuredGrantType1Allowed = NULLP;
5171
5172    macLcConfig->ul_SpecificParameters->logicalChannelGroup = NULLP;
5173    CU_ALLOC(macLcConfig->ul_SpecificParameters->logicalChannelGroup,    sizeof(long));
5174    if(!macLcConfig->ul_SpecificParameters->logicalChannelGroup)
5175         {
5176                 DU_LOG("\nF1AP : Memory allocation failure in BuildMacLCConfig");
5177                 return RFAILED;
5178         }
5179    *(macLcConfig->ul_SpecificParameters->logicalChannelGroup) = LC_GRP;
5180
5181    macLcConfig->ul_SpecificParameters->schedulingRequestID = NULLP;
5182         CU_ALLOC(macLcConfig->ul_SpecificParameters->schedulingRequestID,       sizeof(SchedulingRequestId_t));
5183         if(!macLcConfig->ul_SpecificParameters->schedulingRequestID)
5184         {
5185                 DU_LOG("\nF1AP : Memory allocation failure in BuildMacLCConfig");
5186                 return RFAILED;
5187         }
5188    *(macLcConfig->ul_SpecificParameters->schedulingRequestID) = SCH_REQ_ID;
5189
5190         macLcConfig->ul_SpecificParameters->logicalChannelSR_Mask = false;
5191         macLcConfig->ul_SpecificParameters->logicalChannelSR_DelayTimerApplied = false;
5192         macLcConfig->ul_SpecificParameters->bitRateQueryProhibitTimer = NULLP;
5193
5194    return ROK;
5195 }
5196 /*******************************************************************
5197 *
5198 * @brief Builds RLC Bearer to Add/Mod list
5199 *
5200 * @details
5201 *
5202 *    Function :BuildRlcBearerToAddModList
5203 *
5204 *    Functionality: Builds RLC Bearer to Add/Mod list in DuToCuRrcContainer
5205 *
5206 * @params[in] rlc_BearerToAddModList
5207 *
5208 * @return ROK     - success
5209 *         RFAILED - failure
5210 *
5211 * ****************************************************************/
5212 uint8_t BuildRlcBearerToAddModList(struct CellGroupConfigRrc__rlc_BearerToAddModList *rlcBearerList)
5213 {
5214    uint8_t                     idx, elementCnt;
5215
5216    elementCnt = 1;
5217    rlcBearerList->list.count = elementCnt;
5218         rlcBearerList->list.size  = elementCnt * sizeof(struct RLC_BearerConfig *);
5219
5220    rlcBearerList->list.array = NULLP;
5221         CU_ALLOC(rlcBearerList->list.array, rlcBearerList->list.size);
5222         if(!rlcBearerList->list.array)
5223         {
5224                 DU_LOG("\nF1AP : Memory allocation failure in BuildRlcBearerToAddModList");
5225                 return RFAILED;
5226         }
5227
5228    for(idx=0; idx<rlcBearerList->list.count; idx++)
5229         {
5230            rlcBearerList->list.array[idx] = NULLP;
5231                 CU_ALLOC(rlcBearerList->list.array[idx], sizeof(struct RLC_BearerConfig));
5232                 if(!rlcBearerList->list.array[idx])
5233                 {
5234                         DU_LOG("\nF1AP : Memory allocation failure in BuildRlcBearerToAddModList");
5235                         return RFAILED;
5236                 }
5237         }
5238
5239    idx = 0;
5240         rlcBearerList->list.array[idx]->logicalChannelIdentity = RLC_LCID;
5241
5242         CU_ALLOC(rlcBearerList->list.array[idx]->servedRadioBearer, sizeof(struct RLC_BearerConfig__servedRadioBearer));
5243         if(!rlcBearerList->list.array[idx]->servedRadioBearer)
5244         {
5245                 DU_LOG("\nF1AP : Memory allocation failure in BuildRlcBearerToAddModList");
5246                 return RFAILED;
5247         }
5248
5249         rlcBearerList->list.array[idx]->servedRadioBearer->present = RLC_BearerConfig__servedRadioBearer_PR_srb_Identity;
5250    rlcBearerList->list.array[idx]->servedRadioBearer->choice.srb_Identity = SRB_ID_1;
5251
5252    rlcBearerList->list.array[idx]->reestablishRLC = NULLP;
5253    rlcBearerList->list.array[idx]->rlc_Config = NULLP;
5254    CU_ALLOC(rlcBearerList->list.array[idx]->rlc_Config, sizeof(struct RLC_Config));
5255         if(!rlcBearerList->list.array[idx]->rlc_Config)
5256         {
5257                 DU_LOG("\nF1AP : Memory allocation failure in BuildRlcBearerToAddModList");
5258                 return RFAILED;
5259         }
5260
5261    if(BuildRlcConfig(rlcBearerList->list.array[idx]->rlc_Config) != ROK)
5262         {
5263                 DU_LOG("\nF1AP : BuildRlcConfig failed");
5264                 return RFAILED;
5265         }
5266
5267    rlcBearerList->list.array[idx]->mac_LogicalChannelConfig = NULLP;
5268    CU_ALLOC(rlcBearerList->list.array[idx]->mac_LogicalChannelConfig, sizeof(struct LogicalChannelConfig));
5269         if(!rlcBearerList->list.array[idx]->mac_LogicalChannelConfig)
5270         {
5271                 DU_LOG("\nF1AP : Memory allocation failure in BuildRlcBearerToAddModList");
5272                 return RFAILED;
5273         }
5274
5275         if(BuildMacLCConfig(rlcBearerList->list.array[idx]->mac_LogicalChannelConfig) != ROK)
5276         {
5277                 DU_LOG("\nF1AP : BuildMacLCConfig failed");
5278                 return RFAILED;
5279         }
5280
5281         return ROK;
5282 }
5283
5284 /*******************************************************************
5285  *
5286  * @brief Free memory allocated for CellGroupConfig
5287  *
5288  * @details
5289  *
5290  *    Function : FreeMemCellGrpCfg
5291  *
5292  *    Functionality: Deallocating memory of CellGroupConfig
5293  *
5294  * @params[in] pointer to CellGroupConfigRrc_t
5295  *
5296  * @return ROK     - success
5297  *         RFAILED - failure
5298  *
5299  ******************************************************************/
5300 uint8_t FreeMemCellGrpCfg(CellGroupConfigRrc_t *cellGrpCfg)
5301 {
5302    uint8_t idx=0;
5303    SpCellConfig_t *spCellCfg=NULLP;
5304    ServingCellConfig_t *srvCellCfg=NULLP;
5305    BWP_DownlinkDedicated_t *dlBwp=NULLP;
5306    MAC_CellGroupConfig_t *macCellGrpCfg=NULLP;
5307    PhysicalCellGroupConfig_t *phyCellGrpCfg=NULLP;
5308    struct CellGroupConfigRrc__rlc_BearerToAddModList *rlcBearerList=NULLP;
5309    struct RLC_Config *rlcConfig=NULLP;
5310    struct LogicalChannelConfig *macLcConfig=NULLP;
5311    struct SchedulingRequestConfig *schedulingRequestConfig=NULLP;
5312    struct SchedulingRequestConfig__schedulingRequestToAddModList *schReqList=NULLP;
5313    struct TAG_Config *tagConfig=NULLP;
5314    struct TAG_Config__tag_ToAddModList *tagList=NULLP;
5315    struct MAC_CellGroupConfig__phr_Config *phrConfig=NULLP;
5316    struct ServingCellConfig__pdsch_ServingCellConfig *pdschCfg=NULLP;
5317
5318    rlcBearerList = cellGrpCfg->rlc_BearerToAddModList;
5319    if(rlcBearerList)
5320    {
5321       if(rlcBearerList->list.array)
5322       {
5323          for(idx=0; idx<rlcBearerList->list.count; idx++)
5324          {
5325             if(rlcBearerList->list.array[idx])
5326             {
5327                rlcConfig   = rlcBearerList->list.array[idx]->rlc_Config;
5328                macLcConfig = rlcBearerList->list.array[idx]->mac_LogicalChannelConfig;
5329                if(rlcConfig)
5330                {
5331                   if(rlcConfig->choice.am)
5332                   {
5333                      CU_FREE(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
5334                      CU_FREE(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
5335                      CU_FREE(rlcConfig->choice.am, sizeof(struct RLC_Config__am));
5336                   }
5337                   CU_FREE(rlcConfig, sizeof(struct RLC_Config));
5338                }
5339                CU_FREE(rlcBearerList->list.array[idx]->servedRadioBearer, sizeof(struct RLC_BearerConfig__servedRadioBearer));
5340                if(macLcConfig)
5341                {
5342                   if(macLcConfig->ul_SpecificParameters)
5343                   {
5344                      CU_FREE(macLcConfig->ul_SpecificParameters->schedulingRequestID,   sizeof(SchedulingRequestId_t));
5345                      CU_FREE(macLcConfig->ul_SpecificParameters->logicalChannelGroup,   sizeof(long));
5346                      CU_FREE(macLcConfig->ul_SpecificParameters, sizeof(struct LogicalChannelConfig__ul_SpecificParameters));
5347                   }
5348                   CU_FREE(rlcBearerList->list.array[idx]->mac_LogicalChannelConfig, sizeof(struct LogicalChannelConfig));
5349                }
5350                CU_FREE(rlcBearerList->list.array[idx], sizeof(struct RLC_BearerConfig));
5351             }
5352          }
5353          CU_FREE(rlcBearerList->list.array, rlcBearerList->list.size);
5354       }
5355       CU_FREE(cellGrpCfg->rlc_BearerToAddModList, sizeof(struct CellGroupConfigRrc__rlc_BearerToAddModList));
5356    }
5357
5358    macCellGrpCfg = cellGrpCfg->mac_CellGroupConfig;
5359    if(macCellGrpCfg)
5360    {
5361       schedulingRequestConfig = macCellGrpCfg->schedulingRequestConfig;
5362       if(schedulingRequestConfig)
5363       {
5364          schReqList = schedulingRequestConfig->schedulingRequestToAddModList;
5365          if(schReqList)
5366          {
5367             if(schReqList->list.array)
5368             {
5369                for(idx=0;idx<schReqList->list.count; idx++)
5370                {
5371                   if(schReqList->list.array[idx])
5372                   {
5373                      CU_FREE(schReqList->list.array[idx]->sr_ProhibitTimer, sizeof(long));
5374                      CU_FREE(schReqList->list.array[idx], sizeof(struct SchedulingRequestToAddMod));
5375                   }
5376                }
5377                CU_FREE(schReqList->list.array, schReqList->list.size);
5378             }
5379             CU_FREE(schedulingRequestConfig->schedulingRequestToAddModList,\
5380                   sizeof(struct SchedulingRequestConfig__schedulingRequestToAddModList));    }
5381             CU_FREE(macCellGrpCfg->schedulingRequestConfig, sizeof(struct SchedulingRequestConfig));
5382       }
5383       if(macCellGrpCfg->bsr_Config)
5384       {
5385          CU_FREE(macCellGrpCfg->bsr_Config, sizeof(struct BSR_Config));
5386       }
5387       tagConfig = macCellGrpCfg->tag_Config;
5388       if(tagConfig)
5389       {
5390          tagList = tagConfig->tag_ToAddModList;
5391          if(tagList)
5392          {
5393             if(tagList->list.array)
5394             {
5395                for(idx=0; idx<tagList->list.count; idx++)
5396                {
5397                   CU_FREE(tagList->list.array[idx], sizeof(struct TAG));
5398                }
5399                CU_FREE(tagList->list.array, tagList->list.size);
5400             }
5401             CU_FREE(tagConfig->tag_ToAddModList, sizeof(struct TAG_Config__tag_ToAddModList));
5402          }
5403          CU_FREE(tagConfig, sizeof(struct TAG_Config));
5404       }
5405
5406       phrConfig = macCellGrpCfg->phr_Config;
5407       if(phrConfig)
5408       {
5409          CU_FREE(phrConfig->choice.setup, sizeof(struct PHR_Config));
5410          CU_FREE(phrConfig, sizeof(struct MAC_CellGroupConfig__phr_Config));
5411       }
5412
5413       CU_FREE(macCellGrpCfg, sizeof(MAC_CellGroupConfig_t));
5414    }
5415
5416    phyCellGrpCfg = cellGrpCfg->physicalCellGroupConfig;
5417    if(phyCellGrpCfg)
5418    {
5419       CU_FREE(phyCellGrpCfg->p_NR_FR1, sizeof(long));
5420       CU_FREE(phyCellGrpCfg, sizeof(PhysicalCellGroupConfig_t));
5421    }
5422
5423    spCellCfg = cellGrpCfg->spCellConfig;
5424    if(spCellCfg)
5425    {
5426       if(spCellCfg->servCellIndex)
5427       {
5428          if(spCellCfg->rlmInSyncOutOfSyncThreshold)
5429          {
5430             if(spCellCfg->spCellConfigDedicated)
5431             {
5432                srvCellCfg = spCellCfg->spCellConfigDedicated;
5433                if(srvCellCfg->initialDownlinkBWP)
5434                {
5435                   dlBwp = srvCellCfg->initialDownlinkBWP;
5436                   if(srvCellCfg->firstActiveDownlinkBWP_Id)
5437                   {
5438                      if(srvCellCfg->defaultDownlinkBWP_Id)
5439                      {
5440                         if(srvCellCfg->uplinkConfig)
5441                         {
5442                            if(srvCellCfg->pdsch_ServingCellConfig)
5443                            {
5444                               pdschCfg= srvCellCfg->pdsch_ServingCellConfig;
5445                               if(pdschCfg->choice.setup)
5446                               {
5447                                  CU_FREE(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH,sizeof(long));
5448                                  CU_FREE(pdschCfg->choice.setup, sizeof( struct PDSCH_ServingCellConfig));
5449                               }
5450                               CU_FREE(srvCellCfg->pdsch_ServingCellConfig, sizeof(struct
5451                                        ServingCellConfig__pdsch_ServingCellConfig));
5452                            }
5453                            FreeinitialUplinkBWP(srvCellCfg->uplinkConfig);
5454                            CU_FREE(srvCellCfg->uplinkConfig, sizeof(UplinkConfig_t));
5455                         }
5456                         CU_FREE(srvCellCfg->defaultDownlinkBWP_Id, sizeof(long));
5457                      }
5458                      CU_FREE(srvCellCfg->firstActiveDownlinkBWP_Id, sizeof(long));
5459                   }
5460                   if(dlBwp->pdcch_Config)
5461                   {
5462                      if(dlBwp->pdsch_Config)
5463                      {
5464                         FreeBWPDlDedPdschCfg(dlBwp);
5465                         CU_FREE(dlBwp->pdsch_Config, sizeof(struct BWP_DownlinkDedicated__pdsch_Config));
5466                      }
5467                      FreeBWPDlDedPdcchCfg(dlBwp);
5468                      CU_FREE(dlBwp->pdcch_Config, sizeof(struct BWP_DownlinkDedicated__pdcch_Config));
5469                   }
5470                   CU_FREE(srvCellCfg->initialDownlinkBWP, sizeof(BWP_DownlinkDedicated_t));
5471                }
5472                CU_FREE(spCellCfg->spCellConfigDedicated, sizeof(ServingCellConfig_t));
5473             }
5474             CU_FREE(spCellCfg->rlmInSyncOutOfSyncThreshold, sizeof(long));
5475          }
5476          CU_FREE(spCellCfg->servCellIndex, sizeof(long));
5477       }
5478       CU_FREE(spCellCfg,sizeof(SpCellConfig_t));
5479    }
5480    return ROK;
5481 }
5482
5483 /*******************************************************************
5484  *
5485  * @brief Fills CellGroupConfig
5486  *
5487  * @details
5488  *
5489  *    Function : fillCellGrpCfg
5490  *
5491  *    Functionality: Fills CellGroupConfig
5492  *
5493  * @params[in] pointer to CellGroupConfigRrc_t
5494  *
5495  * @return ROK     - success
5496  *         RFAILED - failure
5497  *
5498  ******************************************************************/
5499
5500 uint8_t fillCellGrpCfg(CellGroupConfig_t *cellGrp)
5501 {
5502    uint8_t               ret = RFAILED;
5503    CellGroupConfigRrc_t  cellGrpCfg;
5504    asn_enc_rval_t        encRetVal;
5505
5506    while(true)
5507    {
5508       cellGrpCfg.cellGroupId = CELL_GRP_ID;
5509
5510       cellGrpCfg.rlc_BearerToAddModList = NULLP;
5511       CU_ALLOC(cellGrpCfg.rlc_BearerToAddModList, sizeof(struct CellGroupConfigRrc__rlc_BearerToAddModList));
5512       if(!cellGrpCfg.rlc_BearerToAddModList)
5513       {
5514          DU_LOG("\nF1AP : Memory allocation failure in CellGrpConfig");
5515          break;
5516       }
5517       if(BuildRlcBearerToAddModList(cellGrpCfg.rlc_BearerToAddModList) != ROK)
5518       {
5519          DU_LOG("\nF1AP : fillCellGrpCfg failed");
5520          break;
5521       }
5522
5523       cellGrpCfg.rlc_BearerToReleaseList = NULLP;
5524       cellGrpCfg.mac_CellGroupConfig = NULLP;
5525       CU_ALLOC(cellGrpCfg.mac_CellGroupConfig, sizeof(MAC_CellGroupConfig_t));
5526       if(!cellGrpCfg.mac_CellGroupConfig)
5527       {
5528          DU_LOG("\nF1AP : Memory allocation failure in fillCellGrpCfg");
5529          break;
5530       }
5531       if(BuildMacCellGrpCfg(cellGrpCfg.mac_CellGroupConfig) != ROK)
5532       {
5533          DU_LOG("\nF1AP : BuildMacCellGrpCfg failed");
5534          break;
5535       }
5536
5537
5538       cellGrpCfg.physicalCellGroupConfig = NULLP;
5539       CU_ALLOC(cellGrpCfg.physicalCellGroupConfig, sizeof(PhysicalCellGroupConfig_t));
5540       if(!cellGrpCfg.physicalCellGroupConfig)
5541       {
5542          DU_LOG("\nF1AP : Memory allocation failure in BuildDuToCuRrcContainer");
5543          break;
5544       }
5545       if(BuildPhyCellGrpCfg(cellGrpCfg.physicalCellGroupConfig) != ROK)
5546       {
5547          DU_LOG("\nF1AP : BuildPhyCellGrpCfg failed");
5548          break;
5549       }
5550
5551       cellGrpCfg.spCellConfig = NULLP;
5552       CU_ALLOC(cellGrpCfg.spCellConfig, sizeof(SpCellConfig_t));
5553       if(!cellGrpCfg.spCellConfig)
5554       {
5555          DU_LOG("\nF1AP : Memory allocation failure in BuildDuToCuRrcContainer");
5556          break;
5557       }
5558       if(BuildSpCellCfg(cellGrpCfg.spCellConfig) != ROK)
5559       {
5560          DU_LOG("\nF1AP : BuildSpCellCfg failed");
5561          break;
5562       }
5563
5564       cellGrpCfg.sCellToAddModList = NULLP;
5565       cellGrpCfg.sCellToReleaseList = NULLP;
5566       cellGrpCfg.ext1 = NULLP;
5567
5568       /* encode cellGrpCfg into duToCuRrcContainer */
5569       xer_fprint(stdout, &asn_DEF_CellGroupConfigRrc, &cellGrpCfg);
5570       cmMemset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
5571       encBufSize = 0;
5572       encRetVal = aper_encode(&asn_DEF_CellGroupConfigRrc, 0, &cellGrpCfg, PrepFinalEncBuf, encBuf);
5573       /* Encode results */
5574       if(encRetVal.encoded == ENCODE_FAIL)
5575       {
5576          DU_LOG( "\n F1AP : Could not encode DuToCuRrcContainer (at %s)\n",\
5577                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
5578          break;
5579       }
5580       else
5581       {
5582          DU_LOG("\n F1AP : Created APER encoded buffer for DuToCuRrcContainer\n");
5583          for(int i=0; i< encBufSize; i++)
5584          {
5585             printf("%x",encBuf[i]);
5586          }
5587       }
5588
5589       cellGrp->size = encBufSize;
5590       CU_ALLOC(cellGrp->buf, cellGrp->size);
5591       if(!cellGrp->buf)
5592       {
5593          DU_LOG("\nF1AP : Memory allocation failed in BuildDuToCuRrcContainer");
5594          break;
5595       }
5596       memcpy(cellGrp->buf, encBuf, cellGrp->size);
5597       ret = ROK;
5598       break;
5599    }
5600    FreeMemCellGrpCfg(&cellGrpCfg);
5601    return ROK;
5602 }
5603
5604 /*******************************************************************
5605  *
5606  * @brief Fills CuToDuContainer
5607  *
5608  * @details
5609  *
5610  *    Function : fillCuToDuContainer
5611  *
5612  *    Functionality: Fills CuToDuContainer
5613  *
5614  * @params[in] pointer to CUtoDURRCInformation_t
5615  *
5616  * @return ROK     - success
5617  *         RFAILED - failure
5618  *
5619  ******************************************************************/
5620
5621 uint8_t fillCuToDuContainer(CUtoDURRCInformation_t *rrcMsg)
5622 {
5623    uint8_t elementCnt = 0;
5624    uint8_t ret = ROK;
5625    uint8_t idx, idx2, rrcBufLen;
5626
5627    elementCnt = 1;
5628    CU_ALLOC(rrcMsg->iE_Extensions, sizeof(ProtocolExtensionContainer_4624P16_t));
5629    if(rrcMsg->iE_Extensions)
5630    {
5631       rrcMsg->iE_Extensions->list.count = elementCnt;
5632       rrcMsg->iE_Extensions->list.size = elementCnt * sizeof(CUtoDURRCInformation_ExtIEs_t);
5633
5634       /* Initialize the CUtoDURRCInformation_ExtIEs */
5635       CU_ALLOC(rrcMsg->iE_Extensions->list.array, rrcMsg->iE_Extensions->list.size);
5636
5637       if(rrcMsg->iE_Extensions->list.array == NULLP)
5638       {
5639          DU_LOG(" F1AP : Memory allocation for CUtoDURRCInformation_ExtIEs failed");
5640          ret = RFAILED;
5641       }
5642
5643       for(idx=0; idx<elementCnt; idx++)
5644       {
5645          CU_ALLOC(rrcMsg->iE_Extensions->list.array[idx], sizeof(CUtoDURRCInformation_ExtIEs_t));
5646          if(rrcMsg->iE_Extensions->list.array[idx] == NULLP)
5647          {
5648             ret = RFAILED;
5649          }
5650       }
5651       idx = 0;
5652       /* Filling CellGroupConfig_t IE */
5653       rrcMsg->iE_Extensions->list.array[idx]->id = ProtocolIE_ID_id_CellGroupConfig;
5654       rrcMsg->iE_Extensions->list.array[idx]->criticality = Criticality_ignore;
5655       rrcMsg->iE_Extensions->list.array[idx]->extensionValue.present  =\
5656       CUtoDURRCInformation_ExtIEs__extensionValue_PR_CellGroupConfig;
5657       ret = fillCellGrpCfg(&rrcMsg->iE_Extensions->list.array[idx]->extensionValue.choice.CellGroupConfig);
5658    }
5659    return ret;
5660 }
5661
5662 /*******************************************************************
5663  *
5664  * @brief Free CuToDuContainer
5665  *
5666  * @details
5667  *
5668  *    Function : FreeCuToDuInfo
5669  *
5670  *    Functionality: Free CuToDuContainer
5671  *
5672  * @params[in] pointer to CUtoDURRCInformation_t
5673  *
5674  * @return ROK     - success
5675  *         RFAILED - failure
5676  *
5677  ******************************************************************/
5678
5679 void FreeCuToDuInfo(CUtoDURRCInformation_t *rrcMsg)
5680 {
5681    uint8_t idx, idx2;
5682
5683    if(rrcMsg->iE_Extensions)
5684    {
5685       if(rrcMsg->iE_Extensions->list.array)
5686       {
5687          for(idx= 0; idx < rrcMsg->iE_Extensions->list.count; idx++)
5688          {
5689             if(rrcMsg->iE_Extensions->list.array[idx])
5690             {
5691                switch(rrcMsg->iE_Extensions->list.array[idx]->id)
5692                {
5693                   case ProtocolIE_ID_id_CellGroupConfig:
5694                      if(rrcMsg->iE_Extensions->list.array[idx]->extensionValue.choice.CellGroupConfig.buf != NULLP)
5695                      {
5696                         CU_FREE(rrcMsg->iE_Extensions->list.array[idx]->extensionValue.choice.CellGroupConfig.buf,\
5697                         rrcMsg->iE_Extensions->list.array[idx]->extensionValue.choice.CellGroupConfig.size);
5698
5699                      }
5700                   break;
5701                   default:
5702                      DU_LOG("\nF1AP:Invalid Event type %ld at FreeCuToDuInfo()", \
5703                         rrcMsg->iE_Extensions->list.array[idx]->id);
5704                      break;
5705                }
5706             }
5707             break;
5708          }
5709          for(idx2 = 0; idx2 < idx; idx2++)
5710          {
5711             CU_FREE(rrcMsg->iE_Extensions->list.array[idx2], sizeof(CUtoDURRCInformation_ExtIEs_t));
5712          }
5713          CU_FREE(rrcMsg->iE_Extensions->list.array, rrcMsg->iE_Extensions->list.size);
5714
5715       }
5716
5717       CU_FREE(rrcMsg->iE_Extensions, sizeof(ProtocolExtensionContainer_4624P16_t));
5718    }
5719 }
5720 /*******************************************************************
5721  *
5722  * @brief Builds and sends the UE Setup Request
5723  *
5724  * @details
5725  *
5726  *    Function : BuildAndSendUeContextSetupReq
5727  *
5728  *    Functionality: Constructs the UE Setup Request and sends
5729  *                   it to the CU through SCTP.
5730  *
5731  * @params[in]
5732  *
5733  * @return ROK     - success
5734  *         RFAILED - failure
5735  *
5736  * ****************************************************************/
5737 uint8_t BuildAndSendUeContextSetupReq(uint8_t cuUeF1apId, uint8_t duUeF1apId, \
5738    uint16_t rrcContLen, uint8_t *rrcContainer)
5739 {
5740    uint8_t   Nrcgiret;
5741    uint8_t   SplCellListret;
5742    uint8_t   SrbSetupret;
5743    uint8_t   elementCnt;
5744    uint8_t   idx, bufLen;
5745    uint8_t   idx1;
5746    F1AP_PDU_t           *f1apMsg = NULLP;
5747    UEContextSetupRequest_t *ueSetReq = NULLP;
5748    asn_enc_rval_t encRetVal;        /* Encoder return value */
5749    memset(&encRetVal, 0, sizeof(asn_enc_rval_t));
5750    uint8_t ret= RFAILED;
5751    uint8_t ret1;
5752    while(true)
5753    {
5754       DU_LOG("\n F1AP : Building UE Context Setup Request\n");
5755
5756       CU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
5757       if(f1apMsg == NULLP)
5758       {
5759          DU_LOG(" F1AP : Memory allocation for F1AP-PDU failed");
5760          break;
5761       }
5762
5763       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
5764       CU_ALLOC(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
5765       if(f1apMsg->choice.initiatingMessage == NULLP)
5766       {
5767          DU_LOG(" F1AP : Memory allocation for  F1AP-PDU failed");
5768          break;
5769       }
5770
5771       f1apMsg->choice.initiatingMessage->procedureCode = \
5772          ProcedureCode_id_UEContextSetup;
5773       f1apMsg->choice.initiatingMessage->criticality = Criticality_reject;
5774       f1apMsg->choice.initiatingMessage->value.present = \
5775          InitiatingMessage__value_PR_UEContextSetupRequest;
5776       ueSetReq =
5777          &f1apMsg->choice.initiatingMessage->value.choice.UEContextSetupRequest;
5778
5779       elementCnt = 12;
5780       ueSetReq->protocolIEs.list.count = elementCnt;
5781       ueSetReq->protocolIEs.list.size = \
5782                                         elementCnt * sizeof(UEContextSetupRequestIEs_t *);
5783
5784       /* Initialize the UESetup members */
5785       CU_ALLOC(ueSetReq->protocolIEs.list.array,ueSetReq->protocolIEs.list.size);
5786
5787       if(ueSetReq->protocolIEs.list.array == NULLP)
5788       {
5789          DU_LOG(" F1AP : Memory allocation for UE Context SetupRequest failed");
5790          break;
5791       }
5792
5793       for(idx1=0; idx1<elementCnt; idx1++)
5794       {
5795          CU_ALLOC(ueSetReq->protocolIEs.list.array[idx1],sizeof(UEContextSetupRequestIEs_t));
5796          if(ueSetReq->protocolIEs.list.array[idx1] == NULLP)
5797          {
5798             break;
5799          }
5800       }
5801
5802       idx = 0;
5803
5804       /*GNB CU UE F1AP ID*/
5805       ueSetReq->protocolIEs.list.array[idx]->id = \
5806                                                   ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
5807       ueSetReq->protocolIEs.list.array[idx]->criticality        =       Criticality_reject;
5808       ueSetReq->protocolIEs.list.array[idx]->value.present = \
5809                                                              UEContextSetupRequestIEs__value_PR_GNB_CU_UE_F1AP_ID;
5810       ueSetReq->protocolIEs.list.array[idx]->value.choice.GNB_CU_UE_F1AP_ID = cuUeF1apId;
5811
5812       /*GNB DU UE F1AP ID*/
5813       idx++;
5814       ueSetReq->protocolIEs.list.array[idx]->id = \
5815                                                   ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
5816       ueSetReq->protocolIEs.list.array[idx]->criticality        =       Criticality_ignore;
5817       ueSetReq->protocolIEs.list.array[idx]->value.present = \
5818                                                              UEContextSetupRequestIEs__value_PR_GNB_DU_UE_F1AP_ID;
5819       ueSetReq->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID = duUeF1apId;
5820
5821       /*Special Cell ID*/
5822       idx++;
5823       ueSetReq->protocolIEs.list.array[idx]->id = \
5824                                                   ProtocolIE_ID_id_SpCell_ID;
5825       ueSetReq->protocolIEs.list.array[idx]->criticality        =       Criticality_reject;
5826       ueSetReq->protocolIEs.list.array[idx]->value.present = \
5827                                                              UEContextSetupRequestIEs__value_PR_NRCGI;
5828       Nrcgiret = BuildNrcgi(&ueSetReq->protocolIEs.list.array[idx]->value.choice.NRCGI);
5829       if(Nrcgiret != ROK)
5830       {
5831          break;
5832       }
5833
5834       /*Served Cell Index*/
5835       idx++;
5836       ueSetReq->protocolIEs.list.array[idx]->id = \
5837                                                   ProtocolIE_ID_id_ServCellIndex;
5838       ueSetReq->protocolIEs.list.array[idx]->criticality        =       Criticality_reject;
5839       ueSetReq->protocolIEs.list.array[idx]->value.present = \
5840                                                              UEContextSetupRequestIEs__value_PR_ServCellIndex;
5841       ueSetReq->protocolIEs.list.array[idx]->value.choice.ServCellIndex = \
5842                                                                           CELL_INDEX;
5843
5844       /*CellULConfigured*/
5845       idx++;
5846       ueSetReq->protocolIEs.list.array[idx]->id = \
5847                                                   ProtocolIE_ID_id_SpCellULConfigured;
5848       ueSetReq->protocolIEs.list.array[idx]->criticality        =       Criticality_ignore;
5849       ueSetReq->protocolIEs.list.array[idx]->value.present = \
5850                                                              UEContextSetupRequestIEs__value_PR_CellULConfigured;
5851       ueSetReq->protocolIEs.list.array[idx]->value.choice.CellULConfigured = \
5852                                                                              CellULConfigured_none;
5853
5854       /*CUtoDURRCContainer*/
5855       idx++;
5856       ueSetReq->protocolIEs.list.array[idx]->id = \
5857                                                   ProtocolIE_ID_id_CUtoDURRCInformation;
5858       ueSetReq->protocolIEs.list.array[idx]->criticality        =       Criticality_reject;
5859       ueSetReq->protocolIEs.list.array[idx]->value.present = \
5860                                                              UEContextSetupRequestIEs__value_PR_CUtoDURRCInformation;
5861       if(fillCuToDuContainer(&ueSetReq->protocolIEs.list.array[idx]->value.choice.CUtoDURRCInformation))
5862       {
5863          break;
5864       }
5865
5866       /*Special Cells to be SetupList*/
5867       idx++;
5868       ueSetReq->protocolIEs.list.array[idx]->id = \
5869                                                   ProtocolIE_ID_id_SCell_ToBeSetup_List;
5870       ueSetReq->protocolIEs.list.array[idx]->criticality        =       Criticality_ignore;
5871       ueSetReq->protocolIEs.list.array[idx]->value.present = \
5872                                                              UEContextSetupRequestIEs__value_PR_SCell_ToBeSetup_List;
5873       SplCellListret = BuildSplCellList(&ueSetReq->protocolIEs.list.array[idx]->value.choice.SCell_ToBeSetup_List);
5874       if(SplCellListret != ROK)
5875       {
5876          break;
5877       }
5878       /*SRBs To Be Setup List*/
5879       idx++;
5880       ueSetReq->protocolIEs.list.array[idx]->id = \
5881                                                   ProtocolIE_ID_id_SRBs_ToBeSetup_List;
5882       ueSetReq->protocolIEs.list.array[idx]->criticality        =       Criticality_reject;
5883       ueSetReq->protocolIEs.list.array[idx]->value.present = \
5884                                                              UEContextSetupRequestIEs__value_PR_SRBs_ToBeSetup_List;
5885       SrbSetupret =     BuildSRBSetup(&ueSetReq->protocolIEs.list.array[idx]->value.choice.SRBs_ToBeSetup_List);
5886       if(SrbSetupret != ROK)
5887       {
5888          break;
5889       }
5890       /*DRBs to Be Setup List*/
5891       idx++;
5892       ueSetReq->protocolIEs.list.array[idx]->id = \
5893                                                   ProtocolIE_ID_id_DRBs_ToBeSetup_List;
5894       ueSetReq->protocolIEs.list.array[idx]->criticality        =       Criticality_reject;
5895       ueSetReq->protocolIEs.list.array[idx]->value.present = \
5896                                                              UEContextSetupRequestIEs__value_PR_DRBs_ToBeSetup_List;
5897       ret1 = BuildDRBSetup(&ueSetReq->protocolIEs.list.array[idx]->value.choice.DRBs_ToBeSetup_List);
5898       if(ret1 != ROK)
5899       {
5900          break;
5901       }
5902       /* RRC Container for security mode */
5903       idx++;
5904       ueSetReq->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_RRCContainer;
5905       ueSetReq->protocolIEs.list.array[idx]->criticality = Criticality_reject;
5906       ueSetReq->protocolIEs.list.array[idx]->value.present = \
5907          UEContextSetupRequestIEs__value_PR_RRCContainer;
5908       char secModeBuf[9]={0x00, 0x02, 0x22, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00};
5909       bufLen =9;
5910       ueSetReq->protocolIEs.list.array[idx]->value.choice.RRCContainer.size = bufLen;
5911       CU_ALLOC(ueSetReq->protocolIEs.list.array[idx]->value.choice.RRCContainer.buf,
5912           ueSetReq->protocolIEs.list.array[idx]->value.choice.RRCContainer.size);
5913       if(!ueSetReq->protocolIEs.list.array[idx]->value.choice.RRCContainer.buf)
5914       {
5915          DU_LOG(" F1AP : Memory allocation for BuildAndSendUeContextSetupReq failed");
5916          break;
5917       }
5918       memset(ueSetReq->protocolIEs.list.array[idx]->value.choice.RRCContainer.buf, 0, bufLen);
5919       memcpy(ueSetReq->protocolIEs.list.array[idx]->value.choice.RRCContainer.buf, secModeBuf, bufLen);
5920
5921       /* RRC delivery status request */
5922       idx++;
5923       ueSetReq->protocolIEs.list.array[idx]->id = \
5924          ProtocolIE_ID_id_RRCDeliveryStatusRequest;
5925       ueSetReq->protocolIEs.list.array[idx]->criticality = Criticality_ignore;
5926       ueSetReq->protocolIEs.list.array[idx]->value.present = \
5927          UEContextSetupRequestIEs__value_PR_RRCDeliveryStatusRequest;
5928       ueSetReq->protocolIEs.list.array[idx]->value.choice.RRCDeliveryStatusRequest = \
5929          RRCDeliveryStatusRequest_true;
5930
5931       /* Bit Rate hardcoded as in reference logs */
5932       idx++;
5933       ueSetReq->protocolIEs.list.array[idx]->id = \
5934          ProtocolIE_ID_id_GNB_DU_UE_AMBR_UL;
5935       ueSetReq->protocolIEs.list.array[idx]->criticality = Criticality_ignore;
5936       ueSetReq->protocolIEs.list.array[idx]->value.present = \
5937          UEContextSetupRequestIEs__value_PR_BitRate;
5938       char bitRateBuf[4]= {0x3B, 0x37, 0xF4, 0xCD};
5939       bufLen = 4;
5940       ueSetReq->protocolIEs.list.array[idx]->value.choice.BitRate.size = bufLen;
5941       CU_ALLOC(ueSetReq->protocolIEs.list.array[idx]->value.choice.BitRate.buf,\
5942          ueSetReq->protocolIEs.list.array[idx]->value.choice.BitRate.size);
5943       if(!ueSetReq->protocolIEs.list.array[idx]->value.choice.BitRate.buf)
5944       {
5945          DU_LOG(" F1AP : Failed to allocate memory for Bit Rate in BuildAndSendUeContextSetupReq()");
5946          break;
5947       }
5948       memset(ueSetReq->protocolIEs.list.array[idx]->value.choice.BitRate.buf, 0, bufLen);
5949       memcpy(ueSetReq->protocolIEs.list.array[idx]->value.choice.BitRate.buf, bitRateBuf, bufLen);
5950
5951       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
5952
5953       /* Encode the F1SetupRequest type as APER */
5954       memset(encBuf, 0, ENC_BUF_MAX_LEN);
5955       encBufSize = 0;
5956       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
5957             encBuf);
5958       /* Encode results */
5959       if(encRetVal.encoded == ENCODE_FAIL)
5960       {
5961          DU_LOG( "\n F1AP : Could not encode UE Context Setup Request structure (at %s)\n",\
5962                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
5963          break;
5964       }
5965       else
5966       {
5967          DU_LOG("\n F1AP : Created APER encoded buffer for UE Context Setup Request\n");
5968          for(int i=0; i< encBufSize; i++)
5969          {
5970             printf("%x",encBuf[i]);
5971          }
5972       }
5973
5974       /* Sending  msg  */
5975       if(SendF1APMsg(CU_APP_MEM_REG,CU_POOL)    !=      ROK)
5976       {
5977          DU_LOG("\n F1AP : Sending UE Context Setup Request Failed");
5978          break;
5979       }
5980       ret = ROK;
5981       break;
5982    }
5983    FreeUeContextSetupReq(f1apMsg);
5984
5985    return ret;
5986 }/* End of BuildAndSendUeContextSetupReq*/
5987
5988 /****************************************************************
5989  * @brief Function to process Ul Rrc Msg received from DU
5990  *
5991  * @details
5992  *
5993  *    Function : procUlRrcMsg
5994  *
5995  *    Functionality:
5996  *         - Function to process Ul Rrc Msg received from DU
5997  *
5998  * @params[in]
5999  * @return ROK     - success
6000  *         RFAILED - failure
6001  *
6002  * ****************************************************************/
6003
6004 uint8_t procUlRrcMsg(F1AP_PDU_t *f1apMsg)
6005 {
6006    uint8_t idx, ret, srbId, rrcMsgType;
6007    uint8_t cuUeF1apId, duUeF1apId;
6008    uint8_t *rrcContainer = NULLP;
6009    uint16_t rrcContLen;
6010    ULRRCMessageTransfer_t *ulRrcMsg = NULLP;
6011
6012    ret = ROK;
6013    ulRrcMsg = &f1apMsg->choice.initiatingMessage->value.choice.ULRRCMessageTransfer;
6014
6015    for(idx=0; idx < ulRrcMsg->protocolIEs.list.count; idx++)
6016    {
6017       switch(ulRrcMsg->protocolIEs.list.array[idx]->id)
6018       {
6019          case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
6020             {
6021                cuUeF1apId = ulRrcMsg->protocolIEs.list.array[idx]->value.choice.GNB_CU_UE_F1AP_ID;
6022                break;
6023             }
6024          case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
6025             {
6026                duUeF1apId = ulRrcMsg->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID;
6027                break;
6028             }
6029          case ProtocolIE_ID_id_SRBID:
6030             srbId = ulRrcMsg->protocolIEs.list.array[idx]->value.choice.SRBID;
6031             break;
6032          case ProtocolIE_ID_id_RRCContainer:
6033             {
6034                rrcContLen = ulRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.size;
6035                CU_ALLOC(rrcContainer, rrcContLen)
6036                if(!rrcContainer)
6037                {
6038                   DU_LOG("\nCU_STUB: Failed to allocated memory in procUlRrcMsg");
6039                   return RFAILED;
6040                }
6041                memcpy(rrcContainer, ulRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.buf,\
6042                      rrcContLen);
6043                break;
6044             }
6045
6046          default:
6047             DU_LOG("\n Invalid Event %ld", ulRrcMsg->protocolIEs.list.array[idx]->id);
6048             break;
6049       }
6050    }
6051    if(srbId == 1)
6052    {
6053       f1apMsgDb.dlRrcMsgCount++;
6054       rrcMsgType = setDlRRCMsgType();
6055       if(rrcMsgType == REGISTRATION_ACCEPT)
6056       {
6057          DU_LOG("\nF1AP: Sending DL RRC MSG for RRC Registration Accept");
6058          ret = BuildAndSendDLRRCMessageTransfer(srbId, rrcMsgType);
6059       }
6060       if(rrcMsgType == UE_CONTEXT_SETUP_REQ)
6061       {
6062          DU_LOG("\nF1AP: Sending Ue Context Setup Req");
6063          ret = BuildAndSendUeContextSetupReq(cuUeF1apId, duUeF1apId,\
6064             rrcContLen, rrcContainer);
6065       }
6066       if(rrcMsgType == SECURITY_MODE_COMPLETE)
6067       {
6068          /* To trigger the DL RRC Msg for RRC Reconfig */
6069          f1apMsgDb.dlRrcMsgCount++;
6070          rrcMsgType = setDlRRCMsgType();
6071          if(rrcMsgType == RRC_RECONFIG)
6072          {
6073             DU_LOG("\nF1AP: Sending DL RRC MSG for RRC Reconfig");
6074             BuildAndSendDLRRCMessageTransfer(srbId, rrcMsgType);
6075          }
6076       }
6077    }
6078    return ret;
6079 }
6080
6081 /****************************************************************
6082  * @brief Build And Send F1ResetAck
6083  *
6084  * @details
6085  *
6086  *    Function : FreeF1ResetAck
6087  *
6088  *    Functionality:
6089  *         - Build And Send  F1ResetRSP
6090  *
6091  *  @params[in]
6092  * @return ROK     - success
6093  *         RFAILED - failure
6094  *
6095  * ****************************************************************/
6096 void FreeF1ResetAck(F1AP_PDU_t *f1apMsg)
6097 {
6098     uint8_t idx;
6099     ResetAcknowledge_t *f1ResetAck;
6100
6101     if(f1apMsg)
6102     {
6103        if(f1apMsg->choice.successfulOutcome)
6104        {
6105           f1ResetAck= &f1apMsg->choice.successfulOutcome->value.choice.ResetAcknowledge;
6106
6107           if(f1ResetAck->protocolIEs.list.array)
6108           {
6109              for(idx=0; idx<f1ResetAck->protocolIEs.list.count ; idx++)
6110              {
6111                 if(f1ResetAck->protocolIEs.list.array[idx])
6112                 {
6113                    CU_FREE(f1ResetAck->protocolIEs.list.array[idx], sizeof(ResetAcknowledgeIEs_t));
6114                 }
6115              }
6116              CU_FREE(f1ResetAck->protocolIEs.list.array, f1ResetAck->protocolIEs.list.size );
6117           }
6118           CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
6119        }
6120        CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
6121     }
6122 }
6123
6124 /****************************************************************
6125 * @brief Build And Send F1ResetAck
6126 *
6127 * @details
6128 *
6129 *    Function : BuildAndSendF1ResetAck
6130 *
6131 *    Functionality:
6132 *         - Build And Send  F1ResetRSP
6133 *
6134 *  @params[in]
6135 * @return ROK     - success
6136 *         RFAILED - failure
6137 *
6138 * ****************************************************************/
6139
6140 uint8_t BuildAndSendF1ResetAck()
6141 {
6142    uint8_t                idx = 0;
6143    uint8_t                elementCnt = 0;
6144    uint8_t                ret = RFAILED;
6145    F1AP_PDU_t             *f1apMsg = NULL;
6146    ResetAcknowledge_t     *f1ResetAck = NULLP;
6147    asn_enc_rval_t         encRetVal;
6148    DU_LOG("\nF1AP : Building F1 Reset Acknowledgment \n");
6149
6150    do{
6151         /* Allocate the memory for F1ResetRequest_t */
6152         CU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
6153         if(f1apMsg == NULLP)
6154         {
6155            DU_LOG("\nF1AP : Memory allocation for F1AP-PDU failed");
6156            break;
6157         }
6158
6159         f1apMsg->present =  F1AP_PDU_PR_successfulOutcome;
6160
6161         CU_ALLOC(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
6162         if(f1apMsg->choice.successfulOutcome == NULLP)
6163         {
6164            DU_LOG("\nF1AP : Memory allocation for F1AP-PDU failed");
6165            break;
6166         }
6167
6168         f1apMsg->choice.successfulOutcome->procedureCode = ProcedureCode_id_Reset;
6169         f1apMsg->choice.successfulOutcome->criticality   = Criticality_reject;
6170         f1apMsg->choice.successfulOutcome->value.present = SuccessfulOutcome__value_PR_ResetAcknowledge;
6171         f1ResetAck = &f1apMsg->choice.successfulOutcome->value.choice.ResetAcknowledge;
6172
6173         elementCnt = 1;
6174
6175         f1ResetAck->protocolIEs.list.count = elementCnt;
6176         f1ResetAck->protocolIEs.list.size = elementCnt*sizeof(ResetAcknowledgeIEs_t *);
6177
6178         CU_ALLOC(f1ResetAck->protocolIEs.list.array, f1ResetAck->protocolIEs.list.size );
6179         if(f1ResetAck->protocolIEs.list.array == NULLP)
6180         {
6181            DU_LOG("\nF1AP : Memory allocation for F1ResetAckIEs failed");
6182            break;
6183         }
6184
6185         for(idx=0; idx<elementCnt; idx++)
6186         {
6187            CU_ALLOC(f1ResetAck->protocolIEs.list.array[idx], sizeof(ResetAcknowledgeIEs_t));
6188            if(f1ResetAck->protocolIEs.list.array[idx] == NULLP)
6189            {
6190               break;
6191            }
6192         }
6193         /*TransactionID*/
6194         idx = 0;
6195         f1ResetAck->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_TransactionID;
6196         f1ResetAck->protocolIEs.list.array[idx]->criticality = Criticality_reject;
6197         f1ResetAck->protocolIEs.list.array[idx]->value.present = ResetAcknowledgeIEs__value_PR_TransactionID;
6198         f1ResetAck->protocolIEs.list.array[idx]->value.choice.TransactionID = TRANS_ID;
6199
6200         xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
6201
6202         /* Encode the F1SetupRequest type as UPER */
6203         memset(encBuf, 0, ENC_BUF_MAX_LEN);
6204         encBufSize = 0;
6205         encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
6206
6207         /* Check encode results */
6208         if(encRetVal.encoded == ENCODE_FAIL)
6209         {
6210            DU_LOG("\nF1AP : Could not encode F1ResetAck structure (at %s)\n",\
6211                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
6212            break;
6213         }
6214         else
6215         {
6216            DU_LOG("\nF1AP : Created APER encoded buffer for F1ResetAck \n");
6217            for(int i=0; i< encBufSize; i++)
6218            {
6219               printf("%x",encBuf[i]);
6220            }
6221         }
6222         /* Sending msg */
6223         if(SendF1APMsg(CU_APP_MEM_REG, CU_POOL) != ROK)
6224         {
6225            DU_LOG("\nF1AP : Sending F1 Reset Response failed");
6226            break;
6227         }
6228
6229         ret = ROK;
6230         break;
6231    }while(true);
6232
6233    FreeF1ResetAck(f1apMsg);
6234    return ret;
6235 }
6236
6237 /*******************************************************************
6238  *
6239  * @brief Handles received F1AP message and sends back response
6240  *
6241  * @details
6242  *
6243  *    Function : F1APMsgHdlr
6244  *
6245  *    Functionality:
6246  *         - Decodes received F1AP control message
6247  *         - Prepares response message, encodes and sends to SCTP
6248  *
6249  * @params[in]
6250  * @return ROK     - success
6251  *         RFAILED - failure
6252  *
6253  * ****************************************************************/
6254 void F1APMsgHdlr(Buffer *mBuf)
6255 {
6256    int i;
6257    char *recvBuf;
6258    MsgLen copyCnt;
6259    MsgLen recvBufLen;
6260    F1AP_PDU_t *f1apMsg = NULLP;
6261    asn_dec_rval_t rval; /* Decoder return value */
6262    F1AP_PDU_t f1apasnmsg ;
6263
6264    DU_LOG("\nF1AP : Received F1AP message buffer");
6265    ODU_PRINT_MSG(mBuf, 0,0);
6266
6267    /* Copy mBuf into char array to decode it */
6268    ODU_GET_MSG_LEN(mBuf, &recvBufLen);
6269    CU_ALLOC(recvBuf, (Size)recvBufLen);
6270
6271    if(recvBuf == NULLP)
6272    {
6273       DU_LOG("\nF1AP : Memory allocation failed");
6274       return;
6275    }
6276    if(ODU_COPY_MSG_TO_FIX_BUF(mBuf, 0, recvBufLen, (Data *)recvBuf, &copyCnt) != ROK)
6277    {
6278       DU_LOG("\nF1AP : Failed while copying %d", copyCnt);
6279       return;
6280    }
6281
6282    printf("\nF1AP : Received flat buffer to be decoded : ");
6283    for(i=0; i< recvBufLen; i++)
6284    {
6285       printf("%x",recvBuf[i]);
6286    }
6287
6288    /* Decoding flat buffer into F1AP messsage */
6289    f1apMsg = &f1apasnmsg;
6290    memset(f1apMsg, 0, sizeof(F1AP_PDU_t));
6291
6292    rval = aper_decode(0, &asn_DEF_F1AP_PDU, (void **)&f1apMsg, recvBuf, recvBufLen, 0, 0);
6293    CU_FREE(recvBuf, (Size)recvBufLen);
6294
6295    if(rval.code == RC_FAIL || rval.code == RC_WMORE)
6296    {
6297       DU_LOG("\nF1AP : ASN decode failed");
6298       return;
6299    }
6300    printf("\n");
6301    xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
6302
6303    switch(f1apMsg->present)
6304    {
6305       case F1AP_PDU_PR_initiatingMessage:
6306       {
6307          switch(f1apMsg->choice.initiatingMessage->value.present)
6308          {
6309             case InitiatingMessage__value_PR_Reset:
6310             {
6311                 DU_LOG("\nF1AP : F1 reset request received ");
6312                 BuildAndSendF1ResetAck();
6313                 break;
6314             }
6315
6316             case InitiatingMessage__value_PR_F1SetupRequest:
6317             {
6318                DU_LOG("\nF1AP : F1 setup request received");
6319                BuildAndSendF1SetupRsp();
6320                break;
6321             }
6322
6323             case InitiatingMessage__value_PR_GNBDUConfigurationUpdate:
6324             {
6325                DU_LOG("\nF1AP : GNB-DU config update received");
6326                BuildAndSendDUUpdateAck();
6327                DU_LOG("\nF1AP : Sending F1 reset request");
6328                BuildAndSendF1ResetReq();
6329                break;
6330             }
6331             case InitiatingMessage__value_PR_InitialULRRCMessageTransfer:
6332             {
6333                DU_LOG("\nF1AP : Received InitialULRRCMessageTransfer");
6334                procInitULRRCMsg(f1apMsg);
6335                break;
6336             }
6337             case InitiatingMessage__value_PR_ULRRCMessageTransfer:
6338             {
6339                DU_LOG("\nF1AP : Received ULRRCMessageTransfer");
6340                procUlRrcMsg(f1apMsg);
6341                break;
6342             }
6343
6344             case InitiatingMessage__value_PR_RRCDeliveryReport:
6345             {
6346                DU_LOG("\nF1AP : Received RRC delivery report");
6347                 break;
6348             }
6349             default:
6350             {
6351                DU_LOG("\nF1AP : Invalid type of intiating message [%d]",f1apMsg->choice.initiatingMessage->value.present);
6352                return;
6353             }
6354          }/* End of switch(initiatingMessage) */
6355          break;
6356       }
6357
6358       case F1AP_PDU_PR_successfulOutcome:
6359       {
6360          switch(f1apMsg->choice.successfulOutcome->value.present)
6361          {
6362             case SuccessfulOutcome__value_PR_ResetAcknowledge:
6363             {
6364                DU_LOG("\nF1Reset Acknowledgement is received successfully ");
6365                break;
6366             }
6367             case SuccessfulOutcome__value_PR_UEContextSetupResponse:
6368             {
6369                DU_LOG("\nF1AP : UE ContextSetupResponse received");
6370                f1apMsgDb.dlRrcMsgCount++; /* keeping DL RRC Msg Count */
6371                break;
6372             }
6373             default:
6374             {
6375                DU_LOG("\nF1AP : Invalid type of successful outcome message [%d]",\
6376                   f1apMsg->choice.successfulOutcome->value.present);
6377                return;
6378             }
6379          }/* End of switch(successfulOutcome) */
6380          break;
6381       }
6382       default:
6383          {
6384             DU_LOG("\nF1AP : Invalid type of f1apMsg->present [%d]",f1apMsg->present);
6385             return;
6386          }
6387    }/* End of switch(f1apMsg->present) */
6388
6389 } /* End of F1APMsgHdlr */
6390
6391 /**********************************************************************
6392   End of file
6393  **********************************************************************/