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