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 "ProtocolIE-Field.h"
  25 #include "ProtocolExtensionField.h"
  26 #include "ProtocolIE-SingleContainer.h"
  27 #include "F1AP-PDU.h"
  28 #include "ModulationOrder.h"
  29 #include "BandNR.h"
  30 #include "UE-CapabilityRAT-Container.h"
  31 #include "UE-CapabilityRAT-ContainerList.h"
  32 #include "UE-CapabilityRAT-ContainerListRRC.h"
  33 #include "HandoverPreparationInformationRrc-IEs.h"
  34 #include "HandoverPreparationInformationRrc.h"
  35 #include "SupportedBandwidth.h"
  36 #include "FeatureSetUplinkPerCC.h"
  37 #include "FeatureSetDownlinkPerCC.h"
  38 #include "FeatureSets.h"
  39 #include "RF-Parameters.h"
  40 #include "UE-NR-Capability.h"
  41 #include "ProtocolExtensionContainer.h"
  42 #include "CellGroupConfigRrc.h"
  43 #include "MAC-CellGroupConfig.h"
  44 #include "SchedulingRequestConfig.h"
  45 #include "SchedulingRequestToAddMod.h"
  46 #include "BSR-Config.h"
  47 #include "TAG-Config.h"
  48 #include "TAG.h"
  49 #include "PHR-Config.h"
  50 #include "RLC-Config.h"
  51 #include "UL-AM-RLC.h"
  52 #include "DL-AM-RLC.h"
  53 #include "LogicalChannelConfig.h"
  54 #include "RLC-BearerConfig.h"
  55 #include "PhysicalCellGroupConfig.h"
  56 #include "SpCellConfig.h"
  57 #include "ServingCellConfig.h"
  58 #include "ControlResourceSet.h"
  59 #include "SearchSpace.h"
  60 #include "PDCCH-Config.h"
  61 #include "PDSCH-TimeDomainResourceAllocation.h"
  62 #include "PDSCH-TimeDomainResourceAllocationList.h"
  63 #include "DMRS-DownlinkConfig.h"
  64 #include "PDSCH-Config.h"
  65 #include "BWP-DownlinkDedicated.h"
  66 #include "PUSCH-TimeDomainResourceAllocation.h"
  67 #include "PUSCH-TimeDomainResourceAllocationList.h"
  68 #include "DMRS-UplinkConfig.h"
  69 #include "PUSCH-Config.h"
  70 #include "SRS-ResourceId.h"
  71 #include "SRS-Resource.h"
  72 #include "SRS-ResourceSet.h"
  73 #include "SRS-Config.h"
  74 #include "PUCCH-Config.h"
  75 #include "PUCCH-ResourceSet.h"
  76 #include "PUCCH-Resource.h"
  77 #include "PUCCH-format1.h"
  78 #include "PUCCH-FormatConfig.h"
  79 #include "BWP-UplinkDedicated.h"
  80 #include "PUSCH-ServingCellConfig.h"
  81 #include "UplinkConfig.h"
  82 #include "PDSCH-ServingCellConfig.h"
  83 #include "EUTRANQoS.h"
  84 #include "GBR-QosInformation.h"
  85 #include "DRBs-ToBeSetupMod-List.h"
  86 #include "DRBs-ToBeSetupMod-Item.h"
  87 #include "DRBs-Setup-Item.h"
  88 #include "DLUPTNLInformation-ToBeSetup-List.h"
  89 #include "DLUPTNLInformation-ToBeSetup-Item.h"
  90 #include "UPTransportLayerInformation.h"
  91 #include "GTPTunnel.h"
  92 #include "QoSInformation.h"
  93 #include "Cells-to-be-Activated-List.h"
  94 #include "DL-CCCH-Message.h"
  95 #include "SRB-ToAddModList.h"
  96 #include "SRB-ToAddMod.h"
  97 #include "RRCSetup-IEs.h"
  98 #include "RRCSetup.h"
  99 #include "DL-DCCH-Message.h"
 100 #include "RRCReconfiguration-IEs.h"
 101 #include "RRCReconfiguration.h"
 102 #include "DRB-ToAddModList.h"
 103 #include "DRB-ToAddMod.h"
 104 #include "SDAP-Config.h"
 105 #include "SSB-MTC.h"
 106 #include "MeasTiming.h"
 107 #include "MeasTimingList.h"
 108 #include "MeasurementTimingConfigurationRrc-IEs.h"
 109 #include "MeasurementTimingConfigurationRrc.h"
 110 #include "PDCP-Config.h"
 111 #include "RSRP-Range.h"
 112 #include "RSRQ-Range.h"
 113 #include "SINR-Range.h"
 114 #include "ThresholdNR.h"
 115 #include "MeasObjectToAddMod.h"
 116 #include "MeasObjectNR.h"
 117 #include "MeasObjectToAddModList.h"
 118 #include "EventTriggerConfig.h"
 119 #include "ReportConfigNR.h"
 120 #include "ReportConfigToAddMod.h"
 121 #include "ReportConfigToAddModList.h"
 122 #include "MeasIdToAddMod.h"
 123 #include "MeasIdToAddModList.h"
 124 #include "FilterCoefficient.h"
 125 #include "QuantityConfigNR.h"
 126 #include "QuantityConfig.h"
 127 #include "MeasConfigRrc.h"
 128 #include "AS-Config.h"
 129 #include "RRCReconfiguration-v1530-IEs.h"
 130 #include "CNUEPagingIdentity.h"
 131 #include "PagingCell-Item.h"
 132 #include "UL-DCCH-Message.h"
 133
 134 #include "cu_stub_sctp.h"
 135 #include "cu_stub_egtp.h"
 136 #include "cu_f1ap_msg_hdl.h"
 137 #include "cu_stub.h"
 138
 139 uint8_t fillCellGrpCfg(CuUeCb *ueCb, OCTET_STRING_t *cellGrp, bool updateAllRbCfg);
 140 uint8_t fillRrcReconfig(CuUeCb *ueCb, RRCReconfiguration_t *rrcReconfig, bool updateAllRbCfg);
 141
 142 /*******************************************************************
 143  *
 144  * @brief Sends F1 msg over SCTP
 145  *
 146  * @details
 147  *
 148  *    Function : SendF1APMsg
 149  *
 150  *    Functionality: Sends F1 msg over SCTP
 151  *
 152  * @params[in] Region region
 153  *             Pool pool
 154  * @return ROK     - success
 155  *         RFAILED - failure
 156  *
 157  * ****************************************************************/
 158 S16 SendF1APMsg(Region region, Pool pool, uint32_t duId)
 159 {
 160    Buffer *mBuf = NULLP;
 161
 162    if(ODU_GET_MSG_BUF(region, pool, &mBuf) == ROK)
 163    {
 164       if(ODU_ADD_POST_MSG_MULT((Data *)encBuf, encBufSize, mBuf) == ROK)
 165       {
 166          ODU_PRINT_MSG(mBuf, 0,0);
 167
 168          if(sctpSend(duId, mBuf) != ROK)
 169          {
 170             DU_LOG("\nERROR  -->  F1AP : SCTP Send failed");
 171             ODU_PUT_MSG_BUF(mBuf);
 172             return RFAILED;
 173          }
 174       }
 175       else
 176       {
 177          DU_LOG("\nERROR  -->  F1AP : ODU_ADD_POST_MSG_MULT failed");
 178          ODU_PUT_MSG_BUF(mBuf);
 179          return RFAILED;
 180       }
 181       ODU_PUT_MSG_BUF(mBuf);
 182    }
 183    else
 184    {
 185       DU_LOG("\nERROR  -->  F1AP : Failed to allocate memory");
 186       return RFAILED;
 187    }
 188
 189    return ROK;
 190 } /* SendF1APMsg */
 191
 192 /********************************************************************
 193  *
 194  * @brief Builds and sends the F1SetupResponse
 195  *
 196  * @details
 197  *
 198  *    Function : BuildAndSendF1SetupRsp
 199  *
 200  *    Functionality: Constructs the F1SetupResponse message and sends
 201  *                   it back to the DU through SCTP.
 202  *
 203  * @params[in] void **buf,Buffer to which encoded pattern is written into
 204  * @params[in] int *size,size of buffer
 205  *
 206  * @return ROK     - success
 207  *         RFAILED - failure
 208  *
 209  * ****************************************************************/
 210 uint8_t BuildAndSendF1SetupRsp(uint32_t duId, BIT_STRING_t *nrcellId)
 211 {
 212    uint8_t    idx,ieIdx;
 213    uint8_t    elementCnt,cellCnt;
 214    F1AP_PDU_t         *f1apMsg = NULL;
 215    F1SetupResponse_t  *f1SetupRsp;
 216    GNB_CU_Name_t      *cuName;
 217    Cells_to_be_Activated_List_t *cellToActivate;
 218    RRC_Version_t      *rrcVer;
 219    asn_enc_rval_t     encRetVal;
 220    DU_LOG("\nINFO  -->  F1AP : Building F1 Setup Response\n");
 221
 222    /* Allocate the memory for F1SetupRequest_t */
 223    CU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
 224    if(f1apMsg == NULLP)
 225    {
 226       DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
 227       return RFAILED;
 228    }
 229    f1apMsg->present =  F1AP_PDU_PR_successfulOutcome;
 230
 231    CU_ALLOC(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 232    if(f1apMsg->choice.successfulOutcome == NULLP)
 233    {
 234       DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
 235       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 236       return RFAILED;
 237    }
 238
 239    f1apMsg->choice.successfulOutcome->procedureCode = ProcedureCode_id_F1Setup;
 240    f1apMsg->choice.successfulOutcome->criticality = Criticality_reject;
 241    f1apMsg->choice.successfulOutcome->value.present = \
 242                                                       SuccessfulOutcome__value_PR_F1SetupResponse;
 243    f1SetupRsp = &f1apMsg->choice.successfulOutcome->value.choice.F1SetupResponse;
 244
 245    elementCnt = 4;
 246    f1SetupRsp->protocolIEs.list.count = elementCnt;
 247    f1SetupRsp->protocolIEs.list.size = elementCnt*sizeof(F1SetupResponseIEs_t *);
 248
 249    CU_ALLOC(f1SetupRsp->protocolIEs.list.array, \
 250          elementCnt * sizeof(F1SetupResponseIEs_t *));
 251    if(f1SetupRsp->protocolIEs.list.array == NULLP)
 252    {
 253       DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1ResponseIEs failed");
 254       CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 255       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 256       return RFAILED;
 257    }
 258
 259    for(idx=0; idx<elementCnt; idx++)
 260    {
 261       CU_ALLOC(f1SetupRsp->protocolIEs.list.array[idx], \
 262             sizeof(F1SetupResponseIEs_t));
 263       if(f1SetupRsp->protocolIEs.list.array[idx] == NULLP)
 264       {
 265          CU_FREE(f1SetupRsp->protocolIEs.list.array,\
 266                elementCnt * sizeof(F1SetupResponseIEs_t *));
 267          CU_FREE(f1apMsg->choice.successfulOutcome, \
 268                sizeof(SuccessfulOutcome_t));
 269          CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 270          return RFAILED;
 271       }
 272    }
 273
 274    /*TransactionID*/
 275    idx = 0;
 276    f1SetupRsp->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_TransactionID;
 277    f1SetupRsp->protocolIEs.list.array[idx]->criticality = Criticality_reject;
 278    f1SetupRsp->protocolIEs.list.array[idx]->value.present = \
 279                                                             F1SetupResponseIEs__value_PR_TransactionID;
 280    f1SetupRsp->protocolIEs.list.array[idx]->value.choice.TransactionID =\
 281                                                                         TRANS_ID;
 282
 283    /*CU Name*/
 284    idx++;
 285    f1SetupRsp->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_gNB_CU_Name;
 286    f1SetupRsp->protocolIEs.list.array[idx]->criticality = Criticality_ignore;
 287    f1SetupRsp->protocolIEs.list.array[idx]->value.present = \
 288                                                             F1SetupResponseIEs__value_PR_GNB_CU_Name;
 289    cuName = &f1SetupRsp->protocolIEs.list.array[idx]->value.choice.GNB_CU_Name;
 290    cuName->size = sizeof(cuCb.cuCfgParams.cuName);
 291
 292    CU_ALLOC(cuName->buf, sizeof(cuName->size));
 293    if(cuName->buf == NULLP)
 294    {
 295       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
 296       {
 297          CU_FREE(f1SetupRsp->protocolIEs.list.array[ieIdx],\
 298                sizeof(F1SetupResponseIEs_t));
 299       }
 300       CU_FREE(f1SetupRsp->protocolIEs.list.array,\
 301             elementCnt * sizeof(F1SetupResponseIEs_t *));
 302       CU_FREE(f1apMsg->choice.successfulOutcome,\
 303             sizeof(SuccessfulOutcome_t));
 304       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 305       return RFAILED;
 306    }
 307    strcpy((char*)cuName->buf, (char*)cuCb.cuCfgParams.cuName);
 308
 309    /*Cells to be activated list*/
 310    idx++;
 311    f1SetupRsp->protocolIEs.list.array[idx]->id = \
 312                                                  ProtocolIE_ID_id_Cells_to_be_Activated_List ;
 313    f1SetupRsp->protocolIEs.list.array[idx]->criticality = Criticality_reject;
 314    f1SetupRsp->protocolIEs.list.array[idx]->value.present = \
 315                                                             F1SetupResponseIEs__value_PR_Cells_to_be_Activated_List;
 316    cellToActivate = &f1SetupRsp->protocolIEs.list.array[idx]->value.choice.\
 317                     Cells_to_be_Activated_List;
 318    cellCnt=1;
 319    cellToActivate->list.count = cellCnt;
 320    cellToActivate->list.size = \
 321                                cellCnt*sizeof(struct Cells_to_be_Activated_List_ItemIEs  *);
 322    CU_ALLOC(cellToActivate->list.array,\
 323          sizeof(struct Cells_to_be_Activated_List_ItemIEs  *));
 324    if(cellToActivate->list.array == NULLP)
 325    {
 326       CU_FREE(cuName->buf, sizeof(cuName->size));
 327       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
 328       {
 329          CU_FREE(f1SetupRsp->protocolIEs.list.array[ieIdx],\
 330                sizeof(F1SetupResponseIEs_t));
 331       }
 332       CU_FREE(f1SetupRsp->protocolIEs.list.array,\
 333             elementCnt * sizeof(F1SetupResponseIEs_t *));
 334       CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 335       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 336       return RFAILED;
 337    }
 338    for(ieIdx=0; ieIdx<cellCnt; ieIdx++)
 339    {
 340       CU_ALLOC(cellToActivate->list.array[ieIdx],sizeof(struct Cells_to_be_Activated_List_ItemIEs ));
 341       if(cellToActivate->list.array[ieIdx] == NULLP)
 342       {
 343          CU_FREE(cellToActivate->list.array,\
 344                sizeof(struct Cells_to_be_Activated_List_ItemIEs  *));
 345          CU_FREE(cuName->buf, sizeof(cuName->size));
 346          for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
 347          {
 348             CU_FREE(f1SetupRsp->protocolIEs.list.array[ieIdx], \
 349                   sizeof(F1SetupResponseIEs_t));
 350          }
 351          CU_FREE(f1SetupRsp->protocolIEs.list.array, \
 352                elementCnt * sizeof(F1SetupResponseIEs_t *));
 353          CU_FREE(f1apMsg->choice.successfulOutcome, \
 354                sizeof(SuccessfulOutcome_t));
 355          CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 356          return RFAILED;
 357       }
 358    }
 359    cellToActivate->list.array[0]->id = \
 360                                        ProtocolIE_ID_id_Cells_to_be_Activated_List_Item;
 361    cellToActivate->list.array[0]->criticality = Criticality_ignore;
 362    cellToActivate->list.array[0]->value.present = \
 363                                                   Cells_to_be_Activated_List_ItemIEs__value_PR_Cells_to_be_Activated_List_Item;
 364    cellToActivate->list.array[0]->value.choice.Cells_to_be_Activated_List_Item.\
 365       nRCGI.pLMN_Identity.size = 3*sizeof(uint8_t);
 366    CU_ALLOC(cellToActivate->list.array[0]->\
 367          value.choice.Cells_to_be_Activated_List_Item.nRCGI.pLMN_Identity.buf,\
 368          3*sizeof(uint8_t));
 369    if(cellToActivate->list.array[0]->value.choice.\
 370          Cells_to_be_Activated_List_Item.nRCGI.pLMN_Identity.buf == NULLP)
 371    {
 372
 373       for(ieIdx=0; ieIdx<cellCnt; ieIdx++)
 374       {
 375          CU_FREE(cellToActivate->list.array[ieIdx],\
 376                sizeof(struct Cells_to_be_Activated_List_ItemIEs ));
 377       }
 378
 379       CU_FREE(cellToActivate->list.array,\
 380             sizeof(struct Cells_to_be_Activated_List_ItemIEs  *));
 381       CU_FREE(cuName->buf, sizeof(cuName->size));
 382       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
 383       {
 384          CU_FREE(f1SetupRsp->protocolIEs.list.array[ieIdx], \
 385                sizeof(F1SetupResponseIEs_t));
 386       }
 387       CU_FREE(f1SetupRsp->protocolIEs.list.array, \
 388             elementCnt * sizeof(F1SetupResponseIEs_t *));
 389       CU_FREE(f1apMsg->choice.successfulOutcome, \
 390             sizeof(SuccessfulOutcome_t));
 391       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 392       return RFAILED;
 393    }
 394    buildPlmnId(cuCb.cuCfgParams.plmn , cellToActivate->list.array[0]->value.choice.\
 395          Cells_to_be_Activated_List_Item.nRCGI.pLMN_Identity.buf);
 396    cellToActivate->list.array[0]->value.choice.Cells_to_be_Activated_List_Item.\
 397       nRCGI.nRCellIdentity.size = 5;
 398    CU_ALLOC(cellToActivate->list.array[0]->value.choice.\
 399          Cells_to_be_Activated_List_Item.nRCGI.nRCellIdentity.buf,\
 400          5*sizeof(uint8_t));
 401    if(cellToActivate->list.array[0]->value.choice.\
 402          Cells_to_be_Activated_List_Item.nRCGI.nRCellIdentity.buf == NULLP)
 403    {
 404       CU_FREE(cellToActivate->list.array[0]->\
 405             value.choice.Cells_to_be_Activated_List_Item.nRCGI.pLMN_Identity.buf,\
 406             3*sizeof(uint8_t));
 407       for(ieIdx=0; ieIdx<cellCnt; ieIdx++)
 408       {
 409          CU_FREE(cellToActivate->list.array[ieIdx],\
 410                sizeof(struct Cells_to_be_Activated_List_ItemIEs ));
 411       }
 412
 413       CU_FREE(cellToActivate->list.array,\
 414             sizeof(struct Cells_to_be_Activated_List_ItemIEs  *));
 415       CU_FREE(cuName->buf, sizeof(cuName->size));
 416       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
 417       {
 418          CU_FREE(f1SetupRsp->protocolIEs.list.array[ieIdx], \
 419                sizeof(F1SetupResponseIEs_t));
 420       }
 421       CU_FREE(f1SetupRsp->protocolIEs.list.array, \
 422             elementCnt * sizeof(F1SetupResponseIEs_t *));
 423       CU_FREE(f1apMsg->choice.successfulOutcome, \
 424             sizeof(SuccessfulOutcome_t));
 425       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 426       return RFAILED;
 427    }
 428    memcpy(&cellToActivate->list.array[0]->value.choice.Cells_to_be_Activated_List_Item.nRCGI.nRCellIdentity, nrcellId, sizeof(BIT_STRING_t));
 429    /* RRC Version */
 430    idx++;
 431    f1SetupRsp->protocolIEs.list.array[idx]->id = \
 432                                                  ProtocolIE_ID_id_GNB_CU_RRC_Version;
 433    f1SetupRsp->protocolIEs.list.array[idx]->criticality = Criticality_reject;
 434    f1SetupRsp->protocolIEs.list.array[idx]->value.present = \
 435                                                             F1SetupResponseIEs__value_PR_RRC_Version;
 436    rrcVer = &f1SetupRsp->protocolIEs.list.array[idx]->value.choice.RRC_Version;
 437    rrcVer->latest_RRC_Version.size = RRC_SIZE;
 438
 439    CU_ALLOC(rrcVer->latest_RRC_Version.buf, sizeof(uint8_t));
 440    if(rrcVer->latest_RRC_Version.buf == NULLP)
 441    {
 442       CU_FREE(cuName->buf, sizeof(cuName->size));
 443       for(ieIdx=0; ieIdx<elementCnt; idx++)
 444       {
 445          CU_FREE(f1SetupRsp->protocolIEs.list.array[ieIdx], \
 446                sizeof(F1SetupResponseIEs_t));
 447       }
 448       CU_FREE(f1SetupRsp->protocolIEs.list.array,\
 449             elementCnt * sizeof(F1SetupResponseIEs_t *));
 450       CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 451       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 452       return RFAILED;
 453    }
 454
 455    /* Need to check RRC Version */
 456    rrcVer->latest_RRC_Version.buf[0] = cuCb.cuCfgParams.rrcVersion.rrcVer;
 457    rrcVer->latest_RRC_Version.bits_unused = 5; //TODO: pick from cuCfgParam. If not present, add it
 458    CU_ALLOC(rrcVer->iE_Extensions,sizeof(ProtocolExtensionContainer_4624P81_t));
 459    if(rrcVer->iE_Extensions == NULLP)
 460    {
 461       CU_FREE(rrcVer->latest_RRC_Version.buf, sizeof(uint8_t));
 462       CU_FREE(cuName->buf, sizeof(cuName->size));
 463       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
 464       {
 465          CU_FREE(f1SetupRsp->protocolIEs.list.array[ieIdx], \
 466                sizeof(F1SetupResponseIEs_t));
 467       }
 468       CU_FREE(f1SetupRsp->protocolIEs.list.array,\
 469             elementCnt * sizeof(F1SetupResponseIEs_t *));
 470       CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 471       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 472       return RFAILED;
 473    }
 474    rrcVer->iE_Extensions->list.count = 1;
 475    rrcVer->iE_Extensions->list.size = sizeof(struct RRC_Version_ExtIEs *);
 476    CU_ALLOC(rrcVer->iE_Extensions->list.array,\
 477          sizeof(struct RRC_Version_ExtIEs *));
 478    if(rrcVer->iE_Extensions->list.array == NULLP)
 479    {
 480       CU_FREE(rrcVer->iE_Extensions,\
 481             sizeof(ProtocolExtensionContainer_4624P81_t));
 482       CU_FREE(rrcVer->latest_RRC_Version.buf, sizeof(uint8_t));
 483       CU_FREE(cuName->buf, sizeof(cuName->size));
 484       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
 485       {
 486          CU_FREE(f1SetupRsp->protocolIEs.list.array[ieIdx], \
 487                sizeof(F1SetupResponseIEs_t));
 488       }
 489       CU_FREE(f1SetupRsp->protocolIEs.list.array,\
 490             elementCnt * sizeof(F1SetupResponseIEs_t *));
 491       CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 492       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 493       return RFAILED;
 494    }
 495    CU_ALLOC(rrcVer->iE_Extensions->list.array[0],\
 496          sizeof(struct RRC_Version_ExtIEs));
 497    if(rrcVer->iE_Extensions->list.array[0] == NULLP)
 498    {
 499       CU_FREE(rrcVer->iE_Extensions->list.array,\
 500             sizeof(struct RRC_Version_ExtIEs *));
 501       CU_FREE(rrcVer->iE_Extensions,\
 502             sizeof(ProtocolExtensionContainer_4624P81_t));
 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.array[0]->id = \
 517                                               ProtocolIE_ID_id_latest_RRC_Version_Enhanced;
 518    rrcVer->iE_Extensions->list.array[0]->criticality = Criticality_reject;
 519    rrcVer->iE_Extensions->list.array[0]->extensionValue.present = \
 520                                                                   RRC_Version_ExtIEs__extensionValue_PR_Latest_RRC_Version_Enhanced;
 521    rrcVer->iE_Extensions->list.array[0]->extensionValue.choice.\
 522       Latest_RRC_Version_Enhanced.size = 3*sizeof(uint8_t);
 523    CU_ALLOC(rrcVer->iE_Extensions->list.\
 524          array[0]->extensionValue.choice.Latest_RRC_Version_Enhanced.buf,\
 525          3*sizeof(uint8_t));
 526    if(rrcVer->iE_Extensions->list.\
 527          array[0]->extensionValue.choice.Latest_RRC_Version_Enhanced.buf == NULLP)
 528    {
 529       CU_FREE(rrcVer->iE_Extensions->list.array[0],\
 530             sizeof(struct RRC_Version_ExtIEs));
 531       CU_FREE(rrcVer->iE_Extensions->list.array,\
 532             sizeof(struct RRC_Version_ExtIEs *));
 533       CU_FREE(rrcVer->iE_Extensions,\
 534             sizeof(ProtocolExtensionContainer_4624P81_t));
 535       CU_FREE(rrcVer->latest_RRC_Version.buf, sizeof(uint8_t));
 536       CU_FREE(cuName->buf, sizeof(cuName->size));
 537       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
 538       {
 539          CU_FREE(f1SetupRsp->protocolIEs.list.array[ieIdx], \
 540                sizeof(F1SetupResponseIEs_t));
 541       }
 542       CU_FREE(f1SetupRsp->protocolIEs.list.array,\
 543             elementCnt * sizeof(F1SetupResponseIEs_t *));
 544       CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 545       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 546       return RFAILED;
 547    }
 548    rrcVer->iE_Extensions->list.array[0]->extensionValue.choice.\
 549       Latest_RRC_Version_Enhanced.buf[0] = 0;
 550    rrcVer->iE_Extensions->list.array[0]->extensionValue.choice.\
 551       Latest_RRC_Version_Enhanced.buf[1] = 5;
 552    rrcVer->iE_Extensions->list.array[0]->extensionValue.choice.\
 553       Latest_RRC_Version_Enhanced.buf[2] = 15;
 554
 555    xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
 556
 557    /* Encode the F1SetupRequest type as UPER */
 558    memset(encBuf, 0, ENC_BUF_MAX_LEN);
 559    encBufSize = 0;
 560    encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
 561
 562    /* Clean up */
 563    CU_FREE(rrcVer->latest_RRC_Version.buf, sizeof(uint8_t));
 564    CU_FREE(cuName->buf, sizeof(cuName->size));
 565    for(idx=0; idx<elementCnt; idx++)
 566    {
 567       CU_FREE(f1SetupRsp->protocolIEs.list.array[idx], sizeof(F1SetupResponseIEs_t));
 568    }
 569    CU_FREE(f1SetupRsp->protocolIEs.list.array, elementCnt * sizeof(F1SetupResponseIEs_t *));
 570    CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 571    CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 572
 573    /* Check encode results */
 574    if(encRetVal.encoded == ENCODE_FAIL)
 575    {
 576       DU_LOG("\nERROR  -->  F1AP : Could not encode F1SetupResponse structure (at %s)\n",\
 577             encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
 578       return RFAILED;
 579    }
 580    else
 581    {
 582       DU_LOG("\nDEBUG  -->  F1AP : Created APER encoded buffer for F1SetupResponse\n");
 583       for(int i=0; i< encBufSize; i++)
 584       {
 585          DU_LOG("%x",encBuf[i]);
 586       }
 587    }
 588
 589    /* Sending msg */
 590    if(SendF1APMsg(CU_APP_MEM_REG, CU_POOL, duId) != ROK)
 591    {
 592       DU_LOG("\nERROR  -->  F1AP : Sending F1 Setup Response failed");
 593       return RFAILED;
 594    }
 595
 596    return ROK;
 597 }/* End of BuildAndSendF1SetupRsp */
 598
 599 /*******************************************************************
 600  *
 601  * @brief Builds and sends the DUUpdateAcknowledge
 602  *
 603  * @details
 604  *
 605  *    Function : BuildAndSendDUUpdateAck
 606  *
 607  *    Functionality: Constructs the DU Update Acknowledge message and sends
 608  *                   it to the DU through SCTP.
 609  *
 610  * @params[in]
 611  *
 612  * @return ROK     - success
 613  *         RFAILED - failure
 614  *
 615  * ****************************************************************/
 616
 617 uint8_t BuildAndSendDUUpdateAck(uint32_t duId)
 618 {
 619    uint8_t   idx;
 620    uint8_t   elementCnt;
 621    F1AP_PDU_t *f1apMsg = NULL;
 622    GNBDUConfigurationUpdateAcknowledge_t *gNBDuCfgAck;
 623    asn_enc_rval_t enRetVal; /* Encoder return value */
 624
 625    DU_LOG("\nINFO  -->  F1AP : Building GNB-DU Config Update Ack\n");
 626
 627    /* Allocate the memory for F1SetupRequest_t */
 628    CU_ALLOC(f1apMsg, (Size)sizeof(F1AP_PDU_t));
 629    if(f1apMsg == NULLP)
 630    {
 631       DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
 632       return RFAILED;
 633    }
 634
 635    f1apMsg->present =  F1AP_PDU_PR_successfulOutcome;
 636
 637    CU_ALLOC(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 638    if(f1apMsg->choice.successfulOutcome == NULLP)
 639    {
 640       DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
 641       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 642       return RFAILED;
 643    }
 644
 645    f1apMsg->choice.successfulOutcome->procedureCode = ProcedureCode_id_gNBDUConfigurationUpdate;
 646    f1apMsg->choice.successfulOutcome->criticality = Criticality_reject;
 647    f1apMsg->choice.successfulOutcome->value.present = SuccessfulOutcome__value_PR_GNBDUConfigurationUpdateAcknowledge;
 648    gNBDuCfgAck = &f1apMsg->choice.successfulOutcome->value.choice.GNBDUConfigurationUpdateAcknowledge;
 649
 650    elementCnt = 1;
 651    gNBDuCfgAck->protocolIEs.list.count = elementCnt;
 652    gNBDuCfgAck->protocolIEs.list.size = elementCnt*sizeof(GNBDUConfigurationUpdateAcknowledgeIEs_t);
 653
 654    /* Initialize the F1Setup members */
 655    CU_ALLOC(gNBDuCfgAck->protocolIEs.list.array, elementCnt * sizeof(GNBDUConfigurationUpdateAcknowledgeIEs_t *));
 656    if(gNBDuCfgAck->protocolIEs.list.array == NULLP)
 657    {
 658       DU_LOG("\nERROR  -->  F1AP : Memory allocation for DuUpdateAcknowledgeIEs failed");
 659       CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 660       CU_FREE(f1apMsg,(Size)sizeof(F1AP_PDU_t));
 661       return RFAILED;
 662    }
 663
 664    for(idx=0; idx<elementCnt; idx++)
 665    {
 666       CU_ALLOC(gNBDuCfgAck->protocolIEs.list.array[idx], sizeof(GNBDUConfigurationUpdateAcknowledgeIEs_t));
 667       if(gNBDuCfgAck->protocolIEs.list.array[idx] == NULLP)
 668       {
 669          CU_FREE(gNBDuCfgAck->protocolIEs.list.array, elementCnt * sizeof(GNBDUConfigurationUpdateAcknowledgeIEs_t *));
 670          CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 671          CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 672          return RFAILED;
 673       }
 674    }
 675
 676    /*TransactionID*/
 677    idx = 0;
 678    gNBDuCfgAck->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_TransactionID ;
 679    gNBDuCfgAck->protocolIEs.list.array[idx]->criticality = Criticality_reject;
 680    gNBDuCfgAck->protocolIEs.list.array[idx]->value.present =\
 681    GNBDUConfigurationUpdateAcknowledgeIEs__value_PR_TransactionID;
 682    gNBDuCfgAck->protocolIEs.list.array[idx]->value.choice.TransactionID = TRANS_ID;
 683
 684    xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
 685
 686    /* Encode the F1SetupRequest type as UPER */
 687    memset(encBuf, 0, ENC_BUF_MAX_LEN);
 688    encBufSize = 0;
 689    enRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
 690
 691    /* Clean up */
 692    for(idx=0; idx<elementCnt; idx++)
 693    {
 694       CU_FREE(gNBDuCfgAck->protocolIEs.list.array[idx], sizeof(GNBDUConfigurationUpdateAcknowledgeIEs_t));
 695    }
 696    CU_FREE(gNBDuCfgAck->protocolIEs.list.array, elementCnt * sizeof(GNBDUConfigurationUpdateAcknowledgeIEs_t *));
 697    CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 698    CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 699
 700    /* Checking encode results */
 701    if(enRetVal.encoded == ENCODE_FAIL)
 702    {
 703       DU_LOG("\nERROR  -->  F1AP : Could not encode DUConfigUpdateAcknowledge structure (at %s)",\
 704       enRetVal.failed_type ? enRetVal.failed_type->name : "unknown");
 705       return RFAILED;
 706    }
 707    else
 708    {
 709       DU_LOG("\nDEBUG  -->  F1AP : Created APER encoded buffer for DuConfigUpdateAcknowledge\n");
 710       for(int i=0; i< encBufSize; i++)
 711       {
 712          DU_LOG("%x",encBuf[i]);
 713       }
 714    }
 715
 716    /* Sending msg */
 717    /* TODO : Hardcoding DU ID to 1 for messages other than F1 Setup Response. This will be made generic in future gerrit */
 718    if(SendF1APMsg(CU_APP_MEM_REG, CU_POOL, duId) != ROK)
 719    {
 720       DU_LOG("\nERROR  -->  F1AP : Sending GNB-DU Config Update Ack failed");
 721       return RFAILED;
 722    }
 723
 724    return ROK;
 725
 726 }/* End of BuildAndSendDUUpdateAck*/
 727
 728 /*******************************************************************
 729 *
 730 * @brief deallocating the memory of  F1reset msg
 731 *
 732 * @details
 733 *
 734 *    Function : FreeF1ResetReq
 735 *
 736 *    Functionality :
 737 *         - freeing memory of F1reset request msg
 738 *
 739 * @params[in]
 740 * @return void
 741 *
 742 *
 743 * ****************************************************************/
 744 void FreeF1ResetReq(F1AP_PDU_t *f1apMsg)
 745 {
 746    uint8_t idx = 0;
 747    Reset_t *f1ResetMsg = NULLP;
 748
 749    if(f1apMsg)
 750    {
 751       if(f1apMsg->choice.initiatingMessage)
 752       {
 753          f1ResetMsg = &f1apMsg->choice.initiatingMessage->value.choice.Reset;
 754          if(f1ResetMsg->protocolIEs.list.array)
 755          {
 756             for(idx=0 ;idx < f1ResetMsg->protocolIEs.list.count ; idx++)
 757             {
 758                if(f1ResetMsg->protocolIEs.list.array[idx])
 759                {
 760                   CU_FREE(f1ResetMsg->protocolIEs.list.array[idx],sizeof(ResetIEs_t));
 761                }
 762             }
 763             CU_FREE(f1ResetMsg->protocolIEs.list.array,f1ResetMsg->protocolIEs.list.size);
 764          }
 765          CU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
 766       }
 767       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 768    }
 769 }
 770 /*******************************************************************
 771  *
 772  * @brief build ansld ans send f1reset msg
 773  *
 774  * @details
 775  *
 776  *    Function : BuildAndSendF1ResetReq
 777  *
 778  *    Functionality: build and send f1reset msg
 779  *
 780  * @return ROK     - success
 781  *         RFAILED - failure
 782  *
 783  * ****************************************************************/
 784 uint8_t BuildAndSendF1ResetReq()
 785 {
 786    uint8_t          elementCnt=0;
 787    uint8_t          idx=0;
 788    uint8_t          ret= RFAILED;
 789    Reset_t          *f1ResetMsg = NULLP;
 790    F1AP_PDU_t       *f1apMsg = NULLP;
 791    asn_enc_rval_t   encRetVal;
 792    DU_LOG("\nINFO  -->  F1AP : Building F1 Reset request \n");
 793    do
 794    {
 795       CU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
 796       if(f1apMsg == NULLP)
 797       {
 798          DU_LOG("\nERROR  -->  F1AP : Memory allocation for the BuildAndSendF1ResetReq's F1AP-PDU failed");
 799          break;
 800       }
 801       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
 802       CU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
 803       if(f1apMsg->choice.initiatingMessage == NULLP)
 804       {
 805          DU_LOG("\nERROR  -->  F1AP : Memory allocation for BuildAndSendF1ResetReq failed");
 806          break;
 807       }
 808       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_Reset;
 809       f1apMsg->choice.initiatingMessage->criticality = Criticality_reject;
 810       f1apMsg->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_Reset;
 811
 812       f1ResetMsg = &f1apMsg->choice.initiatingMessage->value.choice.Reset;
 813
 814       elementCnt = 3;
 815       f1ResetMsg->protocolIEs.list.count = elementCnt;
 816       f1ResetMsg->protocolIEs.list.size = elementCnt * sizeof(ResetIEs_t *);
 817
 818       /* Initialize the F1Reset members */
 819       CU_ALLOC(f1ResetMsg->protocolIEs.list.array,f1ResetMsg->protocolIEs.list.size);
 820       if(f1ResetMsg->protocolIEs.list.array == NULLP)
 821       {
 822          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed for BuildAndSendF1ResetReq");
 823          break;
 824       }
 825       for(idx=0; idx<elementCnt; idx++)
 826       {
 827          CU_ALLOC(f1ResetMsg->protocolIEs.list.array[idx],sizeof(ResetIEs_t));
 828          if(f1ResetMsg->protocolIEs.list.array[idx] == NULLP)
 829          {
 830             DU_LOG("\nERROR  -->  F1AP : Memory allocation failed for BuildAndSendF1ResetReq msg array");
 831             break;
 832          }
 833       }
 834
 835       /*TransactionID*/
 836       idx=0;
 837       f1ResetMsg->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_TransactionID;
 838       f1ResetMsg->protocolIEs.list.array[idx]->criticality = Criticality_reject;
 839       f1ResetMsg->protocolIEs.list.array[idx]->value.present = ResetIEs__value_PR_TransactionID;
 840       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.TransactionID = 1;
 841
 842       /*Cause*/
 843       idx++;
 844       f1ResetMsg->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_Cause;
 845       f1ResetMsg->protocolIEs.list.array[idx]->criticality = Criticality_ignore;
 846       f1ResetMsg->protocolIEs.list.array[idx]->value.present = ResetIEs__value_PR_Cause;
 847       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.Cause.present = Cause_PR_radioNetwork;
 848       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.Cause.choice.radioNetwork = CauseRadioNetwork_action_desirable_for_radio_reasons;
 849
 850       /*Reset Type*/
 851       idx++;
 852       f1ResetMsg->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_ResetType;
 853       f1ResetMsg->protocolIEs.list.array[idx]->criticality = Criticality_reject;
 854       f1ResetMsg->protocolIEs.list.array[idx]->value.present = ResetIEs__value_PR_ResetType;
 855       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.ResetType.present = ResetType_PR_f1_Interface;
 856       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.ResetType.choice.f1_Interface = ResetAll_reset_all;
 857
 858       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
 859
 860       /* Encode the F1SetupRequest type as APER */
 861       memset(encBuf, 0, ENC_BUF_MAX_LEN);
 862       encBufSize = 0;
 863       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
 864             encBuf);
 865
 866       /* Encode results */
 867       if(encRetVal.encoded == ENCODE_FAIL)
 868       {
 869          DU_LOG("\nERROR  -->  F1AP : Could not encode F1Reset structure (at %s)\n",\
 870                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
 871          break;
 872       }
 873       else
 874       {
 875          DU_LOG("\nDEBUG  -->  F1AP : Created APER encoded buffer for F1Reset\n");
 876          for(idx=0; idx< encBufSize; idx++)
 877          {
 878             DU_LOG("%x",encBuf[idx]);
 879          }
 880       }
 881
 882       /* TODO : Hardcoding DU ID to 1 for messages other than F1 Setup Response. This will be made generic in future gerrit */
 883       if(SendF1APMsg(CU_APP_MEM_REG, CU_POOL, DU_ID) != ROK)
 884       {
 885          DU_LOG("\nERROR  -->  F1AP : Sending F1 Reset request failed");
 886          break;
 887       }
 888
 889       ret = ROK;
 890       break;
 891    }while(true);
 892
 893    FreeF1ResetReq(f1apMsg);
 894    return ret;
 895 }
 896
 897 /*******************************************************************
 898  *
 899  * @brief Fills Radio Bearer Config
 900  *
 901  * @details
 902  *
 903  *    Function : fillSrbCfg
 904  *
 905  *    Functionality: Fills Radio Bearer Config
 906  *
 907  * @params[in] SRB_ToAddModList *
 908  *
 909  * @return ROK     - success
 910  *         RFAILED - failure
 911  *
 912  * ****************************************************************/
 913 uint8_t fillSrbCfg(CuUeCb *ueCb, SRB_ToAddModList_t *bearerCfg)
 914 {
 915    uint8_t elementCnt = 0;
 916    uint8_t idx, ieId, srbIdx = 0;
 917
 918    for(srbIdx=0; srbIdx < ueCb->numSrb; srbIdx++)
 919    {
 920       if(ueCb->srbList[srbIdx].cfgSentToUe == false)
 921          elementCnt++;
 922    }
 923
 924    if(bearerCfg != NULLP)
 925    {
 926       bearerCfg->list.count = elementCnt;
 927       bearerCfg->list.size = elementCnt * sizeof(SRB_ToAddMod_t *);
 928       CU_ALLOC(bearerCfg->list.array, bearerCfg->list.size);
 929       if(bearerCfg->list.array != NULLP)
 930       {
 931          for(idx = 0; idx < elementCnt; idx++)
 932          {
 933             CU_ALLOC(bearerCfg->list.array[idx], sizeof(SRB_ToAddMod_t));
 934             if(bearerCfg->list.array[idx] == NULLP)
 935             {
 936                for(ieId = 0; ieId < idx; ieId++)
 937                {
 938                   CU_FREE(bearerCfg->list.array[ieId], sizeof(SRB_ToAddMod_t));
 939                }
 940                CU_FREE(bearerCfg->list.array, bearerCfg->list.size);
 941                return RFAILED;
 942             }
 943          }
 944       }
 945       else
 946       {
 947          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed for bearer list arry in fillSrbCfg");
 948          return RFAILED;
 949       }
 950
 951       idx = 0;
 952       for(srbIdx=0; srbIdx < ueCb->numSrb; srbIdx++)
 953       {
 954          if(ueCb->srbList[srbIdx].cfgSentToUe == false)
 955             bearerCfg->list.array[idx++]->srb_Identity = ueCb->srbList[srbIdx].srbId;
 956       }
 957    }
 958    return ROK;
 959 }
 960
 961 /*******************************************************************
 962  *
 963  * @brief Fills Master CellGroup Info
 964  *
 965  * @details
 966  *
 967  *    Function : fillMasterCellGroup
 968  *
 969  *    Functionality: Fills Master Cell Group IE
 970  *
 971  * @params[in] RRCSetup_IEs_t *
 972  *
 973  * @return ROK     - success
 974  *         RFAILED - failure
 975  *
 976  * ****************************************************************/
 977
 978 uint8_t fillMasterCellGroup(CuUeCb *ueCb, OCTET_STRING_t *masterCellGroup)
 979 {
 980    uint8_t ret = ROK;
 981    masterCellGroup->buf = NULLP;
 982    if(ueCb->f1apMsgDb.duToCuContainer.buf)
 983    {
 984       masterCellGroup->size = ueCb->f1apMsgDb.duToCuContainer.size;
 985       CU_ALLOC(masterCellGroup->buf, masterCellGroup->size);
 986       if(masterCellGroup->buf != NULLP)
 987       {
 988          memcpy(masterCellGroup->buf, ueCb->f1apMsgDb.duToCuContainer.buf, masterCellGroup->size);
 989       }
 990       else
 991       {
 992          DU_LOG( "\nERROR  -->  F1AP : Master Cell Group buffer is NULL");
 993          ret = RFAILED;
 994       }
 995    }
 996    else
 997    {
 998       ret =  RFAILED;
 999    }
1000    return ret;
1001 }
1002
1003 /*******************************************************************
1004  *
1005  * @brief Fills RRC setup IE
1006  *
1007  * @details
1008  *
1009  *    Function : fillRRCSetupIE
1010  *
1011  *    Functionality: Fills RRC Setup IE
1012  *
1013  * @params[in] RRCSetup_IEs_t *
1014  *
1015  * @return ROK     - success
1016  *         RFAILED - failure
1017  *
1018  * ****************************************************************/
1019
1020 uint8_t fillRRCSetupIE(CuUeCb *ueCb, RRCSetup_IEs_t *rrcSetupIE)
1021 {
1022    uint8_t ret = ROK, srbIdx = 0;
1023    if(rrcSetupIE)
1024    {
1025       CU_ALLOC(rrcSetupIE->radioBearerConfig.srb_ToAddModList, sizeof(SRB_ToAddModList_t));
1026       if(rrcSetupIE->radioBearerConfig.srb_ToAddModList != NULLP)
1027       {
1028          ret = fillSrbCfg(ueCb, rrcSetupIE->radioBearerConfig.srb_ToAddModList);
1029       }
1030       if(ret == ROK)
1031       {
1032          ret = fillCellGrpCfg(ueCb, &rrcSetupIE->masterCellGroup, false);
1033       }
1034       else
1035       {
1036          CU_FREE(rrcSetupIE->radioBearerConfig.srb_ToAddModList, sizeof(SRB_ToAddModList_t));
1037          ret = RFAILED;
1038       }
1039
1040       /* If SRB configuration are filled successfully in RRC Setup, mark these
1041        * configurartion as sent to UE */
1042       for(srbIdx=0; srbIdx < ueCb->numSrb; srbIdx++)
1043       {
1044          if(ueCb->srbList[srbIdx].cfgSentToUe == false)
1045             ueCb->srbList[srbIdx].cfgSentToUe = true;
1046       }
1047    }
1048    return ret;
1049 }
1050 /*******************************************************************
1051  *
1052  * @brief Fills DL DCCCH Message required for DLRRCMessageTransfer
1053  *
1054  * @details
1055  *
1056  *    Function : fillDlCcchRrcMsg
1057  *
1058  *    Functionality: Fills DL DCCCH Message required for
1059  *                   DLRRCMessageTransfer
1060  *
1061  * @params[in] RRCContainer_t *rrcContainer
1062  *
1063  * @return ROK     - success
1064  *         RFAILED - failure
1065  *
1066  * ****************************************************************/
1067
1068 uint8_t fillDlCcchRrcMsg(CuUeCb *ueCb, RRCContainer_t *rrcContainer)
1069 {
1070    uint8_t ret = ROK;
1071    uint16_t idx2;
1072    DL_CCCH_Message_t dl_CCCH_Msg;
1073    asn_enc_rval_t    encRetVal;
1074
1075    if(rrcContainer != NULLP)
1076    {
1077       dl_CCCH_Msg.message.present = DL_CCCH_MessageType_PR_c1;
1078
1079       CU_ALLOC(dl_CCCH_Msg.message.choice.c1 , sizeof(DL_CCCH_MessageType_t));
1080       if(dl_CCCH_Msg.message.choice.c1 != NULLP)
1081       {
1082          dl_CCCH_Msg.message.choice.c1->present = DL_CCCH_MessageType__c1_PR_rrcSetup;
1083          CU_ALLOC(dl_CCCH_Msg.message.choice.c1->choice.rrcSetup, sizeof(RRCSetup_t));
1084          if(dl_CCCH_Msg.message.choice.c1->choice.rrcSetup != NULLP)
1085          {
1086             dl_CCCH_Msg.message.choice.c1->choice.rrcSetup->rrc_TransactionIdentifier = 0;
1087             dl_CCCH_Msg.message.choice.c1->choice.rrcSetup->criticalExtensions.present = \
1088                RRCSetup__criticalExtensions_PR_rrcSetup;
1089
1090             /* Fill RRC Setup IE */
1091             CU_ALLOC(dl_CCCH_Msg.message.choice.c1->choice.rrcSetup->criticalExtensions.choice.rrcSetup, \
1092                sizeof(RRCSetup_IEs_t));
1093             if(dl_CCCH_Msg.message.choice.c1->choice.rrcSetup->criticalExtensions.choice.rrcSetup != NULLP)
1094             {
1095                ret = fillRRCSetupIE(ueCb, dl_CCCH_Msg.message.choice.c1->choice.rrcSetup->criticalExtensions.choice.rrcSetup);
1096
1097                if(ret == ROK)
1098                {
1099                   /* encode DL-CCCH message into RRC Container */
1100                   xer_fprint(stdout, &asn_DEF_DL_CCCH_MessageType, &dl_CCCH_Msg);
1101                   memset(encBuf, 0, ENC_BUF_MAX_LEN);
1102                   encBufSize = 0;
1103                   encRetVal = aper_encode(&asn_DEF_DL_CCCH_MessageType, 0, &dl_CCCH_Msg, PrepFinalEncBuf, encBuf);
1104                   /* Encode results */
1105                   if(encRetVal.encoded == ENCODE_FAIL)
1106                   {
1107                      DU_LOG( "\nERROR  -->  F1AP : Could not encode RRCContainer for DL-CCCH Msg(at %s)\n",\
1108                            encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
1109                      return RFAILED;
1110                   }
1111                   else
1112                   {
1113                      DU_LOG("\nDEBUG  -->  F1AP : Created APER encoded buffer for RRCContainer for DL-CCCH Msg\n");
1114                      for(int i = 0; i< encBufSize; i++)
1115                      {
1116                         DU_LOG("%x",encBuf[i]);
1117                      }
1118                      rrcContainer->size = encBufSize;
1119                      CU_ALLOC(rrcContainer->buf, rrcContainer->size);
1120                      if(rrcContainer->buf != NULLP)
1121                      {
1122                         memset(rrcContainer->buf, 0, encBufSize);
1123                         for(idx2 = 0; idx2 < encBufSize; idx2++)
1124                         {
1125                            rrcContainer->buf[idx2] =    encBuf[idx2];
1126                         }
1127                      }
1128                   }
1129                }
1130                else
1131                {
1132                   ret = RFAILED;
1133                }
1134             }
1135             else
1136             {
1137                DU_LOG("\nERROR  -->  F1AP: Memory Alloc failed for RRC Setup Msg at fillDlCcchRrcMsg()");
1138                ret = RFAILED;
1139             }
1140          }
1141          else
1142          {
1143             DU_LOG("\nERROR  -->  F1AP: Memory Alloc failed for RRC Msg at fillDlCcchRrcMsg()");
1144             ret = RFAILED;
1145          }
1146       }
1147       else
1148       {
1149          DU_LOG("\nF1AP: Memory Alloc failed for DL Ccch Msg choice at fillDlCcchRrcMsg()");
1150          ret = RFAILED;
1151       }
1152    }
1153    else
1154    {
1155       DU_LOG("\nERROR  -->  F1AP: RRC Container is NULLP at fillDlCcchRrcMsg()");
1156       ret = RFAILED;
1157    }
1158 }
1159
1160 /*******************************************************************
1161  *
1162  * @brief Fills QOS flow configuration
1163  *
1164  * @details
1165  *
1166  *    Function : fillQosFlowsToAdd
1167  *
1168  *    Functionality: Fills QOS flow configuration
1169  *
1170  * @params[in] struct SDAP_Config__mappedQoS_FlowsToAdd *qosFlow
1171  *
1172  * @return ROK     - success
1173  *         RFAILED - failure
1174  *
1175  * ****************************************************************/
1176 uint8_t fillQosFlowsToAdd(struct SDAP_Config__mappedQoS_FlowsToAdd *qosFlow)
1177 {
1178    uint8_t idx, ied, elementCnt;
1179
1180    elementCnt = 1;
1181    qosFlow->list.count = elementCnt;
1182    qosFlow->list.size  = elementCnt * sizeof(QFI_t *);
1183    CU_ALLOC(qosFlow->list.array, qosFlow->list.size);
1184    if(qosFlow->list.array != NULLP)
1185    {
1186       for(idx = 0; idx < elementCnt; idx++)
1187       {
1188          CU_ALLOC(qosFlow->list.array[idx], sizeof(QFI_t));
1189          if(qosFlow->list.array[idx] == NULLP)
1190          {
1191             for(ied = 0; ied < idx; ied++)
1192             {
1193                CU_FREE(qosFlow->list.array[idx], sizeof(QFI_t));
1194             }
1195             CU_FREE(qosFlow->list.array, qosFlow->list.size);
1196             return RFAILED;
1197          }
1198       }
1199    }
1200    idx = 0;
1201    *qosFlow->list.array[idx] = 9;
1202    return ROK;
1203 }
1204
1205 /*******************************************************************
1206  *
1207  * @brief Fills CN Assoc for Drb to Add/Mod List
1208  *
1209  * @details
1210  *
1211  *    Function : fillCnAssoc
1212  *
1213  *    Functionality: Fills CN Assoc for Drb to Add/Mod List
1214  *
1215  * @params[in] struct DRB_ToAddMod__cnAssociation *
1216  *
1217  * @return ROK     - success
1218  *         RFAILED - failure
1219  *
1220  * ****************************************************************/
1221
1222 uint8_t fillCnAssoc(struct DRB_ToAddMod__cnAssociation *cnAssoc)
1223 {
1224    uint8_t ret = ROK;
1225
1226    cnAssoc->present = DRB_ToAddMod__cnAssociation_PR_sdap_Config;
1227    if(cnAssoc->present == DRB_ToAddMod__cnAssociation_PR_eps_BearerIdentity)
1228    {
1229       cnAssoc->choice.eps_BearerIdentity = 5;
1230    }
1231    if(cnAssoc->present == DRB_ToAddMod__cnAssociation_PR_sdap_Config)
1232    {
1233       CU_ALLOC(cnAssoc->choice.sdap_Config, sizeof(SDAP_Config_t));
1234       if(cnAssoc->choice.sdap_Config)
1235       {
1236          cnAssoc->choice.sdap_Config->pdu_Session = 5;
1237          cnAssoc->choice.sdap_Config->sdap_HeaderDL = 0;
1238          cnAssoc->choice.sdap_Config->sdap_HeaderUL = 0;
1239          cnAssoc->choice.sdap_Config->defaultDRB = true;
1240          cnAssoc->choice.sdap_Config->mappedQoS_FlowsToAdd = NULLP;
1241          cnAssoc->choice.sdap_Config->mappedQoS_FlowsToRelease = NULLP;
1242          CU_ALLOC(cnAssoc->choice.sdap_Config->mappedQoS_FlowsToAdd, \
1243                sizeof(struct SDAP_Config__mappedQoS_FlowsToAdd));
1244          if(cnAssoc->choice.sdap_Config->mappedQoS_FlowsToAdd)
1245          {
1246             ret = fillQosFlowsToAdd(cnAssoc->choice.sdap_Config->mappedQoS_FlowsToAdd);
1247          }
1248          else
1249          {
1250             DU_LOG("\nERROR  -->  F1AP: Memory alloc failed at mappedQoS_FlowsToAdd in fillCnAssoc()");
1251             CU_FREE(cnAssoc->choice.sdap_Config, sizeof(SDAP_Config_t));
1252             ret = RFAILED;
1253          }
1254       }
1255       else
1256       {
1257          DU_LOG("\nERROR  -->  F1AP: Mem alloc failed at fillCnAssoc()");
1258          ret = RFAILED;
1259       }
1260    }
1261    return ret;
1262 }
1263
1264 /*******************************************************************
1265  *
1266  * @brief Fills Radio Bearer Config for Drb
1267  *
1268  * @details
1269  *
1270  *    Function : fillDrbCfg
1271  *
1272  *    Functionality: Fills Radio Bearer Config for Drb
1273  *
1274  * @params[in] drbId, DRB_ToAddModList *
1275  *
1276  * @return ROK     - success
1277  *         RFAILED - failure
1278  *
1279  * ****************************************************************/
1280 uint8_t fillDrbCfg(uint8_t drbId, DRB_ToAddModList_t *drbCfg)
1281 {
1282    uint8_t idx, ied, ret, elementCnt;
1283
1284    ret = ROK;
1285    if(drbCfg != NULLP)
1286    {
1287       elementCnt = 1;
1288       drbCfg->list.count = elementCnt;
1289       drbCfg->list.size =\
1290                          elementCnt * sizeof(DRB_ToAddMod_t *);
1291       CU_ALLOC(drbCfg->list.array, drbCfg->list.size);
1292       if(drbCfg->list.array != NULLP)
1293       {
1294          for(idx = 0; idx < elementCnt; idx++)
1295          {
1296             CU_ALLOC(drbCfg->list.array[idx], sizeof(DRB_ToAddMod_t));
1297             if(drbCfg->list.array[idx] == NULLP)
1298             {
1299                for(ied = 0; ied < idx; ied++)
1300                {
1301                   CU_FREE(drbCfg->list.array[idx], sizeof(DRB_ToAddMod_t));
1302                }
1303                CU_FREE(drbCfg->list.array, drbCfg->list.size);
1304                return RFAILED;
1305             }
1306          }
1307       }
1308       else
1309       {
1310          return RFAILED;
1311       }
1312       idx = 0;
1313       /* CN ASSOCIATION */
1314       CU_ALLOC(drbCfg->list.array[idx]->cnAssociation, sizeof(struct DRB_ToAddMod__cnAssociation));
1315       if(drbCfg->list.array[idx]->cnAssociation)
1316       {
1317          ret = fillCnAssoc(drbCfg->list.array[idx]->cnAssociation);
1318       }
1319       /* DRB */
1320       drbCfg->list.array[idx]->drb_Identity = drbId;
1321    }
1322    return ret;
1323 }
1324
1325 /*******************************************************************
1326  *
1327  * @brief Fills RRC Reconfig Message required for DLRRCMessageTransfer
1328  *
1329  * @details
1330  *
1331  *    Function : fillRrcReconfigIE
1332  *
1333  *    Functionality: Fills RRC Reconfig Message required for
1334  *                   DLRRCMessageTransfer
1335  *
1336  * @params[in] RRCReconfiguration_IEs_t* rrcReconfig
1337  *
1338  * @return ROK     - success
1339  *         RFAILED - failure
1340  *
1341  * ****************************************************************/
1342
1343 uint8_t fillRrcReconfigIE(RRCReconfiguration_IEs_t *rrcReconfigMsg)
1344 {
1345    uint8_t ret = ROK;
1346    CU_ALLOC(rrcReconfigMsg->radioBearerConfig, sizeof(RadioBearerConfig_t));
1347    if(rrcReconfigMsg->radioBearerConfig)
1348    {
1349       CU_ALLOC(rrcReconfigMsg->radioBearerConfig->srb_ToAddModList, sizeof(SRB_ToAddModList_t));
1350       if(rrcReconfigMsg->radioBearerConfig->srb_ToAddModList != NULLP)
1351       {
1352          ret = fillSrbCfg(SRB2, rrcReconfigMsg->radioBearerConfig->srb_ToAddModList);
1353
1354       }
1355       if(ret == ROK)
1356       {
1357          CU_ALLOC(rrcReconfigMsg->radioBearerConfig->drb_ToAddModList, sizeof(DRB_ToAddModList_t));
1358          if(rrcReconfigMsg->radioBearerConfig->drb_ToAddModList != NULLP)
1359          {
1360             ret = fillDrbCfg(DRB1, rrcReconfigMsg->radioBearerConfig->drb_ToAddModList);
1361             if(ret == RFAILED)
1362             {
1363                DU_LOG("\nERROR  -->  F1AP : Failed to fill DrbCfg at fillRrcReconfigIE()");
1364                CU_FREE(rrcReconfigMsg->radioBearerConfig->srb_ToAddModList, sizeof(SRB_ToAddModList_t));
1365                CU_FREE(rrcReconfigMsg->radioBearerConfig->drb_ToAddModList, sizeof(DRB_ToAddModList_t));
1366             }
1367          }
1368       }
1369       else
1370       {
1371          DU_LOG("\nERROR  -->  F1AP : memory Alloc failed at fillRrcReconfigIE()");
1372          CU_FREE(rrcReconfigMsg->radioBearerConfig->srb_ToAddModList, sizeof(SRB_ToAddModList_t));
1373       }
1374    }
1375
1376    return ret;
1377 }
1378 /*******************************************************************
1379  *
1380  * @brief Fills DL DCCH Message required for DLRRCMessageTransfer
1381  *
1382  * @details
1383  *
1384  *    Function : fillDlDcchRrcMsg
1385  *
1386  *    Functionality: Fills DL DCCH Message required for
1387  *                   DLRRCMessageTransfer
1388  *
1389  * @params[in] RRCContainer_t *rrcContainer
1390  *
1391  * @return ROK     - success
1392  *         RFAILED - failure
1393  *
1394  * ****************************************************************/
1395
1396 uint8_t fillDlDcchRrcMsg(CuUeCb *ueCb, RRCContainer_t *rrcContainer)
1397 {
1398    uint8_t ret = ROK;
1399    uint16_t idx2 = 0, drbIdx = 0, srbIdx = 0;
1400    DL_DCCH_Message_t dl_DCCH_Msg;
1401    memset(&dl_DCCH_Msg, 0, sizeof(DL_DCCH_Message_t));
1402    asn_enc_rval_t        encRetVal;
1403
1404    if(rrcContainer != NULLP)
1405    {
1406       dl_DCCH_Msg.message.present = DL_DCCH_MessageType_PR_c1;
1407
1408       CU_ALLOC(dl_DCCH_Msg.message.choice.c1 , sizeof(DL_DCCH_MessageType_t));
1409       if(dl_DCCH_Msg.message.choice.c1 != NULLP)
1410       {
1411          dl_DCCH_Msg.message.choice.c1->present = DL_DCCH_MessageType__c1_PR_rrcReconfiguration;
1412          CU_ALLOC(dl_DCCH_Msg.message.choice.c1->choice.rrcReconfiguration, sizeof(RRCReconfiguration_t));
1413          if(dl_DCCH_Msg.message.choice.c1->choice.rrcReconfiguration != NULLP)
1414          {
1415             DU_LOG("\nDEBUG --> F1AP : Filling DL DCCH RRC Reconfiguration Message ");
1416             fillRrcReconfig(ueCb, dl_DCCH_Msg.message.choice.c1->choice.rrcReconfiguration, false);
1417             if(ret == ROK)
1418             {
1419                /* If RB configuration are filled successfully in RRC Reconfiguration, mark these
1420                 * configurartion as sent to UE */
1421                for(srbIdx=0; srbIdx < ueCb->numSrb; srbIdx++)
1422                {
1423                   if(ueCb->srbList[srbIdx].cfgSentToUe == false)
1424                      ueCb->srbList[srbIdx].cfgSentToUe = true;
1425                }
1426                for(drbIdx=0; drbIdx < ueCb->numDrb; drbIdx++)
1427                {
1428                   if(ueCb->drbList[drbIdx].cfgSentToUe == false)
1429                      ueCb->drbList[drbIdx].cfgSentToUe = true;
1430                }
1431
1432                /* encode DL-DCCH message into RRC Container */
1433                xer_fprint(stdout, &asn_DEF_DL_DCCH_MessageType, &dl_DCCH_Msg);
1434                memset(encBuf, 0, ENC_BUF_MAX_LEN);
1435                encBufSize = 0;
1436                encRetVal = aper_encode(&asn_DEF_DL_DCCH_MessageType, 0, &dl_DCCH_Msg, PrepFinalEncBuf, encBuf);
1437                /* Encode results */
1438                if(encRetVal.encoded == ENCODE_FAIL)
1439                {
1440                   DU_LOG( "\nERROR  -->  F1AP : Could not encode RRCContainer for DL-DCCH Msg (at %s)\n",\
1441                         encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
1442                   return RFAILED;
1443                }
1444                else
1445                {
1446                   DU_LOG("\nDEBUG  -->  F1AP : Created APER encoded buffer for RRCContainer for DL-DCCH Msg\n");
1447                   for(int i = 0; i< encBufSize; i++)
1448                   {
1449                      DU_LOG("%x",encBuf[i]);
1450                   }
1451                   rrcContainer->size = encBufSize;
1452                   CU_ALLOC(rrcContainer->buf, rrcContainer->size);
1453                   if(rrcContainer->buf != NULLP)
1454                   {
1455                      memset(rrcContainer->buf, 0, encBufSize);
1456                      for(idx2 = 0; idx2 < encBufSize; idx2++)
1457                      {
1458                         rrcContainer->buf[idx2] =       encBuf[idx2];
1459                      }
1460                   }
1461                }
1462             }
1463          }
1464          else
1465          {
1466             DU_LOG("\nERROR  -->  F1AP: Memory Alloc failed for RRC Msg at fillDlDcchRrcMsg()");
1467             ret = RFAILED;
1468          }
1469       }
1470       else
1471       {
1472          DU_LOG("\nERROR  -->  F1AP: Memory Alloc failed for DL Dcch Msg choice at fillDlDcchRrcMsg()");
1473          ret = RFAILED;
1474       }
1475    }
1476    else
1477    {
1478       DU_LOG("\nERROR  -->  F1AP: RRC Container is NULLP at fillDlDcchRrcMsg()");
1479       ret = RFAILED;
1480    }
1481    return ret;
1482 }
1483
1484 /*******************************************************************
1485  *
1486  * @brief Builds RRC Container IE required for DLRRCMessageTransfer
1487  *
1488  * @details
1489  *
1490  *    Function : BuildDLRRCContainer
1491  *
1492  *    Functionality: Builds RRC Container IE required for
1493  *                   DLRRCMessageTransfer
1494  *
1495  * @params[in]
1496  *
1497  * @return ROK     - success
1498  *         RFAILED - failure
1499  *
1500  * ****************************************************************/
1501
1502 uint8_t BuildDLRRCContainer(CuUeCb *ueCb, uint8_t rrcMsgType, RRCContainer_t *rrcContainer)
1503 {
1504    uint8_t ret, bufLen;
1505
1506    ret =ROK;
1507    if(rrcMsgType == RRC_SETUP)
1508    {
1509       ret = fillDlCcchRrcMsg(ueCb, rrcContainer);
1510       if(ret == RFAILED)
1511          DU_LOG("\nERROR  -->  F1AP: Failed to fill DL-CCCH Msg at RRC SETUP");
1512    }
1513    else if(rrcMsgType == REGISTRATION_ACCEPT)
1514    {
1515       /*Hardcoded RRC Container from reference logs*/
1516       char buf[14] ={0x00, 0x03, 0x2a, 0x80, 0xaf, 0xc0, 0x08, 0x40, 0x20, 0x20, 0x00, 0x00, 0x00, 0x00};
1517       bufLen =14;
1518       rrcContainer->size = bufLen;
1519       CU_ALLOC(rrcContainer->buf, rrcContainer->size);
1520       if(rrcContainer->buf != NULLP)
1521       {
1522          memset(rrcContainer->buf, 0, bufLen);
1523          memcpy(rrcContainer->buf, buf, bufLen);
1524       }
1525       else
1526       {
1527          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure for RRC Container buffer");
1528          ret = RFAILED;
1529       }
1530    }
1531    else if(rrcMsgType == RRC_RECONFIG)
1532    {
1533       DU_LOG("\nDEBUG --> F1AP : Filling DL DCCH RRC Message ");
1534       ret = fillDlDcchRrcMsg(ueCb, rrcContainer);
1535       if(ret == RFAILED)
1536          DU_LOG("\nERROR  -->  F1AP: Failed to fill DL-DCCH Msg for RRC Reconfiguration");
1537    }
1538
1539    return ret;
1540 }
1541
1542 /*******************************************************************
1543  *
1544  * @brief Frees the DLRRCMessageTransfer
1545  *
1546  * @details
1547  *
1548  *    Function : freeDlRrcMessageTransfer
1549  *
1550  *    Functionality: Frees the DLRRCMessageTransfer
1551  *
1552  * @params[in]
1553  *
1554  * @return ROK     - success
1555  *         RFAILED - failure
1556  *
1557  * ****************************************************************/
1558 void freeDlRrcMessageTransfer(F1AP_PDU_t *f1apMsg)
1559 {
1560    uint8_t idx=0;
1561    DLRRCMessageTransfer_t  *dlRRCMsg = NULLP;
1562
1563    if(f1apMsg)
1564    {
1565       dlRRCMsg = &f1apMsg->choice.initiatingMessage->value.choice.DLRRCMessageTransfer;
1566       if(dlRRCMsg->protocolIEs.list.array)
1567       {
1568          idx = 3;
1569          CU_FREE(dlRRCMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.buf, \
1570             dlRRCMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.size);
1571          for(idx=0; idx<dlRRCMsg->protocolIEs.list.count; idx++)
1572          {
1573             CU_FREE(dlRRCMsg->protocolIEs.list.array[idx], sizeof(DLRRCMessageTransferIEs_t));
1574          }
1575          CU_FREE(dlRRCMsg->protocolIEs.list.array, dlRRCMsg->protocolIEs.list.size);
1576       }
1577       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
1578    }
1579 }
1580
1581 /*******************************************************************
1582  *
1583  * @brief Builds and sends the DLRRCMessageTransfer
1584  *
1585  * @details
1586  *
1587  *    Function : BuildAndSendDLRRCMessageTransfer
1588  *
1589  *    Functionality: Constructs the DL RRC Message Transfer and sends
1590  *                   it to the CU through SCTP.
1591  *
1592  * @params[in]
1593  *
1594  * @return ROK     - success
1595  *         RFAILED - failure
1596  *
1597  * ****************************************************************/
1598 uint8_t BuildAndSendDLRRCMessageTransfer(uint32_t duId, CuUeCb *ueCb, uint8_t srbId, uint8_t rrcMsgType)
1599 {
1600    uint8_t   elementCnt = 0;
1601    uint8_t  ieId;
1602    uint8_t  idx;
1603    F1AP_PDU_t  *f1apMsg = NULLP;
1604    DLRRCMessageTransfer_t  *dlRRCMsg = NULLP;
1605    asn_enc_rval_t   encRetVal;        /* Encoder return value */
1606
1607    DU_LOG("\nINFO  -->  F1AP : Building DL RRC Message Transfer Message\n");
1608
1609    CU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
1610    if(f1apMsg == NULLP)
1611    {
1612       DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
1613       return RFAILED;
1614    }
1615
1616    f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
1617    CU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
1618    if(f1apMsg->choice.initiatingMessage == NULLP)
1619    {
1620       DU_LOG("\nERROR  -->  F1AP : Memory allocation for  F1AP-PDU failed");
1621       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
1622       return RFAILED;
1623    }
1624
1625    f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_DLRRCMessageTransfer;
1626    f1apMsg->choice.initiatingMessage->criticality = Criticality_ignore;
1627    f1apMsg->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_DLRRCMessageTransfer;
1628    dlRRCMsg = &f1apMsg->choice.initiatingMessage->value.choice.DLRRCMessageTransfer;
1629
1630    elementCnt = 4;
1631    dlRRCMsg->protocolIEs.list.count = elementCnt;
1632    dlRRCMsg->protocolIEs.list.size = elementCnt * sizeof(DLRRCMessageTransferIEs_t *);
1633
1634    /* Initialize the F1Setup members */
1635    CU_ALLOC(dlRRCMsg->protocolIEs.list.array, dlRRCMsg->protocolIEs.list.size);
1636    if(dlRRCMsg->protocolIEs.list.array == NULLP)
1637    {
1638       DU_LOG("\nERROR  -->  F1AP : Memory allocation for DL RRC MessageTransferIEs failed");
1639       CU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
1640       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
1641       return RFAILED;
1642    }
1643
1644    for(idx=0; idx<elementCnt; idx++)
1645    {
1646       CU_ALLOC(dlRRCMsg->protocolIEs.list.array[idx], sizeof(DLRRCMessageTransferIEs_t));
1647       if(dlRRCMsg->protocolIEs.list.array[idx] == NULLP)
1648       {
1649          for(ieId=0; ieId<idx; ieId++)
1650          {
1651             CU_FREE(dlRRCMsg->protocolIEs.list.array[ieId], sizeof(DLRRCMessageTransferIEs_t));
1652          }
1653          CU_FREE(dlRRCMsg->protocolIEs.list.array, dlRRCMsg->protocolIEs.list.size);
1654          CU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
1655          CU_FREE(f1apMsg,sizeof(F1AP_PDU_t));
1656          return RFAILED;
1657       }
1658    }
1659
1660    /* GNB CU UE F1AP ID */
1661    idx = 0;
1662    dlRRCMsg->protocolIEs.list.array[idx]->id  = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
1663    dlRRCMsg->protocolIEs.list.array[idx]->criticality  = Criticality_reject;
1664    dlRRCMsg->protocolIEs.list.array[idx]->value.present = DLRRCMessageTransferIEs__value_PR_GNB_CU_UE_F1AP_ID;
1665    dlRRCMsg->protocolIEs.list.array[idx]->value.choice.GNB_CU_UE_F1AP_ID = ueCb->gnbCuUeF1apId;
1666
1667    /* GNB DU UE F1AP ID */
1668    idx++;
1669    dlRRCMsg->protocolIEs.list.array[idx]->id  = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
1670    dlRRCMsg->protocolIEs.list.array[idx]->criticality  = Criticality_reject;
1671    dlRRCMsg->protocolIEs.list.array[idx]->value.present = DLRRCMessageTransferIEs__value_PR_GNB_DU_UE_F1AP_ID;
1672    dlRRCMsg->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID = ueCb->gnbDuUeF1apId;;
1673
1674    /* SRBID */
1675    idx++;
1676    dlRRCMsg->protocolIEs.list.array[idx]->id  = ProtocolIE_ID_id_SRBID;
1677    dlRRCMsg->protocolIEs.list.array[idx]->criticality  = Criticality_reject;
1678    dlRRCMsg->protocolIEs.list.array[idx]->value.present = 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 = DLRRCMessageTransferIEs__value_PR_RRCContainer;
1686    BuildDLRRCContainer(ueCb, rrcMsgType, &dlRRCMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer);
1687
1688    xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
1689
1690    /* Encode the F1SetupRequest type as APER */
1691    memset(encBuf, 0, ENC_BUF_MAX_LEN);
1692    encBufSize = 0;
1693    encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
1694          encBuf);
1695    /* Encode results */
1696    if(encRetVal.encoded == ENCODE_FAIL)
1697    {
1698       DU_LOG( "\nERROR  -->  F1AP : Could not encode DL RRC Message Transfer structure (at %s)\n",\
1699             encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
1700       return RFAILED;
1701    }
1702    else
1703    {
1704       DU_LOG("\nDEBUG  -->  F1AP : Created APER encoded buffer for DL RRC Message transfer\n");
1705       for(int i=0; i< encBufSize; i++)
1706       {
1707          DU_LOG("%x",encBuf[i]);
1708       }
1709    }
1710
1711    /* Sending  msg  */
1712    if(SendF1APMsg(CU_APP_MEM_REG,CU_POOL, duId)  !=  ROK)
1713    {
1714       DU_LOG("\nERROR  -->  F1AP : Sending  DL RRC Message Transfer Failed");
1715       return RFAILED;
1716    }
1717    freeDlRrcMessageTransfer(f1apMsg);
1718    return ROK;
1719 }/* End of BuildAndSendDLRRCMessageTransfer */
1720
1721 /*******************************************************************
1722  *
1723  * @brief Function to set the Dl RRC Msg Type
1724  *
1725  * @details
1726  *
1727  *    Function : setDlRRCMsgType
1728  *
1729  *    Functionality: Constructs the UE Setup Response and sends
1730  *                   it to the DU through SCTP.
1731  *
1732  * @params[in]
1733  *
1734  * @return ROK     - success
1735  *         RFAILED - failure
1736  *
1737  * ****************************************************************/
1738
1739 uint8_t setDlRRCMsgType(CuUeCb *ueCb)
1740 {
1741    uint8_t rrcMsgType = 0;
1742    switch(ueCb->f1apMsgDb.dlRrcMsgCount)
1743    {
1744       case RRC_SETUP:
1745          rrcMsgType = RRC_SETUP;
1746          break;
1747       case REGISTRATION_ACCEPT:
1748          rrcMsgType = REGISTRATION_ACCEPT;
1749          break;
1750       case UE_CONTEXT_SETUP_REQ:
1751          rrcMsgType = UE_CONTEXT_SETUP_REQ;
1752          break;
1753       case SECURITY_MODE_COMPLETE:
1754          rrcMsgType = SECURITY_MODE_COMPLETE;
1755          break;
1756       case RRC_RECONFIG:
1757          rrcMsgType = RRC_RECONFIG;
1758          break;
1759       case RRC_RECONFIG_COMPLETE:
1760          rrcMsgType = RRC_RECONFIG_COMPLETE;
1761          break;
1762       case UE_CONTEXT_MOD_REQ:
1763          rrcMsgType = UE_CONTEXT_MOD_REQ;
1764          break;
1765       default:
1766          break;
1767    }
1768    return rrcMsgType;
1769 }
1770
1771 /*******************************************************************
1772  *
1773  * @brief Extract configuration from CellGroupConfig
1774  *
1775  * @details
1776  *
1777  *    Function : extractCellGroupConfig
1778  *
1779  *    Functionality: Extract configuration from CellGroupConfig
1780  *        and store in local database
1781  *
1782  * @params[in] UE control block
1783  *             Cell Group Config
1784  *
1785  * @return ROK     - success
1786  *         RFAILED - failure
1787  *
1788  * ****************************************************************/
1789 uint8_t extractCellGroupConfig(CuUeCb *ueCb, CellGroupConfigRrc_t *cellGrpCfg)
1790 {
1791    uint8_t rbIdx, srbIdx, drbIdx;
1792    bool    srbFound, drbFound;
1793    SrbInfo *srbCfgDb = NULLP;
1794    DrbInfo *drbCfgDb = NULLP;
1795    RlcLcCfg *rlcLcCfgDb = NULLP;
1796    MacLcCfg *macLcCfgDb = NULLP;
1797    RLC_BearerConfig_t *rlcCfg = NULLP;
1798    RLC_Config_t *rlcLcCfg = NULLP;
1799    LogicalChannelConfig_t *macLcCfg = NULLP;
1800
1801    if(ueCb == NULLP)
1802    {
1803       DU_LOG("\nERROR  -->  F1AP: extractCellGroupConfig(): UE Cb is NULL");
1804       return RFAILED;
1805    }
1806
1807    if(cellGrpCfg == NULLP)
1808    {
1809       DU_LOG("\nERROR  -->  F1AP: extractCellGroupConfig(): cellGrpCfg is NULL");
1810       return RFAILED;
1811    }
1812
1813    for(rbIdx = 0; rbIdx < cellGrpCfg->rlc_BearerToAddModList->list.count; rbIdx++)
1814    {
1815       srbFound = false;
1816       drbFound = false;
1817
1818       rlcCfg = cellGrpCfg->rlc_BearerToAddModList->list.array[rbIdx];
1819
1820       /* Update SRB configuration in local DB */
1821       if(rlcCfg->servedRadioBearer->present == RLC_BearerConfig__servedRadioBearer_PR_srb_Identity)
1822       {
1823          /* Search if SRB entry is already present in DB */
1824          for(srbIdx = 0; srbIdx < ueCb->numSrb; srbIdx++)
1825          {
1826             if(ueCb->srbList[srbIdx].srbId == rlcCfg->servedRadioBearer->choice.srb_Identity)
1827             {
1828               srbCfgDb = &ueCb->srbList[srbIdx];
1829               srbFound = true;
1830               break;
1831             }
1832          }
1833
1834          /* If not, add SRB to UE CB's SRB list */
1835          if(!srbFound)
1836          {
1837             ueCb->srbList[ueCb->numSrb].srbId = rlcCfg->servedRadioBearer->choice.srb_Identity;
1838             srbCfgDb = &ueCb->srbList[ueCb->numSrb];
1839             ueCb->numSrb++;
1840          }
1841
1842          srbCfgDb->lcId = rlcCfg->logicalChannelIdentity;
1843          srbCfgDb->cfgSentToUe = false;
1844          rlcLcCfgDb = &srbCfgDb->rlcLcCfg;
1845          macLcCfgDb = &srbCfgDb->macLcCfg;
1846       }
1847
1848       /* Update DRB configuration in local DB */
1849       if(rlcCfg->servedRadioBearer->present == RLC_BearerConfig__servedRadioBearer_PR_drb_Identity)
1850       {
1851          /* Search if DRB entry is already present in DB */
1852          for(drbIdx = 0; drbIdx < ueCb->numDrb; drbIdx++)
1853          {
1854             if(ueCb->drbList[drbIdx].drbId == rlcCfg->servedRadioBearer->choice.drb_Identity)
1855             {
1856               drbCfgDb = &ueCb->drbList[drbIdx];
1857               drbFound = true;
1858               break;
1859             }
1860          }
1861
1862          /* If not, add DRB to UE CB's SRB list */
1863          if(!drbFound)
1864          {
1865             ueCb->drbList[ueCb->numDrb].drbId = rlcCfg->servedRadioBearer->choice.drb_Identity;
1866             drbCfgDb = &ueCb->drbList[ueCb->numDrb];
1867             ueCb->numDrb++;
1868          }
1869
1870          drbCfgDb->lcId = rlcCfg->logicalChannelIdentity;
1871          drbCfgDb->cfgSentToUe = false;
1872          rlcLcCfgDb = &drbCfgDb->rlcLcCfg;
1873          macLcCfgDb = &drbCfgDb->macLcCfg;
1874       }
1875
1876
1877       /* Update RLC configuration for this RB */
1878       rlcLcCfg = rlcCfg->rlc_Config;
1879       rlcLcCfgDb->rlcMode = rlcLcCfg->present;
1880       switch(rlcLcCfgDb->rlcMode)
1881       {
1882          case RLC_Config_PR_am:
1883             {
1884                rlcLcCfgDb->u.amCfg.ulAmCfg.snLenUl = *(rlcLcCfg->choice.am->ul_AM_RLC.sn_FieldLength);
1885                rlcLcCfgDb->u.amCfg.ulAmCfg.pollRetxTmr = rlcLcCfg->choice.am->ul_AM_RLC.t_PollRetransmit ;
1886                rlcLcCfgDb->u.amCfg.ulAmCfg.pollPdu = rlcLcCfg->choice.am->ul_AM_RLC.pollPDU ;
1887                rlcLcCfgDb->u.amCfg.ulAmCfg.pollByte = rlcLcCfg->choice.am->ul_AM_RLC.pollByte ;
1888                rlcLcCfgDb->u.amCfg.ulAmCfg.maxRetxTh = rlcLcCfg->choice.am->ul_AM_RLC.maxRetxThreshold ;
1889
1890                rlcLcCfgDb->u.amCfg.dlAmCfg.snLenDl = *(rlcLcCfg->choice.am->dl_AM_RLC.sn_FieldLength);
1891                rlcLcCfgDb->u.amCfg.dlAmCfg.reAssemTmr = rlcLcCfg->choice.am->dl_AM_RLC.t_Reassembly;
1892                rlcLcCfgDb->u.amCfg.dlAmCfg.statProhTmr = rlcLcCfg->choice.am->dl_AM_RLC.t_StatusProhibit;
1893                break;
1894             }
1895
1896          case RLC_Config_PR_um_Bi_Directional:
1897             {
1898                rlcLcCfgDb->u.umBiDirCfg.ulUmCfg.snLenUlUm = *(rlcLcCfg->choice.um_Bi_Directional->ul_UM_RLC.sn_FieldLength);
1899
1900                rlcLcCfgDb->u.umBiDirCfg.dlUmCfg.snLenDlUm = *(rlcLcCfg->choice.um_Bi_Directional->dl_UM_RLC.sn_FieldLength);
1901                rlcLcCfgDb->u.umBiDirCfg.dlUmCfg.reAssemTmr = rlcLcCfg->choice.um_Bi_Directional->dl_UM_RLC.t_Reassembly;
1902                break;
1903             }
1904       }
1905
1906       /* Update MAC configuration for this LC */
1907       macLcCfg = rlcCfg->mac_LogicalChannelConfig;
1908       macLcCfgDb->priority = macLcCfg->ul_SpecificParameters->priority ;
1909       macLcCfgDb->lcGroup = *(macLcCfg->ul_SpecificParameters->logicalChannelGroup) ;
1910       macLcCfgDb->schReqId = *(macLcCfg->ul_SpecificParameters->schedulingRequestID) ;
1911       macLcCfgDb->pbr = macLcCfg->ul_SpecificParameters->prioritisedBitRate ;
1912       macLcCfgDb->bsd = macLcCfg->ul_SpecificParameters->bucketSizeDuration ;
1913    }
1914    return ROK;
1915 }
1916
1917 /*******************************************************************
1918  *
1919  * @brief Function to decode DU to CU RRC container
1920  *
1921  * @details
1922  *
1923  *    Function : extractDuToCuRrcCont
1924  *
1925  *    Functionality: Function to decode DU to CU RRC container
1926  *
1927  * @params[in] UE Cb
1928  *             RRC conatiner octect string to be decoded
1929  *
1930  * @return ROK     - success
1931  *         RFAILED - failure
1932  *
1933  * ****************************************************************/
1934 uint8_t extractDuToCuRrcCont(CuUeCb *ueCb, OCTET_STRING_t rrcCont)
1935 {
1936    CellGroupConfigRrc_t  cellGrpCfg, *cellGrpCfgMsg = NULLP;
1937    asn_dec_rval_t rval; /* Decoder return value */
1938
1939    /* Copy the received container to UeCb */
1940    memcpy(&ueCb->f1apMsgDb.duToCuContainer, &rrcCont, sizeof(OCTET_STRING_t));
1941
1942    /* Decoding DU to CU RRC container octet string to cell group config */
1943    cellGrpCfgMsg = &cellGrpCfg;
1944    memset(cellGrpCfgMsg, 0, sizeof(CellGroupConfigRrc_t));
1945
1946    rval = aper_decode(0, &asn_DEF_CellGroupConfigRrc, (void **)&cellGrpCfgMsg, rrcCont.buf, rrcCont.size, 0, 0);
1947
1948    if(rval.code == RC_FAIL || rval.code == RC_WMORE)
1949    {
1950       DU_LOG("\nERROR  -->  F1AP : ASN decode failed");
1951       return RFAILED;
1952    }
1953    printf("\n");
1954    xer_fprint(stdout, &asn_DEF_CellGroupConfigRrc, cellGrpCfgMsg);
1955
1956    if((extractCellGroupConfig(ueCb, cellGrpCfgMsg)) != ROK)
1957    {
1958       DU_LOG("\nERROR  -->  F1AP : Failed to extract cell group config");
1959       return RFAILED;
1960    }
1961
1962    return ROK;
1963 }
1964
1965 /*******************************************************************
1966  *
1967  * @brief Function to build Initial UL RRC Message
1968  *
1969  * @details
1970  *
1971  *    Function : procInitULRRCMsg
1972  *
1973  *    Functionality: Function to build Initial UL RRC Message
1974  *
1975  * @params[in]
1976  *
1977  * @return ROK     - success
1978  *         RFAILED - failure
1979  *
1980  * ****************************************************************/
1981
1982 uint8_t procInitULRRCMsg(uint32_t duId, F1AP_PDU_t *f1apMsg)
1983 {
1984    uint8_t idx = 0, duIdx=0, rrcMsgType=0, gnbDuUeF1apId=0;
1985    uint8_t ret =ROK;
1986    uint16_t cellIdx=0, nrCellId = 0;
1987    uint32_t crnti;
1988    DuDb     *duDb;
1989    CuCellCb *cellCb;
1990    CuUeCb   *ueCb;
1991    InitialULRRCMessageTransfer_t *initULRRCMsg = NULLP;
1992
1993    DU_LOG("\nINFO   -->  F1AP : filling the required values in DB in procInitULRRCMsg");
1994
1995    SEARCH_DU_DB(duIdx, duId, duDb);
1996    initULRRCMsg = &f1apMsg->choice.initiatingMessage->value.choice.InitialULRRCMessageTransfer;
1997
1998    for(idx=0; idx < initULRRCMsg->protocolIEs.list.count; idx++)
1999    {
2000       switch(initULRRCMsg->protocolIEs.list.array[idx]->id)
2001       {
2002          case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
2003             gnbDuUeF1apId = initULRRCMsg->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID;
2004             break;
2005
2006          case ProtocolIE_ID_id_NRCGI:
2007             bitStringToInt(&initULRRCMsg->protocolIEs.list.array[idx]->value.choice.NRCGI.nRCellIdentity, &nrCellId);
2008             SEARCH_CELL_DB(cellIdx, duDb, nrCellId, cellCb);
2009             if(cellCb == NULLP)
2010                return RFAILED;
2011             break;
2012
2013          case ProtocolIE_ID_id_C_RNTI:
2014             crnti = initULRRCMsg->protocolIEs.list.array[idx]->value.choice.C_RNTI;
2015             if(duDb->ueCb[gnbDuUeF1apId-1].gnbDuUeF1apId == 0)
2016             {
2017                ueCb = &duDb->ueCb[gnbDuUeF1apId-1];
2018                memset(ueCb, 0, sizeof(CuUeCb));
2019                ueCb->cellCb = cellCb;
2020                ueCb->crnti = crnti;
2021                ueCb->gnbDuUeF1apId = gnbDuUeF1apId;
2022                ueCb->gnbCuUeF1apId = ++cuCb.gnbCuUeF1apIdGenerator;
2023                ueCb->state = UE_ATTACH_IN_PROGRESS;
2024                (duDb->numUe)++;
2025
2026                cellCb->ueCb[cellCb->numUe] = ueCb;
2027                cellCb->numUe++;
2028             }
2029             break;
2030
2031          case ProtocolIE_ID_id_RRCContainer:
2032             break;
2033
2034          case ProtocolIE_ID_id_DUtoCURRCContainer:
2035             {
2036                if((initULRRCMsg->protocolIEs.list.array[idx]->value.choice.DUtoCURRCContainer.size > 0) && \
2037                   (initULRRCMsg->protocolIEs.list.array[idx]->value.choice.DUtoCURRCContainer.buf != NULLP))
2038                {
2039                   DU_LOG("\nINFO  -->  Received Du to Cu RRC Container ");
2040                   ueCb->f1apMsgDb.duToCuContainer.size = initULRRCMsg->protocolIEs.list.array[idx]->value.choice.DUtoCURRCContainer.size;
2041                   CU_ALLOC(ueCb->f1apMsgDb.duToCuContainer.buf, ueCb->f1apMsgDb.duToCuContainer.size);
2042                   if(ueCb->f1apMsgDb.duToCuContainer.buf != NULLP)
2043                   {
2044                      memcpy(ueCb->f1apMsgDb.duToCuContainer.buf, \
2045                         initULRRCMsg->protocolIEs.list.array[idx]->value.choice.DUtoCURRCContainer.buf, \
2046                         ueCb->f1apMsgDb.duToCuContainer.size);
2047                   }
2048                   if((extractDuToCuRrcCont(ueCb, initULRRCMsg->protocolIEs.list.array[idx]->value.choice.DUtoCURRCContainer)) != ROK)
2049                   {
2050                      DU_LOG("\nERROR  --> F1AP : Failed to extract DU to CU RRC Container ");
2051                      ret = RFAILED;
2052                   }
2053                }
2054                else
2055                {
2056                   DU_LOG("\nERROR  -->  Failed to receive Du to Cu RRC Container ");
2057                   ret = RFAILED;
2058                }
2059                break;
2060             }
2061
2062          default:
2063             DU_LOG("\nERROR  -->  Invalid Event %ld", initULRRCMsg->protocolIEs.list.array[idx]->id);
2064             break;
2065       }
2066       if(ret == RFAILED)
2067          break;
2068    }
2069
2070    if(ret == ROK)
2071    {
2072       ueCb->f1apMsgDb.dlRrcMsgCount++;
2073       rrcMsgType = setDlRRCMsgType(ueCb);
2074       ret = BuildAndSendDLRRCMessageTransfer(duId, ueCb, SRB0, rrcMsgType);
2075    }
2076    return ret;
2077 }
2078
2079 /*******************************************************************
2080  *
2081  * @brief Builds Nrcgi
2082  *
2083  * @details
2084  *
2085  *    Function : BuildNrcgi
2086  *
2087  *    Functionality: Building the PLMN ID and NR Cell id
2088  *
2089  * @params[in] NRCGI_t *nrcgi
2090  * @return ROK     - success
2091  *         RFAILED - failure
2092  *
2093  * ****************************************************************/
2094 uint8_t BuildNrcgi(NRCGI_t *nrcgi, uint32_t nrCellId)
2095 {
2096    uint8_t ret;
2097    uint8_t unused_bits = 4;
2098    uint8_t byteSize = 5;
2099
2100    /* Allocate Buffer Memory */
2101    nrcgi->pLMN_Identity.size = 3 * sizeof(uint8_t);
2102    CU_ALLOC(nrcgi->pLMN_Identity.buf, nrcgi->pLMN_Identity.size);
2103    if(nrcgi->pLMN_Identity.buf == NULLP)
2104    {
2105       return RFAILED;
2106    }
2107    ret = buildPlmnId(cuCb.cuCfgParams.plmn , nrcgi->pLMN_Identity.buf);
2108
2109    if(ret != ROK)
2110    {
2111       return RFAILED;
2112    }
2113    nrcgi->nRCellIdentity.size = byteSize * sizeof(uint8_t);
2114    CU_ALLOC(nrcgi->nRCellIdentity.buf, nrcgi->nRCellIdentity.size);
2115    if(nrcgi->nRCellIdentity.buf == NULLP)
2116    {
2117       return RFAILED;
2118    }
2119    fillBitString(&nrcgi->nRCellIdentity, unused_bits, byteSize, nrCellId);
2120
2121    return ROK;
2122 }
2123 /*******************************************************************
2124  *
2125  * @brief Builds Special cell list for UE Setup Request
2126  *
2127  * @details
2128  *
2129  *    Function : BuildSplCellList
2130  *
2131  *    Functionality: Constructs the Special Cell list for UESetReq
2132  *
2133  * @params[in] SCell_ToBeSetup_List_t *spCellLst
2134  *
2135  * @return ROK     - success
2136  *         RFAILED - failure
2137  *
2138  * ****************************************************************/
2139 uint8_t BuildSplCellList(CuUeCb *ueCb, SCell_ToBeSetup_List_t *spCellLst)
2140 {
2141    uint8_t  cellCnt;
2142    uint8_t  idx;
2143    uint8_t  ret;
2144    cellCnt = 1;
2145    spCellLst->list.count = cellCnt;
2146    spCellLst->list.size = cellCnt * sizeof(SCell_ToBeSetup_ItemIEs_t *);
2147    CU_ALLOC(spCellLst->list.array,spCellLst->list.size);
2148    if(spCellLst->list.array == NULLP)
2149    {
2150       return RFAILED;
2151    }
2152    for(idx=0; idx<cellCnt; idx++)
2153    {
2154       CU_ALLOC(spCellLst->list.array[idx],sizeof(SCell_ToBeSetup_ItemIEs_t));
2155       if(spCellLst->list.array[idx] == NULLP)
2156       {
2157          return RFAILED;
2158       }
2159    }
2160    idx = 0;
2161    spCellLst->list.array[idx]->id = ProtocolIE_ID_id_SCell_ToBeSetup_Item;
2162    spCellLst->list.array[idx]->criticality = Criticality_ignore;
2163    spCellLst->list.array[idx]->value.present = SCell_ToBeSetup_ItemIEs__value_PR_SCell_ToBeSetup_Item;
2164
2165    /* Special Cell ID -NRCGI */
2166    ret = BuildNrcgi(&spCellLst->list.array[idx]->value.choice.SCell_ToBeSetup_Item.sCell_ID, ueCb->cellCb->nrCellId);
2167    if(ret != ROK)
2168    {
2169       return RFAILED;
2170    }
2171    /*Special Cell Index*/
2172    spCellLst->list.array[idx]->value.choice.SCell_ToBeSetup_Item.sCellIndex = 1;
2173    return ROK;
2174 }/* End of BuildSplCellList*/
2175
2176 /*******************************************************************
2177  *
2178  * @brief Builds SRBS to be setup
2179  *
2180  * @details
2181  *
2182  *    Function : BuildSRBSetup
2183  *
2184  *    Functionality: Constructs the SRB's for UESetReq
2185  *
2186  * @params[in] SRBs_ToBeSetup_List_t *srbSet
2187  *
2188  * @return ROK     - success
2189  *         RFAILED - failure
2190  *
2191  * ****************************************************************/
2192 uint8_t BuildSRBSetup(CuUeCb *ueCb, SRBs_ToBeSetup_List_t *srbSet)
2193 {
2194    uint8_t idx;
2195    uint8_t srbCnt;
2196
2197    if(ueCb->state == UE_HANDOVER_IN_PROGRESS)
2198       srbCnt = ueCb->numSrb;
2199    else
2200       srbCnt = 1;
2201    srbSet->list.count = srbCnt;
2202    srbSet->list.size = srbCnt*sizeof(SRBs_ToBeSetup_ItemIEs_t *);
2203    CU_ALLOC(srbSet->list.array,srbSet->list.size);
2204    if(srbSet->list.array == NULLP)
2205    {
2206       DU_LOG("\nERROR  --> F1AP : BuildSRBSetup() : Memory allocation failed for SRB to be setup list's array");
2207       return RFAILED;
2208    }
2209
2210    for(idx=0; idx<srbCnt; idx++)
2211    {
2212       CU_ALLOC(srbSet->list.array[idx],sizeof(SRBs_ToBeSetup_ItemIEs_t));
2213       if(srbSet->list.array[idx] == NULLP)
2214       {
2215          DU_LOG("\nERROR  --> F1AP : BuildSRBSetup() : Memory allocation failed for SRB to be setup list's array element");
2216          return RFAILED;
2217       }
2218    }
2219
2220    if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
2221    {
2222       idx = 0;
2223       srbSet->list.array[idx]->id = ProtocolIE_ID_id_SRBs_ToBeSetup_Item;
2224       srbSet->list.array[idx]->criticality = Criticality_ignore;
2225       srbSet->list.array[idx]->value.present = SRBs_ToBeSetup_ItemIEs__value_PR_SRBs_ToBeSetup_Item;
2226       srbSet->list.array[idx]->value.choice.SRBs_ToBeSetup_Item.sRBID = 2;
2227       ueCb->srbList[ueCb->numSrb].srbId = srbSet->list.array[idx]->value.choice.SRBs_ToBeSetup_Item.sRBID;
2228       ueCb->numSrb++;
2229    }
2230    else
2231    {
2232       for(idx=0; idx<srbCnt; idx++)
2233       {
2234          srbSet->list.array[idx]->id = ProtocolIE_ID_id_SRBs_ToBeSetup_Item;
2235          srbSet->list.array[idx]->criticality = Criticality_ignore;
2236          srbSet->list.array[idx]->value.present = SRBs_ToBeSetup_ItemIEs__value_PR_SRBs_ToBeSetup_Item;
2237          srbSet->list.array[idx]->value.choice.SRBs_ToBeSetup_Item.sRBID = ueCb->srbList[idx].srbId;
2238       }
2239    }
2240    return ROK;
2241 }/* End of BuildSRBSetup*/
2242
2243 /*******************************************************************
2244  *
2245  * @brief Builds QOS Info for DRB Setum Item
2246  *
2247  * @details
2248  *
2249  *    Function : BuildQOSInfo
2250  *
2251  *    Functionality: Constructs the QOS Info for DRB Setup Item
2252  *
2253  * @params[in] QoSInformation_t *qosinfo
2254  *             int16_t pduSessionID
2255  *
2256  * @return ROK     - success
2257  *         RFAILED - failure
2258  *
2259  * ****************************************************************/
2260 uint8_t BuildQOSInfo(QosInfo *qosInfo, QoSFlowLevelQoSParameters_t *drbQos, uint8_t actionType, int16_t pduSessionID, bool hoInProgress)
2261 {
2262    uint8_t elementCnt = 0, qosCntIdx = 0;
2263    ProtocolExtensionContainer_4624P74_t *qosIeExt = NULLP;
2264
2265    /* NonDynamic5QIDescriptor */
2266    drbQos->qoS_Characteristics.present = QoS_Characteristics_PR_non_Dynamic_5QI;
2267    CU_ALLOC(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI,sizeof(NonDynamic5QIDescriptor_t));
2268    if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI == NULLP)
2269    {
2270       return RFAILED;
2271    }
2272
2273    if(hoInProgress)
2274       drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->fiveQI = qosInfo->nonDynFiveQI ;
2275    else
2276    {
2277       /*FiveQI*/
2278       if(actionType == ProtocolIE_ID_id_DRBs_ToBeModified_Item)
2279          drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->fiveQI = FIVE_QI_VALUE8;
2280       else
2281          drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->fiveQI = FIVE_QI_VALUE9;
2282
2283       qosInfo->nonDynFiveQI = drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->fiveQI;
2284    }
2285
2286    if(!hoInProgress)
2287    {
2288       /*AveragingWindow*/
2289       CU_ALLOC(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow, sizeof(AveragingWindow_t));
2290       if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow == NULLP)
2291       {
2292          return RFAILED;
2293       }
2294       *(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow) = 0;
2295       qosInfo->avgWindow = *(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow);
2296
2297       /*MaxDataBurstVolume*/
2298       CU_ALLOC(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume, sizeof(MaxDataBurstVolume_t));
2299       if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume == NULLP)
2300       {
2301          return RFAILED;
2302       }
2303       *(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume) = 0;
2304       qosInfo->maxBurstDataVol = *(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume);
2305    }
2306
2307    /*nRGRAN Allocation Retention Priority*/
2308    if(hoInProgress)
2309    {
2310       drbQos->nGRANallocationRetentionPriority.priorityLevel = qosInfo->priorityLevel;
2311       drbQos->nGRANallocationRetentionPriority.pre_emptionCapability = qosInfo->preemptionCapability;
2312       drbQos->nGRANallocationRetentionPriority.pre_emptionVulnerability = qosInfo->preemptionVulnerability;
2313    }
2314    else
2315    {
2316       drbQos->nGRANallocationRetentionPriority.priorityLevel = PriorityLevel_lowest;
2317       drbQos->nGRANallocationRetentionPriority.pre_emptionCapability = Pre_emptionCapability_may_trigger_pre_emption;
2318       drbQos->nGRANallocationRetentionPriority.pre_emptionVulnerability = Pre_emptionVulnerability_not_pre_emptable;
2319
2320       qosInfo->priorityLevel = PriorityLevel_lowest;
2321       qosInfo->preemptionCapability = Pre_emptionCapability_may_trigger_pre_emption;
2322       qosInfo->preemptionVulnerability = Pre_emptionVulnerability_not_pre_emptable;
2323    }
2324
2325    /* PDU session ID */
2326    if(!hoInProgress)
2327    {
2328       /*If PDU Session ID is INVALID thus not to be included in Qos IE, skip the PDU Session IE */
2329       if(pduSessionID <= INVALID_PDU_SESSION_ID)
2330       {
2331          DU_LOG("\nINFO  --> F1AP : Invalid PDU_SESSION_ID");
2332          return ROK;
2333       }
2334
2335       CU_ALLOC(drbQos->iE_Extensions, sizeof(ProtocolExtensionContainer_4624P74_t));
2336       qosIeExt = (ProtocolExtensionContainer_4624P74_t *)drbQos->iE_Extensions;
2337
2338       if(qosIeExt)
2339       {
2340          elementCnt = NUM_QOS_EXT;
2341          qosIeExt->list.count = elementCnt;
2342          qosIeExt->list.size = elementCnt * sizeof(QoSFlowLevelQoSParameters_ExtIEs_t *);
2343
2344          /*Initialize QoSFlowLevelQoSParameters_ExtIEs_t*/
2345          CU_ALLOC(qosIeExt->list.array, qosIeExt->list.size);
2346
2347          if(qosIeExt->list.array == NULLP)
2348          {
2349             DU_LOG("\nERROR  -->        F1AP : Memory allocation for QoSFlowLevelQoSParameters_ExtIEs_t failed");
2350             return  RFAILED;
2351          }
2352
2353          for(qosCntIdx=0; qosCntIdx < elementCnt; qosCntIdx++)
2354          {
2355             CU_ALLOC(qosIeExt->list.array[qosCntIdx], sizeof(QoSFlowLevelQoSParameters_ExtIEs_t));
2356             if(qosIeExt->list.array[qosCntIdx] == NULLP)
2357             {
2358                DU_LOG("\nERROR  -->     F1AP : Memory allocation for QoSFlowLevelQoSParameters_ExtIEs_t array failed");
2359                return  RFAILED;
2360             }
2361             /*Filling QoSFlowLevelQoSParameters_ExtIEs_t*/
2362             qosIeExt->list.array[qosCntIdx]->id = ProtocolIE_ID_id_PDUSessionID;
2363             /*Below Criticality mentioned in Spec38.473, 15.4.1 and later*/
2364             qosIeExt->list.array[qosCntIdx]->criticality = Criticality_ignore;
2365             qosIeExt->list.array[qosCntIdx]->extensionValue.present = \
2366                                                                       QoSFlowLevelQoSParameters_ExtIEs__extensionValue_PR_PDUSessionID;
2367             qosIeExt->list.array[qosCntIdx]->extensionValue.choice.PDUSessionID = (PDUSessionID_t)pduSessionID;
2368             qosInfo->pduSessionId = pduSessionID;
2369          }
2370       }
2371       else
2372       {
2373          DU_LOG("\nERROR  -->   F1AP : Memory allocation for QosIE_extension failed");
2374          return RFAILED;
2375       }
2376    }
2377    return ROK;
2378 }/*End of BuildQOSInfo*/
2379
2380 /*******************************************************************
2381  *
2382  * @brief Builds SNSSAI
2383  *
2384  * @details
2385  *
2386  *    Function : BuildSNSSAI
2387  *
2388  *    Functionality: Constructs the SNSSAI For DRB list
2389  *
2390  * @params[in] SNSSAI_t *snssai
2391  *             Snssai  *snssaiToCopy S-NSSAI from CuCfgParam to be copied
2392  *
2393  * @return ROK     - success
2394  *         RFAILED - failure
2395  *
2396  * ****************************************************************/
2397 uint8_t BuildSNSSAI(DrbInfo *drbInfo, SNSSAI_t *snssai, Snssai *snssaiToCopy, bool hoInProgress)
2398 {
2399    /*SNSSAI*/
2400    /*ssT*/
2401    snssai->sST.size = sizeof(uint8_t);
2402    CU_ALLOC(snssai->sST.buf, snssai->sST.size);
2403    if(snssai->sST.buf == NULLP)
2404    {
2405       return RFAILED;
2406    }
2407    if(!hoInProgress)
2408       memcpy(snssai->sST.buf, &snssaiToCopy->sst, snssai->sST.size);
2409    else
2410       memcpy(snssai->sST.buf, &drbInfo->snssai->sst, snssai->sST.size);
2411
2412    /*sD*/
2413    CU_ALLOC(snssai->sD, sizeof(OCTET_STRING_t));
2414    if(snssai->sD == NULLP)
2415    {
2416       return RFAILED;
2417    }
2418    snssai->sD->size = 3 * sizeof(uint8_t);
2419    CU_ALLOC(snssai->sD->buf, snssai->sD->size);
2420    if(snssai->sD->buf == NULLP)
2421    {
2422       return RFAILED;
2423    }
2424    if(!hoInProgress)
2425       memcpy(snssai->sD->buf, snssaiToCopy->sd, snssai->sD->size);
2426    else
2427       memcpy(snssai->sD->buf, drbInfo->snssai->sd, snssai->sD->size);
2428
2429    if(!hoInProgress)
2430       drbInfo->snssai = snssaiToCopy;
2431    return ROK;
2432 }/*End of BuildSNSSAI*/
2433
2434 /*******************************************************************
2435  *
2436  * @brief Builds the flow map.
2437  *
2438  * @details
2439  *
2440  *    Function : BuildFlowsMap
2441  *
2442  *    Functionality: Constructs the flowmap For DRB list
2443  *
2444  * @params[in] Flows_Mapped_To_DRB_List_t *flowMap
2445  *
2446  * @return ROK     - success
2447  *         RFAILED - failure
2448  *
2449  * ****************************************************************/
2450 uint8_t BuildFlowsMap(DrbInfo *drbInfo, Flows_Mapped_To_DRB_List_t *flowMap , uint8_t actionType, bool hoInProgress)
2451 {
2452    uint8_t  ret = ROK, idx = 0, flowCnt = 0, flowIdx = 0;
2453    FlowsMapped *qosFlow;
2454
2455    if(!hoInProgress)
2456       flowCnt = 1;
2457    else
2458       flowCnt = drbInfo->numFlowMap;
2459    flowMap->list.count = flowCnt;
2460    flowMap->list.size = flowCnt * sizeof(Flows_Mapped_To_DRB_Item_t *);
2461    CU_ALLOC(flowMap->list.array,flowMap->list.size);
2462    if(flowMap->list.array == NULLP)
2463    {
2464       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed for array in BuildFlowsMap()");
2465       return RFAILED;
2466    }
2467    for(idx=0; idx<flowCnt; idx++)
2468    {
2469       CU_ALLOC(flowMap->list.array[idx],sizeof(Flows_Mapped_To_DRB_Item_t));
2470       if(flowMap->list.array[idx] == NULLP)
2471       {
2472          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed for arrayIdx[%d] in BuildFlowsMap()", idx);
2473          return RFAILED;
2474       }
2475
2476       if(!hoInProgress)
2477       {
2478          flowMap->list.array[idx]->qoSFlowIdentifier = 0;
2479          if(actionType == ProtocolIE_ID_id_DRBs_ToBeModified_Item)
2480          {
2481             for(flowIdx =0; flowIdx < drbInfo->numFlowMap; flowIdx++)
2482             {
2483                if(drbInfo->flowMapList[flowIdx].qosFlowId == flowMap->list.array[idx]->qoSFlowIdentifier)
2484                {
2485                   qosFlow = &drbInfo->flowMapList[flowIdx];
2486                   break;
2487                }
2488             }
2489          }
2490          else
2491          {
2492             qosFlow = &drbInfo->flowMapList[drbInfo->numFlowMap];
2493             qosFlow->qosFlowId = flowMap->list.array[idx]->qoSFlowIdentifier;
2494          }
2495       }
2496       else
2497       {
2498          qosFlow = &drbInfo->flowMapList[idx];
2499          flowMap->list.array[idx]->qoSFlowIdentifier = qosFlow->qosFlowId;
2500       }
2501
2502       ret = BuildQOSInfo(&qosFlow->qos, &flowMap->list.array[idx]->qoSFlowLevelQoSParameters,\
2503             actionType, INVALID_PDU_SESSION_ID, hoInProgress);
2504       if(ret != ROK)
2505       {
2506          DU_LOG("\nERROR  -->  F1AP : Failed to Build QOS Info in BuildFlowsMap()");
2507          return RFAILED;
2508       }
2509
2510       if((!hoInProgress) && (actionType != ProtocolIE_ID_id_DRBs_ToBeModified_Item))
2511          drbInfo->numFlowMap++;
2512    }
2513    return ROK;
2514 }/*End of BuildFlowsMap*/
2515
2516 /*******************************************************************
2517  *
2518  * @brief Builds the Uplink Tunnel Info
2519  *
2520  * @details
2521  *
2522  *    Function : BuildULTnlInfo
2523  *
2524  *    Functionality: Constructs the UL TnlInfo For DRB list
2525  *
2526  * @params[in]  UPTNLInformation_ToBeSetup_List_t *ulInfo
2527  *
2528  * @return ROK     - success
2529  *         RFAILED - failure
2530  *
2531  * ****************************************************************/
2532 uint8_t BuildULTnlInfo(uint8_t duId, TnlInfo *ulUpTnlInfo, ULUPTNLInformation_ToBeSetup_List_t *ulInfo, bool hoInProgress)
2533 {
2534    uint8_t idx;
2535    uint8_t ulCnt;
2536
2537    ulCnt = 1;
2538    ulInfo->list.count = ulCnt;
2539    ulInfo->list.size = ulCnt * sizeof(ULUPTNLInformation_ToBeSetup_Item_t *);
2540    CU_ALLOC(ulInfo->list.array,ulInfo->list.size);
2541    if(ulInfo->list.array == NULLP)
2542    {
2543       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed for array in BuildULTnlInfo()");
2544       return RFAILED;
2545    }
2546    for(idx=0; idx<ulCnt; idx++)
2547    {
2548       CU_ALLOC(ulInfo->list.array[idx],sizeof(ULUPTNLInformation_ToBeSetup_Item_t));
2549       if(ulInfo->list.array[idx] == NULLP)
2550       {
2551          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed for arrayIdx [%d] in BuildULTnlInfo()", idx);
2552               return RFAILED;
2553       }
2554    }
2555    idx = 0;
2556    ulInfo->list.array[idx]->uLUPTNLInformation.present = UPTransportLayerInformation_PR_gTPTunnel;
2557    /*GTP TUNNEL*/
2558    CU_ALLOC(ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel, sizeof(GTPTunnel_t));
2559    if(ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel == NULLP)
2560    {
2561       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed for gTPTunnel in BuildULTnlInfo()");
2562       return RFAILED;
2563    }
2564    ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.size     = 4*sizeof(uint8_t);
2565    CU_ALLOC(ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf, \
2566       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.size);
2567    if(ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf == NULLP)
2568    {
2569       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed for gtp tunnel arrayIdx[%d] in BuildULTnlInfo()", idx);
2570       return RFAILED;
2571    }
2572
2573    if(!hoInProgress)
2574    {
2575       /* NOTE: Below IP address must be changed if running on different IP configuration */
2576       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[0] = 192;
2577       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[1] = 168;
2578       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[2] = 130;
2579       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[3] = 82;
2580       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.bits_unused = 0;
2581
2582       ulUpTnlInfo->address[0] = ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[0];
2583       ulUpTnlInfo->address[1] = ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[1];
2584       ulUpTnlInfo->address[2] = ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[2];
2585       ulUpTnlInfo->address[3] = ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[3];
2586    }
2587    else
2588    {
2589       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[0] = ulUpTnlInfo->address[0];
2590       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[1] = ulUpTnlInfo->address[1];
2591       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[2] = ulUpTnlInfo->address[2];
2592       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[3] = ulUpTnlInfo->address[3];
2593       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.bits_unused = 0;
2594    }
2595
2596    /*GTP TEID*/
2597    ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.size = 4 * sizeof(uint8_t);
2598    CU_ALLOC(ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf, \
2599       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.size);
2600    if(ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf == NULLP)
2601    {
2602       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed for gtp tunnel buffer in BuildULTnlInfo()");
2603       return RFAILED;
2604    }
2605
2606    if(!hoInProgress)
2607    {
2608       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[0] = 0;
2609       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[1] = 0;
2610       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[2] = 0;
2611       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[3] = cuCb.cuCfgParams.egtpParams.currTunnelId++;
2612
2613       ulUpTnlInfo->teId[0] = ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[0];
2614       ulUpTnlInfo->teId[1] = ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[1];
2615       ulUpTnlInfo->teId[2] = ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[2];
2616       ulUpTnlInfo->teId[3] = ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[3];
2617    }
2618    else
2619    {
2620       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[0] = ulUpTnlInfo->teId[0];
2621       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[1] = ulUpTnlInfo->teId[1];
2622       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[2] = ulUpTnlInfo->teId[2];
2623       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[3] = ulUpTnlInfo->teId[3];
2624    }
2625    return ROK;
2626 }/*End of BuildULTnlInfo*/
2627
2628 /*******************************************************************
2629  *
2630  * @brief Builds DRBS to be setup
2631  *
2632  * @details
2633  *
2634  *    Function : BuildDRBSetup
2635  *
2636  *    Functionality: Constructs the DRB's for UESetReq
2637  *
2638  * @params[in] DRBs_ToBeSetup_List_t *drbSet
2639  *
2640  * @return ROK     - success
2641  *         RFAILED - failure
2642  *
2643  * ****************************************************************/
2644 uint8_t BuildDRBSetup(uint32_t duId, CuUeCb *ueCb, DRBs_ToBeSetup_List_t *drbSet)
2645 {
2646    uint8_t idx = 0, extIeIdx = 0;
2647    uint8_t elementCnt = 0, drbCnt = 0;
2648    uint8_t BuildQOSInforet = 0,BuildSNSSAIret = 0;
2649    uint8_t BuildFlowsMapret =0, BuildULTnlInforet =0;
2650    DRBs_ToBeSetup_Item_t *drbSetItem;
2651    ProtocolExtensionContainer_4624P33_t *drbToBeSetupExt;
2652    DRBs_ToBeSetup_ItemExtIEs_t *drbToBeSetupExtIe = NULLP;
2653
2654    if(ueCb->state == UE_HANDOVER_IN_PROGRESS)
2655       drbCnt = ueCb->numDrb;
2656    else
2657       drbCnt = MAX_DRB_SET_UE_CONTEXT_SETUP_REQ;
2658    drbSet->list.count = drbCnt;
2659
2660    drbSet->list.size = drbCnt*sizeof(DRBs_ToBeSetup_ItemIEs_t *);
2661    CU_ALLOC(drbSet->list.array,drbSet->list.size);
2662    if(drbSet->list.array == NULLP)
2663    {
2664       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDRBSetup");
2665       return RFAILED;
2666    }
2667
2668    for(idx=0; idx<drbCnt; idx++)
2669    {
2670       CU_ALLOC(drbSet->list.array[idx],sizeof(DRBs_ToBeSetup_ItemIEs_t));
2671       if(drbSet->list.array[idx] == NULLP)
2672       {
2673          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDRBSetup for arry idx [%d]", idx);
2674          return RFAILED;
2675       }
2676
2677       drbSet->list.array[idx]->id = ProtocolIE_ID_id_DRBs_ToBeSetup_Item;
2678       drbSet->list.array[idx]->criticality = Criticality_ignore;
2679       drbSet->list.array[idx]->value.present = DRBs_ToBeSetup_ItemIEs__value_PR_DRBs_ToBeSetup_Item;
2680       drbSetItem = &drbSet->list.array[idx]->value.choice.DRBs_ToBeSetup_Item;
2681       /*dRBID*/
2682       if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
2683       {
2684          drbSetItem->dRBID = idx + 1;
2685          ueCb->drbList[ueCb->numDrb].drbId = drbSetItem->dRBID;
2686       }
2687       else
2688          drbSetItem->dRBID = ueCb->drbList[idx].drbId;
2689
2690       /*qoSInformation*/
2691       drbSetItem->qoSInformation.present = QoSInformation_PR_choice_extension;
2692       CU_ALLOC(drbSetItem->qoSInformation.choice.choice_extension,sizeof(QoSInformation_ExtIEs_t));
2693       if(drbSetItem->qoSInformation.choice.choice_extension == NULLP)
2694       {
2695          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed for QOS choice extension in BuildDRBSetup");
2696          return RFAILED;
2697       }
2698       drbSetItem->qoSInformation.choice.choice_extension->id = ProtocolIE_ID_id_DRB_Information;
2699       drbSetItem->qoSInformation.choice.choice_extension->criticality = Criticality_ignore;
2700       drbSetItem->qoSInformation.choice.choice_extension->value.present = QoSInformation_ExtIEs__value_PR_DRB_Information;
2701       if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
2702          BuildQOSInforet =  BuildQOSInfo(&ueCb->drbList[ueCb->numDrb].qos, &drbSetItem->qoSInformation.choice.\
2703                choice_extension->value.choice.DRB_Information.dRB_QoS, ProtocolIE_ID_id_DRBs_ToBeSetup_Item, PDU_SESSION_ID_1, FALSE);
2704       else
2705          BuildQOSInforet =  BuildQOSInfo(&ueCb->drbList[idx].qos, &drbSetItem->qoSInformation.choice.\
2706                choice_extension->value.choice.DRB_Information.dRB_QoS, ProtocolIE_ID_id_DRBs_ToBeSetup_Item, PDU_SESSION_ID_1, TRUE);
2707       if(BuildQOSInforet != ROK)
2708       {
2709          DU_LOG("\nERROR  -->  F1AP : Failed to build QOS Info in BuildDRBSetup");
2710          return RFAILED;
2711       }
2712
2713       /*SNSSAI*/
2714       if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
2715          BuildSNSSAIret = BuildSNSSAI(&ueCb->drbList[ueCb->numDrb], &drbSetItem->qoSInformation.choice.\
2716                choice_extension->value.choice.DRB_Information.sNSSAI, cuCb.snssaiList[0], FALSE);
2717       else
2718          BuildSNSSAIret = BuildSNSSAI(&ueCb->drbList[idx], &drbSetItem->qoSInformation.choice.\
2719                choice_extension->value.choice.DRB_Information.sNSSAI, cuCb.snssaiList[0], TRUE);
2720       if(BuildSNSSAIret != ROK)
2721       {
2722          DU_LOG("\nERROR  -->  F1AP : Failed to build SNSSAI Info in BuildDRBSetup");
2723          return RFAILED;
2724       }
2725
2726       /*Flows mapped to DRB List*/
2727       if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
2728          BuildFlowsMapret = BuildFlowsMap(&ueCb->drbList[ueCb->numDrb], &drbSetItem->qoSInformation.choice.choice_extension->\
2729                value.choice.DRB_Information.flows_Mapped_To_DRB_List, ProtocolIE_ID_id_DRBs_ToBeSetup_Item, FALSE);
2730       else
2731          BuildFlowsMapret = BuildFlowsMap(&ueCb->drbList[idx], &drbSetItem->qoSInformation.choice.choice_extension->\
2732                value.choice.DRB_Information.flows_Mapped_To_DRB_List, ProtocolIE_ID_id_DRBs_ToBeSetup_Item, TRUE);
2733       if(BuildFlowsMapret != ROK)
2734       {
2735          DU_LOG("\nERROR  -->  F1AP : Failed to build Flow Map Info in BuildDRBSetup");
2736          return RFAILED;
2737       }
2738
2739       /*ULUPTNLInformation To Be Setup List*/
2740       if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
2741          BuildULTnlInforet = BuildULTnlInfo(duId, &ueCb->drbList[ueCb->numDrb].ulUpTnlInfo, &drbSetItem->uLUPTNLInformation_ToBeSetup_List,\
2742                FALSE);
2743       else
2744          BuildULTnlInforet = BuildULTnlInfo(duId, &ueCb->drbList[idx].ulUpTnlInfo, &drbSetItem->uLUPTNLInformation_ToBeSetup_List,\
2745                TRUE);
2746       if(BuildULTnlInforet != ROK)
2747       {
2748          DU_LOG("\nERROR  -->  F1AP : Failed to build tunnel Info in BuildDRBSetup");
2749          return RFAILED;
2750       }
2751
2752       /*RLCMode*/
2753       if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
2754       {
2755          drbSetItem->rLCMode = RLCMode_rlc_um_bidirectional;
2756          ueCb->drbList[ueCb->numDrb].rlcMode = drbSetItem->rLCMode;
2757       }
2758       else
2759          drbSetItem->rLCMode = ueCb->drbList[idx].rlcMode;
2760
2761       /* DL PDCP SN Length */
2762       if(ueCb->state == UE_HANDOVER_IN_PROGRESS)
2763       {
2764          CU_ALLOC(drbToBeSetupExt, sizeof(ProtocolExtensionContainer_4624P33_t));
2765          if(!drbToBeSetupExt)
2766          {
2767             DU_LOG("\nERROR  -->  F1AP : Failed to allocate memory for extension IE list in BuildDRBSetup");
2768             return RFAILED;
2769          }
2770
2771          elementCnt = 1;
2772          drbToBeSetupExt->list.count = elementCnt;
2773          drbToBeSetupExt->list.size = drbToBeSetupExt->list.count * sizeof(DRBs_ToBeSetup_ItemExtIEs_t *);
2774
2775          CU_ALLOC(drbToBeSetupExt->list.array, drbToBeSetupExt->list.size);
2776          if(!drbToBeSetupExt->list.array)
2777          {
2778              DU_LOG("\nERROR  -->  F1AP : Failed to allocated memory for extension array in BuildDRBSetup");
2779              return RFAILED;
2780          }
2781
2782          for(extIeIdx=0; extIeIdx < drbToBeSetupExt->list.count; extIeIdx++)
2783          {
2784             CU_ALLOC(drbToBeSetupExt->list.array[extIeIdx], sizeof(DRBs_ToBeSetup_ItemExtIEs_t));
2785             if(!drbToBeSetupExt->list.array[extIeIdx])
2786             {
2787                DU_LOG("\nERROR  -->  F1AP : Failed to allocated memory for extension array element in BuildDRBSetup");
2788                return RFAILED;
2789             }
2790          }
2791
2792          extIeIdx = 0;
2793          drbToBeSetupExtIe = drbToBeSetupExt->list.array[extIeIdx];
2794
2795          drbToBeSetupExtIe->id = ProtocolIE_ID_id_DLPDCPSNLength;
2796          drbToBeSetupExtIe->criticality = Criticality_ignore;
2797          drbToBeSetupExtIe->extensionValue.present = DRBs_ToBeSetup_ItemExtIEs__extensionValue_PR_PDCPSNLength;
2798          drbToBeSetupExtIe->extensionValue.choice.PDCPSNLength = PDCPSNLength_twelve_bits;
2799          drbSetItem->iE_Extensions = drbToBeSetupExt;
2800       }
2801
2802       if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
2803          ueCb->numDrb++;
2804    }
2805    return ROK;
2806 }/* End of BuildDRBSetup*/
2807
2808 /*******************************************************************
2809  *
2810  * @brief Deallocating memory of function BuildAndSendUESetReq
2811  *
2812  * @details
2813  *
2814  *    Function : FreeNrcgi
2815  *
2816  *    Functionality: Deallocating memory for function BuildNrcgi
2817  *
2818  * @params[in] NRCGI_t *nrcgi
2819  *
2820  * @return void
2821  *
2822  *******************************************************************/
2823 void FreeNrcgi(NRCGI_t *nrcgi)
2824 {
2825    if(nrcgi->pLMN_Identity.buf != NULLP)
2826    {
2827       if(nrcgi->nRCellIdentity.buf != NULLP)
2828       {
2829          CU_FREE(nrcgi->nRCellIdentity.buf, nrcgi->nRCellIdentity.size);
2830       }
2831       CU_FREE(nrcgi->pLMN_Identity.buf, nrcgi->pLMN_Identity.size);
2832    }
2833 }
2834 /*******************************************************************
2835  *
2836  * @brief  Deallocating memory of function BuildAndSendUESetReq
2837  *
2838  * @details
2839  *
2840  *    Function : FreeSplCellList
2841  *
2842  *    Functionality: Deallocating memory for function BuildSplCellList
2843  *
2844  * @params[in] SCell_ToBeSetup_List_t *spCellLst
2845  *
2846  * @return void
2847  *
2848  *
2849  * *****************************************************************/
2850 void FreeSplCellList(SCell_ToBeSetup_List_t *spCellLst)
2851 {
2852    uint8_t  cellidx;
2853    if(spCellLst->list.array != NULLP)
2854    {
2855       for(cellidx=0; cellidx<spCellLst->list.count; cellidx++)
2856       {
2857          if(cellidx==0&&spCellLst->list.array[cellidx]!=NULLP)
2858          {
2859             FreeNrcgi(&spCellLst->list.array[cellidx]->value.choice.SCell_ToBeSetup_Item.sCell_ID);
2860          }
2861          if(spCellLst->list.array[cellidx]!=NULLP)
2862          {
2863             CU_FREE(spCellLst->list.array[cellidx],sizeof(SCell_ToBeSetup_ItemIEs_t));
2864          }
2865       }
2866       CU_FREE(spCellLst->list.array,spCellLst->list.size);
2867    }
2868 }
2869 /*******************************************************************
2870  *
2871  * @brief Deallocating memory of function BuildAndSendUESetReq
2872  *
2873  * @details
2874  *
2875  *    Function : FreeSRBSetup
2876  *
2877  *    Functionality: Deallocating memory for function BuildSRBSetup
2878  *
2879  * @params[in] SRBs_ToBeSetup_List_t *srbSet
2880  *
2881  * @return void
2882  *
2883  *
2884  * ******************************************************************/
2885 void FreeSRBSetup(SRBs_ToBeSetup_List_t *srbSet)
2886 {
2887    uint8_t srbidx;
2888    if(srbSet->list.array != NULLP)
2889    {
2890       for(srbidx=0; srbidx<srbSet->list.count; srbidx++)
2891       {
2892          if(srbSet->list.array[srbidx]!=NULLP)
2893          {
2894             CU_FREE(srbSet->list.array[srbidx],sizeof(SRBs_ToBeSetup_ItemIEs_t));
2895          }
2896       }
2897       CU_FREE(srbSet->list.array,srbSet->list.size);
2898    }
2899 }
2900 /*******************************************************************
2901  *
2902  * @brief Deallocating memory of function BuildAndSendUESetReq
2903  *
2904  * @details
2905  *
2906  *    Function : FreeQOSInfo
2907  *
2908  *    Functionality:  Deallocating memory for function BuildQOSInfo
2909  *
2910  * @params[in] QoSFlowLevelQoSParameters_t *drbQos
2911  *
2912  * @return void
2913  *
2914  * ****************************************************************/
2915 void FreeQOSInfo(QoSFlowLevelQoSParameters_t *drbQos)
2916 {
2917    ProtocolExtensionContainer_4624P74_t *qosIeExt = NULLP;
2918    uint8_t qosCntIdx = 0;
2919
2920    if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI != NULLP)
2921    {
2922       if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow!=NULLP)
2923       {
2924          if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume!=NULLP)
2925          {
2926             CU_FREE(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume,\
2927                   sizeof(MaxDataBurstVolume_t));
2928          }
2929          CU_FREE(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow,\
2930                sizeof(AveragingWindow_t));
2931       }
2932       CU_FREE(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI,\
2933             sizeof(NonDynamic5QIDescriptor_t));
2934    }
2935    if(drbQos->iE_Extensions)
2936    {
2937       qosIeExt = (ProtocolExtensionContainer_4624P74_t *)drbQos->iE_Extensions;
2938       if(qosIeExt->list.array != NULLP)
2939       {
2940          for(qosCntIdx=0; qosCntIdx <  qosIeExt->list.count; qosCntIdx++)
2941          {
2942             if(qosIeExt->list.array[qosCntIdx])
2943             {
2944                CU_FREE(qosIeExt->list.array[qosCntIdx], sizeof(QoSFlowLevelQoSParameters_ExtIEs_t));
2945             }
2946          }
2947          CU_FREE(qosIeExt->list.array, qosIeExt->list.size);
2948       }
2949
2950       CU_FREE(drbQos->iE_Extensions, sizeof(ProtocolExtensionContainer_4624P74_t));
2951    }
2952 }
2953 /*******************************************************************
2954  *
2955  * @brief Deallocating memory of function BuildAndSendUESetReq
2956  *
2957  * @details
2958  *
2959  *    Function : FreeULTnlInfo
2960  *
2961  *    Functionality:  Deallocating memory for function BuildULTnlInfo
2962  *
2963  * @params[in] ULUPTNLInformation_ToBeSetup_List_t *ulInfo
2964  *
2965  * @return void
2966  *
2967
2968  * ****************************************************************/
2969 void FreeULTnlInfo(ULUPTNLInformation_ToBeSetup_List_t *ulInfo)
2970 {
2971    uint8_t ulidx=0;
2972    if(ulInfo->list.array != NULLP)
2973    {
2974       for(ulidx=0; ulidx<ulInfo->list.count; ulidx++)
2975       {
2976          if(ulidx==0&&ulInfo->list.array[ulidx]!=NULLP)
2977          {
2978             if(ulInfo->list.array[ulidx]->uLUPTNLInformation.choice.gTPTunnel!=NULLP)
2979             {
2980                if(ulInfo->list.array[ulidx]->uLUPTNLInformation.choice.gTPTunnel->\
2981                      transportLayerAddress.buf != NULLP)
2982                {
2983                   if(ulInfo->list.array[ulidx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf\
2984                         !=NULLP)
2985                   {
2986                      CU_FREE(ulInfo->list.array[ulidx]->uLUPTNLInformation.choice.gTPTunnel->\
2987                            gTP_TEID.buf,ulInfo->list.array[ulidx]->uLUPTNLInformation.choice.\
2988                            gTPTunnel->gTP_TEID.size);
2989                   }
2990                   CU_FREE(ulInfo->list.array[ulidx]->uLUPTNLInformation.choice.gTPTunnel->\
2991                         transportLayerAddress.buf,ulInfo->list.array[ulidx]->\
2992                         uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.size);
2993                }
2994                CU_FREE(ulInfo->list.array[ulidx]->uLUPTNLInformation.choice.gTPTunnel,\
2995                      sizeof(GTPTunnel_t));
2996             }
2997          }
2998          if(ulInfo->list.array[ulidx]!=NULLP)
2999          {
3000             CU_FREE(ulInfo->list.array[ulidx],sizeof(ULUPTNLInformation_ToBeSetup_Item_t));
3001          }
3002       }
3003       CU_FREE(ulInfo->list.array,ulInfo->list.size);
3004    }
3005 }
3006 /*******************************************************************
3007  *
3008  * @brief Deallocating memory for BuildAndSendUESetReq
3009  *
3010  * @details
3011  *
3012  *    Function : FreeDRBSetup
3013  *
3014  *    Functionality:  Deallocating memory for BuildDRBSetup
3015  *
3016  * @params[in] DRBs_ToBeSetup_List_t *drbSet
3017  *
3018  * @return void
3019  *
3020  * ****************************************************************/
3021 void FreeDRBSetup(DRBs_ToBeSetup_List_t *drbSet)
3022 {
3023    DRBs_ToBeSetup_Item_t *drbSetItem;
3024    ProtocolExtensionContainer_4624P74_t *qosIeExt = NULLP;
3025
3026    uint8_t  flowidx = 0, drbidx = 0, qosCntIdx = 0;
3027
3028    /*BUG: Need to check drbSet->list.array is not Empty to procced with Deletion*/
3029    if(drbSet->list.array != NULLP)
3030    {
3031       for(drbidx=0; drbidx<drbSet->list.count; drbidx++)
3032       {
3033               if(drbSet->list.array[drbidx] != NULLP)
3034               {
3035                  drbSetItem =&drbSet->list.array[drbidx]->value.choice.DRBs_ToBeSetup_Item;
3036                  if(drbSetItem->qoSInformation.choice.choice_extension != NULLP)
3037                  {
3038                     if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
3039                                   qoS_Characteristics.choice.non_Dynamic_5QI !=NULLP)
3040                {
3041                    if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
3042                                           qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow!=NULLP)
3043                             {
3044                                if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
3045                                           qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume!=NULLP)
3046                                {
3047                                        if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sST.buf!=NULLP)
3048                                        {
3049                                           if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD!=NULLP)
3050                                           {
3051                                              if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD->buf!=NULLP)
3052                                              {
3053                                                      if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.\
3054                                                             flows_Mapped_To_DRB_List.list.array != NULLP)
3055                                                      {
3056                                                          for(flowidx=0;flowidx<drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.\
3057                                                                       flows_Mapped_To_DRB_List.list.count; flowidx++)
3058                                                          {
3059                                                              if(flowidx==0&&drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
3060                                                                            DRB_Information.flows_Mapped_To_DRB_List.list.array[flowidx]!=NULLP)
3061                                                              {
3062                                                                      if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
3063                                                                                 DRB_Information.flows_Mapped_To_DRB_List.list.array[flowidx]->qoSFlowLevelQoSParameters.\
3064                                                                                 qoS_Characteristics.choice.non_Dynamic_5QI!=NULLP)
3065                                                                      {
3066                                                                          if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
3067                                                                                    DRB_Information.flows_Mapped_To_DRB_List.list.array[flowidx]->qoSFlowLevelQoSParameters.\
3068                                                                                    qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow!=NULLP)
3069                                                                          {
3070                                                                                  if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
3071                                                                                  DRB_Information.flows_Mapped_To_DRB_List.list.array[flowidx]->qoSFlowLevelQoSParameters.\
3072                                                                                   qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume!=NULLP)
3073                                                                                   {
3074                                                                                       FreeULTnlInfo(&drbSetItem->uLUPTNLInformation_ToBeSetup_List);
3075                                                                                       CU_FREE(drbSetItem->uLConfiguration,sizeof(ULConfiguration_t));
3076
3077                                                                                       CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
3078                                                                                                    DRB_Information.flows_Mapped_To_DRB_List.list.array[flowidx]->qoSFlowLevelQoSParameters.\
3079                                                                                                    qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume,\
3080                                                                                                    sizeof(MaxDataBurstVolume_t));
3081                                                                                   }
3082                                                          CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
3083                                                                                            DRB_Information.flows_Mapped_To_DRB_List.list.array[flowidx]->qoSFlowLevelQoSParameters.\
3084                                                                                            qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow,sizeof(AveragingWindow_t));
3085                                                                          }
3086                                                                          CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
3087                                                                                        DRB_Information.flows_Mapped_To_DRB_List.list.array[flowidx]->qoSFlowLevelQoSParameters.\
3088                                                                                        qoS_Characteristics.choice.non_Dynamic_5QI,sizeof(NonDynamic5QIDescriptor_t));
3089                                                                      }
3090                                                             }
3091                                                             if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
3092                                                                      DRB_Information.flows_Mapped_To_DRB_List.list.array[flowidx]!=NULLP)
3093                                                             {
3094                                                                     CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
3095                                                                                   DRB_Information.flows_Mapped_To_DRB_List.list.array[flowidx],sizeof(Flows_Mapped_To_DRB_Item_t));
3096                                                             }
3097                                                         }
3098                                                         CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.\
3099                                                                       flows_Mapped_To_DRB_List.list.array,drbSetItem->qoSInformation.choice.choice_extension->value.\
3100                                                                       choice.DRB_Information.flows_Mapped_To_DRB_List.list.size);
3101                                                      }
3102                                                      CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD->buf,\
3103                                                              drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD->size);
3104                                             }
3105                                             CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD,\
3106                                                               sizeof(OCTET_STRING_t));
3107                                        }
3108                                        CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sST.buf,\
3109                                                     drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sST.size);
3110                                     }
3111                                     CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
3112                                             qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume,sizeof(MaxDataBurstVolume_t));
3113                             }
3114                        CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
3115                                          qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow,sizeof(AveragingWindow_t));
3116                          }
3117                          CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
3118                                        qoS_Characteristics.choice.non_Dynamic_5QI, sizeof(NonDynamic5QIDescriptor_t));
3119              }
3120              if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
3121                         iE_Extensions != NULLP)
3122              {
3123                 qosIeExt = (ProtocolExtensionContainer_4624P74_t *)drbSetItem->qoSInformation.choice.\
3124                                     choice_extension->value.choice.DRB_Information.dRB_QoS.iE_Extensions;
3125                  if(qosIeExt->list.array != NULLP)
3126                  {
3127                    for(qosCntIdx=0; qosCntIdx < qosIeExt->list.count; qosCntIdx++)
3128                    {
3129                       if(qosIeExt->list.array[qosCntIdx] != NULLP)
3130                       {
3131                          CU_FREE(qosIeExt->list.array[qosCntIdx], sizeof(QoSFlowLevelQoSParameters_ExtIEs_t));
3132                       }
3133                     }
3134                     CU_FREE(qosIeExt->list.array, qosIeExt->list.size);
3135                   }
3136                   CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
3137                                    iE_Extensions, sizeof(ProtocolExtensionContainer_4624P74_t));
3138               }
3139
3140                   CU_FREE(drbSetItem->qoSInformation.choice.choice_extension,sizeof(QoSInformation_ExtIEs_t));
3141                 }
3142                 CU_FREE(drbSet->list.array[drbidx],sizeof(DRBs_ToBeSetup_ItemIEs_t));
3143               }
3144       }
3145       CU_FREE(drbSet->list.array,drbSet->list.size);
3146    }
3147 }
3148
3149
3150 /*******************************************************************
3151  *
3152  * @brief Free the UE Setup Request
3153  *
3154  * @details
3155  *
3156  *    Function : FreeUeContextSetupReq
3157  *
3158  *    Functionality: Deallocate the memory of BuildUESetReq
3159  *
3160  * @params[in]  F1AP_PDU_t  *f1apMsg
3161  *
3162  * @return void
3163  *
3164  *
3165  * ****************************************************************/
3166 void FreeUeContextSetupReq(F1AP_PDU_t  *f1apMsg)
3167 {
3168    uint8_t idx, ieId;
3169    UEContextSetupRequest_t  *ueSetReq = NULLP;
3170
3171    if(f1apMsg != NULLP)
3172    {
3173       if(f1apMsg->choice.initiatingMessage != NULLP)
3174       {
3175          ueSetReq = &f1apMsg->choice.initiatingMessage->value.choice.UEContextSetupRequest;
3176          if(ueSetReq->protocolIEs.list.array != NULLP)
3177          {
3178             for(idx = 0; idx < ueSetReq->protocolIEs.list.count; idx++)
3179             {
3180                if(ueSetReq->protocolIEs.list.array[idx])
3181                {
3182                   switch(ueSetReq->protocolIEs.list.array[idx]->id)
3183                   {
3184                      case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
3185                         break;
3186                      case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
3187                         break;
3188                      case ProtocolIE_ID_id_SpCell_ID:
3189                         FreeNrcgi(&ueSetReq->protocolIEs.list.array[idx]->value.choice.NRCGI);
3190                         break;
3191                      case ProtocolIE_ID_id_ServCellIndex:
3192                         break;
3193                      case ProtocolIE_ID_id_SpCellULConfigured:
3194                         break;
3195                      case ProtocolIE_ID_id_CUtoDURRCInformation:
3196                         FreeCuToDuInfo(&ueSetReq->protocolIEs.list.array[idx]->value.choice.CUtoDURRCInformation);
3197                         break;
3198                      case ProtocolIE_ID_id_SCell_ToBeSetup_List:
3199                         FreeSplCellList(&ueSetReq->protocolIEs.list.array[idx]->value.choice.SCell_ToBeSetup_List);
3200                         break;
3201                      case ProtocolIE_ID_id_SRBs_ToBeSetup_List:
3202                         FreeSRBSetup(&ueSetReq->protocolIEs.list.array[idx]->value.choice.SRBs_ToBeSetup_List);
3203                         break;
3204                      case ProtocolIE_ID_id_DRBs_ToBeSetup_List:
3205                         FreeDRBSetup(&ueSetReq->protocolIEs.list.array[idx]->value.choice.DRBs_ToBeSetup_List);
3206                         break;
3207                      case ProtocolIE_ID_id_RRCContainer:
3208                         if(ueSetReq->protocolIEs.list.array[idx]->value.choice.RRCContainer.buf != NULLP)
3209                         {
3210                            CU_FREE(ueSetReq->protocolIEs.list.array[idx]->value.choice.RRCContainer.buf, \
3211                                  ueSetReq->protocolIEs.list.array[idx]->value.choice.RRCContainer.size);
3212                         }
3213                         break;
3214                      case ProtocolIE_ID_id_GNB_DU_UE_AMBR_UL:
3215                         CU_FREE(ueSetReq->protocolIEs.list.array[idx]->value.choice.BitRate.buf,\
3216                               ueSetReq->protocolIEs.list.array[idx]->value.choice.BitRate.size);
3217                         break;
3218                      default:
3219                         DU_LOG("\nERROR  -->  F1AP: Invalid event type %ld", ueSetReq->protocolIEs.list.array[idx]->id);
3220                         break;
3221                   }
3222                }
3223                /*BUG: Break is causing to exit the for Loop before complete traversing and freeing of each IE*/
3224             }
3225             for(ieId=0; ieId<idx; ieId++)
3226             {
3227                if(ueSetReq->protocolIEs.list.array[ieId] != NULLP)
3228                {
3229                   CU_FREE(ueSetReq->protocolIEs.list.array[ieId],sizeof(UEContextSetupRequestIEs_t));
3230                }
3231             }
3232             CU_FREE(ueSetReq->protocolIEs.list.array,ueSetReq->protocolIEs.list.size);
3233          }
3234          CU_FREE(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
3235       }
3236       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
3237    }
3238 }
3239
3240 /**Filling cell group info **/
3241 /*******************************************************************
3242  *
3243  * @brief Build Control resource set to add/modify list
3244  *
3245  * @details
3246  *
3247  *    Function : BuildControlRSetToAddModList
3248  *
3249  *    Functionality: Build Control resource set to add/modify list
3250  *
3251  * @params[in]
3252  * struct PDCCH_Config__controlResourceSetToAddModList *controlRSetList
3253  *
3254  * @return ROK     - success
3255  *         RFAILED - failure
3256  *
3257  * ****************************************************************/
3258    uint8_t BuildControlRSetToAddModList
3259 (
3260  struct PDCCH_Config__controlResourceSetToAddModList *controlRSetList
3261  )
3262 {
3263    uint8_t idx;
3264    uint8_t elementCnt;
3265    uint8_t numBytes, bitsUnused;
3266    struct ControlResourceSet *controlRSet;
3267    uint8_t freqDomainResource[FREQ_DOM_RSRC_SIZE] = {0};
3268    uint8_t coreset0EndPrb, coreset1StartPrb, coreset1NumPrb;
3269
3270    elementCnt = 1;
3271    controlRSetList->list.count = elementCnt;
3272    controlRSetList->list.size = \
3273                                 elementCnt * sizeof(struct ControlResourceSet *);
3274
3275    controlRSetList->list.array = NULLP;
3276    CU_ALLOC(controlRSetList->list.array, controlRSetList->list.size);
3277    if(!controlRSetList->list.array)
3278    {
3279       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3280       return RFAILED;
3281    }
3282
3283    for(idx = 0; idx < elementCnt; idx++)
3284    {
3285       controlRSetList->list.array[idx] = NULLP;
3286       CU_ALLOC(controlRSetList->list.array[idx], sizeof(struct ControlResourceSet));
3287       if(!controlRSetList->list.array[idx])
3288       {
3289          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3290          return RFAILED;
3291       }
3292    }
3293
3294    idx=0;
3295    controlRSet = controlRSetList->list.array[idx];
3296    controlRSet->controlResourceSetId = PDCCH_CTRL_RSRC_SET_ONE_ID;
3297
3298    /* Values harcoded according to our design:
3299     * size 6 bytes
3300     * 3 LSBs unsued
3301     * Bit string stored ff0000000000
3302     */
3303    numBytes = 6;
3304    bitsUnused = 3;
3305    controlRSet->frequencyDomainResources.size = numBytes * sizeof(uint8_t);
3306    controlRSet->frequencyDomainResources.buf = NULLP;
3307    CU_ALLOC(controlRSet->frequencyDomainResources.buf, \
3308          controlRSet->frequencyDomainResources.size);
3309    if(!controlRSet->frequencyDomainResources.buf)
3310    {
3311       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3312       return RFAILED;
3313    }
3314
3315    memset(controlRSet->frequencyDomainResources.buf, 0, FREQ_DOM_RSRC_SIZE);
3316    coreset0EndPrb = CORESET0_END_PRB;
3317    coreset1StartPrb = coreset0EndPrb + 6;
3318    coreset1NumPrb = CORESET1_NUM_PRB;
3319    /* calculate the PRBs */
3320    fillCoresetFeqDomAllocMap(((coreset1StartPrb)/6), (coreset1NumPrb/6), freqDomainResource);
3321    memcpy(controlRSet->frequencyDomainResources.buf, freqDomainResource, FREQ_DOM_RSRC_SIZE);
3322    controlRSet->frequencyDomainResources.bits_unused = bitsUnused;
3323
3324    controlRSet->duration = PDCCH_CTRL_RSRC_SET_ONE_DURATION;
3325    controlRSet->cce_REG_MappingType.present = \
3326                                               ControlResourceSet__cce_REG_MappingType_PR_nonInterleaved;
3327
3328    controlRSet->precoderGranularity = PDCCH_CTRL_RSRC_SET_ONE_PRECOD_GRANULARITY;
3329    controlRSet->tci_StatesPDCCH_ToAddList = NULLP;
3330    controlRSet->tci_StatesPDCCH_ToReleaseList = NULLP;
3331    controlRSet->tci_PresentInDCI = NULLP;
3332 #if 0
3333    uint8_t tciStateIdx;
3334
3335    CU_ALLOC(controlRset->tci_StatesPDCCH_ToAddList, \
3336          sizeof(struct ControlResourceSet__tci_StatesPDCCH_ToAddList));
3337    if(!controlRset->tci_StatesPDCCH_ToAddList)
3338    {
3339       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3340       return RFAILED;
3341    }
3342
3343    elementCnt = 1;
3344    controlRset->tci_StatesPDCCH_ToAddList->list.count = elementCnt;
3345    controlRset->tci_StatesPDCCH_ToAddList->list.size = elementCnt * sizeof(TCI_StateId_t *);
3346    CU_ALLOC(controlRset->tci_StatesPDCCH_ToAddList->list.array, \
3347          controlRset->tci_StatesPDCCH_ToAddList->list.size)
3348       if(!controlRset->tci_StatesPDCCH_ToAddList->list.array)
3349       {
3350          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3351          return RFAILED;
3352       }
3353
3354    for(tciStateIdx = 0; tciStateIdx <elementCntl; tciStateIdx++)
3355    {
3356       CU_ALLOC(controlRset->tci_StatesPDCCH_ToAddList->list.array[tciStateIdx], sizeof(TCI_StateId_t));
3357       if(!controlRset->tci_StatesPDCCH_ToAddList->list.array[tciStateIdx])
3358       {
3359          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3360          return RFAILED;
3361       }
3362    }
3363
3364    tciStateIdx = 0;
3365    /* TODO */
3366    *(controlRset->tci_StatesPDCCH_ToAddList->list.array[tciStateIdx]);
3367
3368    CU_ALLOC(controlRset->tci_PresentInDCI, sizeof(long));
3369    if(!controlRset->tci_PresentInDCI)
3370    {
3371       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3372       return RFAILED;
3373    }
3374    /* TODO */
3375    *(controlRset->tci_PresentInDCI);
3376 #endif
3377
3378    controlRSet->pdcch_DMRS_ScramblingID = NULLP;
3379    CU_ALLOC(controlRSet->pdcch_DMRS_ScramblingID, sizeof(long));
3380    if(!controlRSet->pdcch_DMRS_ScramblingID)
3381    {
3382       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3383       return RFAILED;
3384    }
3385    *(controlRSet->pdcch_DMRS_ScramblingID) = SCRAMBLING_ID;
3386
3387    return ROK;
3388 } /* End BuildControlRSetToAddModList */
3389
3390 /*******************************************************************
3391  *
3392  * @brief Build search space to add/modify list
3393  *
3394  * @details
3395  *
3396  *    Function : BuildSearchSpcToAddModList
3397  *
3398  *    Functionality: Build search space to add/modify list
3399  *
3400  * @params[in]
3401  * @return ROK     - success
3402  *         RFAILED - failure
3403  *
3404  * ****************************************************************/
3405    uint8_t BuildSearchSpcToAddModList
3406 (
3407  struct PDCCH_Config__searchSpacesToAddModList *searchSpcList
3408  )
3409 {
3410    uint8_t idx;
3411    uint8_t numBytes;
3412    uint8_t byteIdx;
3413    uint8_t bitsUnused;
3414    uint8_t elementCnt;
3415    struct SearchSpace *searchSpc;
3416
3417    elementCnt = 1;
3418    searchSpcList->list.count = elementCnt;
3419    searchSpcList->list.size = elementCnt * sizeof(struct SearchSpace *);
3420
3421    searchSpcList->list.array = NULLP;
3422    CU_ALLOC(searchSpcList->list.array, searchSpcList->list.size);
3423    if(!searchSpcList->list.array)
3424    {
3425       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3426       return RFAILED;
3427    }
3428
3429    for(idx = 0; idx < elementCnt; idx++)
3430    {
3431       searchSpcList->list.array[idx] = NULLP;
3432       CU_ALLOC(searchSpcList->list.array[idx], sizeof(struct SearchSpace));
3433       if(!searchSpcList->list.array[idx])
3434       {
3435          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3436          return RFAILED;
3437       }
3438    }
3439
3440    idx = 0;
3441    searchSpc = searchSpcList->list.array[idx];
3442
3443    searchSpc->searchSpaceId = PDCCH_SRCH_SPC_TWO_ID;
3444
3445    searchSpc->controlResourceSetId = NULLP;
3446    CU_ALLOC(searchSpc->controlResourceSetId, sizeof(ControlResourceSetId_t));
3447    if(!searchSpc->controlResourceSetId)
3448    {
3449       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3450       return RFAILED;
3451    }
3452    *(searchSpc->controlResourceSetId) = PDCCH_CTRL_RSRC_SET_ONE_ID;
3453
3454    searchSpc->monitoringSlotPeriodicityAndOffset = NULLP;
3455    CU_ALLOC(searchSpc->monitoringSlotPeriodicityAndOffset, \
3456          sizeof(struct SearchSpace__monitoringSlotPeriodicityAndOffset));
3457    if(!searchSpc->monitoringSlotPeriodicityAndOffset)
3458    {
3459       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3460       return RFAILED;
3461    }
3462    searchSpc->monitoringSlotPeriodicityAndOffset->present = \
3463                                                             SearchSpace__monitoringSlotPeriodicityAndOffset_PR_sl1;
3464
3465    searchSpc->duration = NULLP;
3466    searchSpc->monitoringSymbolsWithinSlot = NULLP;
3467    CU_ALLOC(searchSpc->monitoringSymbolsWithinSlot, sizeof(BIT_STRING_t));
3468    if(!searchSpc->monitoringSymbolsWithinSlot)
3469    {
3470       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3471       return RFAILED;
3472    }
3473
3474    /* Values taken from reference logs :
3475     * size 2 bytes
3476     * 2 LSBs unsued
3477     * Bit string stores 8000
3478     */
3479    numBytes = 2;
3480    bitsUnused = 2;
3481
3482    searchSpc->monitoringSymbolsWithinSlot->size = numBytes * sizeof(uint8_t);
3483    searchSpc->monitoringSymbolsWithinSlot->buf = NULLP;
3484    CU_ALLOC(searchSpc->monitoringSymbolsWithinSlot->buf, \
3485          searchSpc->monitoringSymbolsWithinSlot->size);
3486    if(!searchSpc->monitoringSymbolsWithinSlot->buf)
3487    {
3488       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3489       return RFAILED;
3490    }
3491
3492    byteIdx = 0;
3493    searchSpc->monitoringSymbolsWithinSlot->buf[byteIdx++] = \
3494                                                             PDCCH_SYMBOL_WITHIN_SLOT /* setting MSB to 128 i.e. 0x80 */;
3495    searchSpc->monitoringSymbolsWithinSlot->buf[byteIdx++] = 0;
3496    searchSpc->monitoringSymbolsWithinSlot->bits_unused = bitsUnused;
3497
3498    searchSpc->nrofCandidates = NULLP;
3499    CU_ALLOC(searchSpc->nrofCandidates, sizeof(struct SearchSpace__nrofCandidates));
3500    if(!searchSpc->nrofCandidates)
3501    {
3502       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3503       return RFAILED;
3504    }
3505
3506    searchSpc->nrofCandidates->aggregationLevel1 = \
3507                                                   PDCCH_SRCH_SPC_TWO_AGG_LVL1_CANDIDATE;
3508    searchSpc->nrofCandidates->aggregationLevel2 = \
3509                                                   PDCCH_SRCH_SPC_TWO_AGG_LVL2_CANDIDATE;
3510    searchSpc->nrofCandidates->aggregationLevel4 = \
3511                                                   PDCCH_SRCH_SPC_TWO_AGG_LVL4_CANDIDATE;
3512    searchSpc->nrofCandidates->aggregationLevel8 = \
3513                                                   PDCCH_SRCH_SPC_TWO_AGG_LVL8_CANDIDATE;
3514    searchSpc->nrofCandidates->aggregationLevel16 = \
3515                                                    PDCCH_SRCH_SPC_TWO_AGG_LVL16_CANDIDATE;
3516
3517    searchSpc->searchSpaceType = NULLP;
3518    CU_ALLOC(searchSpc->searchSpaceType, sizeof(struct SearchSpace__searchSpaceType));
3519    if(!searchSpc->searchSpaceType)
3520    {
3521       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3522       return RFAILED;
3523    }
3524
3525    searchSpc->searchSpaceType->present = SearchSpace__searchSpaceType_PR_ue_Specific;
3526
3527    searchSpc->searchSpaceType->choice.ue_Specific = NULLP;
3528    CU_ALLOC(searchSpc->searchSpaceType->choice.ue_Specific, \
3529          sizeof(struct SearchSpace__searchSpaceType__ue_Specific));
3530    if(!searchSpc->searchSpaceType->choice.ue_Specific)
3531    {
3532       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3533       return RFAILED;
3534    }
3535    searchSpc->searchSpaceType->choice.ue_Specific->dci_Formats = \
3536                                                                  PDCCH_SRCH_SPC_TWO_UE_SPEC_DCI_FORMAT;
3537
3538    return ROK;
3539 }/* End BuildSearchSpcToAddModList */
3540
3541 /*******************************************************************
3542  *
3543  * @brief Builds BWP DL dedicated PDCCH config
3544  *
3545  * @details
3546  *
3547  *    Function : BuildBWPDlDedPdcchCfg
3548  *
3549  *    Functionality: Builds BWP DL dedicated PDCCH config
3550  *
3551  * @params[in] struct PDCCH_Config *pdcchCfg
3552  *
3553  * @return ROK     - success
3554  *         RFAILED - failure
3555  *
3556  * ****************************************************************/
3557 uint8_t BuildBWPDlDedPdcchCfg(struct PDCCH_Config *pdcchCfg)
3558 {
3559    pdcchCfg->controlResourceSetToAddModList = NULLP;
3560    CU_ALLOC(pdcchCfg->controlResourceSetToAddModList, \
3561          sizeof(struct PDCCH_Config__controlResourceSetToAddModList));
3562    if(!pdcchCfg->controlResourceSetToAddModList)
3563    {
3564       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdcchCfg");
3565       return RFAILED;
3566    }
3567
3568    if(BuildControlRSetToAddModList(pdcchCfg->controlResourceSetToAddModList) != ROK)
3569    {
3570       return RFAILED;
3571    }
3572
3573    pdcchCfg->controlResourceSetToReleaseList = NULLP;
3574
3575    pdcchCfg->searchSpacesToAddModList = NULLP;
3576    CU_ALLOC(pdcchCfg->searchSpacesToAddModList, \
3577          sizeof(struct PDCCH_Config__searchSpacesToAddModList));
3578    if(!pdcchCfg->searchSpacesToAddModList)
3579    {
3580       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdcchCfg");
3581       return RFAILED;
3582    }
3583
3584    if(BuildSearchSpcToAddModList(pdcchCfg->searchSpacesToAddModList) != ROK)
3585    {
3586       return RFAILED;
3587    }
3588
3589    pdcchCfg->searchSpacesToReleaseList = NULLP;
3590    pdcchCfg->downlinkPreemption = NULLP;
3591    pdcchCfg->tpc_PUSCH = NULLP;
3592    pdcchCfg->tpc_PUCCH = NULLP;
3593    pdcchCfg->tpc_SRS = NULLP;
3594
3595    return ROK;
3596 }
3597
3598 /*******************************************************************
3599  *
3600  * @brief Builds DMRS DL PDSCH Mapping type A
3601  *
3602  * @details
3603  *
3604  *    Function : BuildDMRSDLPdschMapTypeA
3605  *
3606  *    Functionality: Builds DMRS DL PDSCH Mapping type A
3607  *
3608  * @params[in]
3609  * struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA *dmrsDlCfg
3610  * @return ROK     - success
3611  *         RFAILED - failure
3612  *
3613  * ****************************************************************/
3614    uint8_t BuildDMRSDLPdschMapTypeA
3615 (
3616  struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA *dmrsDlCfg
3617  )
3618 {
3619    dmrsDlCfg->present = PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA_PR_setup;
3620    dmrsDlCfg->choice.setup = NULLP;
3621    CU_ALLOC(dmrsDlCfg->choice.setup, sizeof(struct DMRS_DownlinkConfig));
3622    if(!dmrsDlCfg->choice.setup)
3623    {
3624       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
3625       return RFAILED;
3626    }
3627
3628    dmrsDlCfg->choice.setup->dmrs_Type = NULLP;
3629    dmrsDlCfg->choice.setup->dmrs_AdditionalPosition = NULLP;
3630    CU_ALLOC(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition, sizeof(long));
3631    if(!dmrsDlCfg->choice.setup->dmrs_AdditionalPosition)
3632    {
3633       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSDLPdschMapTypeA");
3634       return RFAILED;
3635    }
3636    *(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition) = DMRS_ADDITIONAL_POS;
3637
3638    dmrsDlCfg->choice.setup->maxLength = NULLP;
3639    dmrsDlCfg->choice.setup->scramblingID0 = NULLP;
3640    dmrsDlCfg->choice.setup->scramblingID1 = NULLP;
3641    dmrsDlCfg->choice.setup->phaseTrackingRS = NULLP;
3642
3643    return ROK;
3644 }
3645
3646 /*******************************************************************
3647  *
3648  * @brief Builds TCI states to add/modify list
3649  *
3650  * @details
3651  *
3652  *    Function : BuildTCIStatesToAddModList
3653  *
3654  *    Functionality:Builds TCI states to add/modify list
3655  *
3656  * @params[in]
3657  * struct PDSCH_Config__tci_StatesToAddModList *tciStatesList
3658  *
3659  * @return ROK     - success
3660  *         RFAILED - failure
3661  *
3662  * ****************************************************************/
3663 uint8_t BuildTCIStatesToAddModList(struct PDSCH_Config__tci_StatesToAddModList *tciStatesList)
3664 {
3665    return ROK;
3666 }
3667
3668 /*******************************************************************
3669  *
3670  * @brief Builds PDSCH time domain allocation list
3671  *
3672  * @details
3673  *
3674  *    Function : BuildPdschTimeDomAllocList
3675  *
3676  *    Functionality: Builds PDSCH time domain allocation list
3677  *
3678  * @params[in]
3679  * struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList
3680  *
3681  * @return ROK     - success
3682  *         RFAILED - failure
3683  *
3684  * ****************************************************************/
3685    uint8_t BuildPdschTimeDomAllocList
3686 (
3687  struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList
3688  )
3689 {
3690    uint8_t idx;
3691    uint8_t elementCnt;
3692    struct PDSCH_TimeDomainResourceAllocation *timeDomAlloc;
3693
3694    timeDomAllocList->present = \
3695                                PDSCH_Config__pdsch_TimeDomainAllocationList_PR_setup;
3696
3697    timeDomAllocList->choice.setup = NULLP;
3698    CU_ALLOC(timeDomAllocList->choice.setup, \
3699          sizeof(struct PDSCH_TimeDomainResourceAllocationList));
3700    if(!timeDomAllocList->choice.setup)
3701    {
3702       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
3703       return RFAILED;
3704    }
3705
3706    elementCnt = 2;
3707    timeDomAllocList->choice.setup->list.count = elementCnt;
3708    timeDomAllocList->choice.setup->list.size = \
3709                                                elementCnt * sizeof(struct PDSCH_TimeDomainResourceAllocation *);
3710
3711    timeDomAllocList->choice.setup->list.array = NULLP;
3712    CU_ALLOC(timeDomAllocList->choice.setup->list.array, \
3713          timeDomAllocList->choice.setup->list.size);
3714    if(!timeDomAllocList->choice.setup->list.array)
3715    {
3716       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
3717       return RFAILED;
3718    }
3719
3720    for(idx = 0; idx < elementCnt; idx++)
3721    {
3722       timeDomAllocList->choice.setup->list.array[idx] = NULLP;
3723       CU_ALLOC(timeDomAllocList->choice.setup->list.array[idx], \
3724             sizeof(struct PDSCH_TimeDomainResourceAllocation));
3725       if(!timeDomAllocList->choice.setup->list.array[idx])
3726       {
3727          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
3728          return RFAILED;
3729       }
3730    }
3731
3732    idx = 0;
3733    timeDomAlloc = timeDomAllocList->choice.setup->list.array[idx];
3734    CU_ALLOC(timeDomAlloc->k0, sizeof(long));
3735    if(!timeDomAlloc->k0)
3736    {
3737        DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
3738        return RFAILED;
3739    }
3740    *(timeDomAlloc->k0) = 0;
3741    timeDomAlloc->mappingType = PDSCH_MAPPING_TYPE_A;
3742    timeDomAlloc->startSymbolAndLength = 66;
3743
3744    idx++;
3745    timeDomAlloc = timeDomAllocList->choice.setup->list.array[idx];
3746    CU_ALLOC(timeDomAlloc->k0, sizeof(long));
3747    if(!timeDomAlloc->k0)
3748    {
3749       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
3750       return RFAILED;
3751    }
3752    *(timeDomAlloc->k0) = 1;
3753    timeDomAlloc->mappingType = PDSCH_MAPPING_TYPE_A;
3754    timeDomAlloc->startSymbolAndLength = 66;
3755
3756    return ROK;
3757 }
3758
3759 /*******************************************************************
3760  *
3761  * @brief Builds PDSCH PRB Bundling type
3762  *
3763  * @details
3764  *
3765  *    Function : BuildPdschPrbBundlingType
3766  *
3767  *    Functionality: Builds PDSCH PRB Bundling type
3768  *
3769  * @params[in]
3770  * struct PDSCH_Config__prb_BundlingType *prbBndlType
3771  *
3772  * @return ROK     - success
3773  *         RFAILED - failure
3774  *
3775  * ****************************************************************/
3776    uint8_t BuildPdschPrbBundlingType
3777 (
3778  struct PDSCH_Config__prb_BundlingType *prbBndlType
3779  )
3780 {
3781    prbBndlType->present = PDSCH_Config__prb_BundlingType_PR_staticBundling;
3782
3783    prbBndlType->choice.staticBundling = NULLP;
3784    CU_ALLOC(prbBndlType->choice.staticBundling, \
3785          sizeof(struct PDSCH_Config__prb_BundlingType__staticBundling));
3786    if(!prbBndlType->choice.staticBundling)
3787    {
3788       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschPrbBundlingType");
3789       return RFAILED;
3790    }
3791    prbBndlType->choice.staticBundling->bundleSize = NULLP;
3792
3793    return ROK;
3794 }
3795
3796 /*******************************************************************
3797  *
3798  * @brief Builds BWP DL dedicated PDSCH config
3799  *
3800  * @details
3801  *
3802  *    Function : BuildBWPDlDedPdschCfg
3803  *
3804  *    Functionality: Builds BWP DL dedicated PDSCH config
3805  *
3806  * @params[in] struct PDSCH_Config *pdschCfg
3807  *
3808  * @return ROK     - success
3809  *         RFAILED - failure
3810  *
3811  * ****************************************************************/
3812 uint8_t BuildBWPDlDedPdschCfg(struct PDSCH_Config *pdschCfg)
3813 {
3814    pdschCfg->dataScramblingIdentityPDSCH = NULLP;
3815
3816    pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA = NULLP;
3817    CU_ALLOC(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA, \
3818          sizeof(struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA));
3819    if(!pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA)
3820    {
3821       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
3822       return RFAILED;
3823    }
3824
3825    if(BuildDMRSDLPdschMapTypeA(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA) != ROK)
3826    {
3827       return RFAILED;
3828    }
3829
3830    pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeB = NULLP;
3831    pdschCfg->tci_StatesToAddModList = NULLP;
3832    pdschCfg->tci_StatesToReleaseList = NULLP;
3833    pdschCfg->vrb_ToPRB_Interleaver = NULLP;
3834 #if 0
3835    CU_ALLOC(pdschCfg->tci_StatesToAddModList, sizeof(struct PDSCH_Config__tci_StatesToAddModList));
3836    if(!pdschCfg->tci_StatesToAddModList)
3837    {
3838       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
3839       return RFAILED;
3840    }
3841    if(BuildTCIStatesToAddModList(pdschCfg->tci_StatesToAddModList) != ROK)
3842    {
3843       return RFAILED;
3844    }
3845 #endif
3846
3847    pdschCfg->resourceAllocation = RES_ALLOC_TYPE;
3848
3849    pdschCfg->pdsch_TimeDomainAllocationList = NULLP;
3850    CU_ALLOC(pdschCfg->pdsch_TimeDomainAllocationList, \
3851          sizeof(struct PDSCH_Config__pdsch_TimeDomainAllocationList));
3852    if(!pdschCfg->pdsch_TimeDomainAllocationList)
3853    {
3854       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
3855       return RFAILED;
3856    }
3857    if(BuildPdschTimeDomAllocList(pdschCfg->pdsch_TimeDomainAllocationList) != ROK)
3858    {
3859       return RFAILED;
3860    }
3861    pdschCfg->pdsch_AggregationFactor = NULLP;
3862    pdschCfg->rateMatchPatternToAddModList = NULLP;
3863    pdschCfg->rateMatchPatternToReleaseList = NULLP;
3864    pdschCfg->rateMatchPatternGroup1 = NULLP;
3865    pdschCfg->rateMatchPatternGroup2 = NULLP;
3866    pdschCfg->rbg_Size = PDSCH_RBG_SIZE;
3867    pdschCfg->mcs_Table = NULLP;
3868
3869    pdschCfg->maxNrofCodeWordsScheduledByDCI = NULLP;
3870    CU_ALLOC(pdschCfg->maxNrofCodeWordsScheduledByDCI, sizeof(long));
3871    if(!pdschCfg->maxNrofCodeWordsScheduledByDCI)
3872    {
3873       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
3874       return RFAILED;
3875    }
3876    *(pdschCfg->maxNrofCodeWordsScheduledByDCI) = PDSCH_MAX_CODEWORD_SCH_BY_DCI;
3877
3878    if(BuildPdschPrbBundlingType(&pdschCfg->prb_BundlingType) != ROK)
3879    {
3880       return RFAILED;
3881    }
3882
3883    pdschCfg->zp_CSI_RS_ResourceToAddModList = NULLP;
3884    pdschCfg->zp_CSI_RS_ResourceToReleaseList = NULLP;
3885    pdschCfg->aperiodic_ZP_CSI_RS_ResourceSetsToAddModList = NULLP;
3886    pdschCfg->aperiodic_ZP_CSI_RS_ResourceSetsToReleaseList = NULLP;
3887    pdschCfg->sp_ZP_CSI_RS_ResourceSetsToAddModList = NULLP;
3888    pdschCfg->sp_ZP_CSI_RS_ResourceSetsToReleaseList = NULLP;
3889    pdschCfg->p_ZP_CSI_RS_ResourceSet = NULLP;
3890
3891    return ROK;
3892 }
3893
3894 /*******************************************************************
3895  *
3896  * @brief Builds intitial DL BWP
3897  * @details
3898  *
3899  *    Function : BuildInitialDlBWP
3900  *
3901  *    Functionality: Builds intitial DL BWP in spCellCfgDed
3902  *
3903  * @params[in] BWP_DownlinkDedicated_t *dlBwp
3904  *
3905  * @return ROK     - success
3906  *         RFAILED - failure
3907  *
3908  * ****************************************************************/
3909 uint8_t BuildInitialDlBWP(BWP_DownlinkDedicated_t *dlBwp)
3910 {
3911    dlBwp->pdcch_Config = NULLP;
3912    CU_ALLOC(dlBwp->pdcch_Config, sizeof(struct BWP_DownlinkDedicated__pdcch_Config));
3913    if(!dlBwp->pdcch_Config)
3914    {
3915       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failure in BuildInitialDlBWP");
3916       return RFAILED;
3917    }
3918    dlBwp->pdcch_Config->present = BWP_DownlinkDedicated__pdcch_Config_PR_setup;
3919
3920    dlBwp->pdcch_Config->choice.setup = NULLP;
3921    CU_ALLOC(dlBwp->pdcch_Config->choice.setup, sizeof(struct PDCCH_Config));
3922    if(!dlBwp->pdcch_Config->choice.setup)
3923    {
3924       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failure in BuildInitialDlBWP");
3925       return RFAILED;
3926    }
3927    if(BuildBWPDlDedPdcchCfg(dlBwp->pdcch_Config->choice.setup) != ROK)
3928    {
3929       return RFAILED;
3930    }
3931
3932    dlBwp->pdsch_Config = NULLP;
3933    CU_ALLOC(dlBwp->pdsch_Config, sizeof(struct BWP_DownlinkDedicated__pdsch_Config));
3934    if(!dlBwp->pdsch_Config)
3935    {
3936       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failure in BuildInitialDlBWP");
3937       return RFAILED;
3938    }
3939    dlBwp->pdsch_Config->present = BWP_DownlinkDedicated__pdsch_Config_PR_setup;
3940
3941    dlBwp->pdsch_Config->choice.setup = NULLP;
3942    CU_ALLOC(dlBwp->pdsch_Config->choice.setup, sizeof(struct PDSCH_Config));
3943    if(!dlBwp->pdsch_Config->choice.setup)
3944    {
3945       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failure in BuildInitialDlBWP");
3946       return RFAILED;
3947    }
3948
3949    if(BuildBWPDlDedPdschCfg(dlBwp->pdsch_Config->choice.setup) != ROK)
3950    {
3951       return RFAILED;
3952    }
3953
3954    dlBwp->sps_Config = NULLP;
3955    dlBwp->radioLinkMonitoringConfig = NULLP;
3956    return ROK;
3957 }
3958
3959 /*******************************************************************
3960  *
3961  * @brief Builds DMRS UL Pusch Mapping type A
3962  *
3963  * @details
3964  *
3965  *    Function : BuildDMRSULPuschMapTypeA
3966  *
3967  *    Functionality: Builds DMRS UL Pusch Mapping type A
3968  *
3969  * @params[in]
3970  *    struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA *dmrsUlCfg
3971  * @return ROK     - success
3972  *         RFAILED - failure
3973  *
3974  * ****************************************************************/
3975    uint8_t BuildDMRSULPuschMapTypeA
3976 (
3977  struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA *dmrsUlCfg
3978  )
3979 {
3980    dmrsUlCfg->present = PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA_PR_setup;
3981    dmrsUlCfg->choice.setup= NULLP;
3982    CU_ALLOC(dmrsUlCfg->choice.setup, sizeof(DMRS_UplinkConfig_t));
3983    if(!dmrsUlCfg->choice.setup)
3984    {
3985       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
3986       return RFAILED;
3987    }
3988
3989    dmrsUlCfg->choice.setup->dmrs_Type = NULLP;
3990    dmrsUlCfg->choice.setup->dmrs_AdditionalPosition = NULLP;
3991    CU_ALLOC(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition, sizeof(long));
3992    if(!dmrsUlCfg->choice.setup->dmrs_AdditionalPosition)
3993    {
3994       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
3995       return RFAILED;
3996    }
3997    *(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition) = DMRS_ADDITIONAL_POS;
3998
3999    dmrsUlCfg->choice.setup->phaseTrackingRS = NULLP;
4000    dmrsUlCfg->choice.setup->maxLength = NULLP;
4001    dmrsUlCfg->choice.setup->transformPrecodingDisabled = NULLP;
4002    CU_ALLOC(dmrsUlCfg->choice.setup->transformPrecodingDisabled, \
4003          sizeof(struct DMRS_UplinkConfig__transformPrecodingDisabled));
4004    if(!dmrsUlCfg->choice.setup->transformPrecodingDisabled)
4005    {
4006       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
4007       return RFAILED;
4008    }
4009
4010    dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0 = NULLP;
4011    CU_ALLOC(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0,\
4012          sizeof(long));
4013    if(!dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0)
4014    {
4015       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
4016       return RFAILED;
4017    }
4018    *(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0) = SCRAMBLING_ID;
4019
4020    dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID1 = NULLP;
4021    dmrsUlCfg->choice.setup->transformPrecodingEnabled = NULLP;
4022    return ROK;
4023 }
4024
4025 /*******************************************************************
4026  *
4027  * @brief Build PUSCH time domain allocation list
4028  *
4029  * @details
4030  *
4031  *    Function : BuildPuschTimeDomAllocList
4032  *
4033  *    Functionality: Build PUSCH time domain allocation list
4034  *
4035  * @params[in]
4036  * struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList
4037  *
4038  * @return ROK     - success
4039  *         RFAILED - failure
4040  *
4041  * ****************************************************************/
4042    uint8_t BuildPuschTimeDomAllocList
4043 (
4044  struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList
4045  )
4046 {
4047    uint8_t idx;
4048    uint8_t elementCnt;
4049    PUSCH_TimeDomainResourceAllocation_t  *timeDomAlloc;
4050
4051    timeDomAllocList->present = PUSCH_Config__pusch_TimeDomainAllocationList_PR_setup;
4052    timeDomAllocList->choice.setup = NULLP;
4053    CU_ALLOC(timeDomAllocList->choice.setup, \
4054          sizeof(struct PUSCH_TimeDomainResourceAllocationList));
4055    if(!timeDomAllocList->choice.setup)
4056    {
4057       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
4058       return RFAILED;
4059    }
4060
4061    elementCnt = 2;
4062    timeDomAllocList->choice.setup->list.count = elementCnt;
4063    timeDomAllocList->choice.setup->list.size = \
4064                                                elementCnt * sizeof(PUSCH_TimeDomainResourceAllocation_t *);
4065    timeDomAllocList->choice.setup->list.array = NULLP;
4066    CU_ALLOC(timeDomAllocList->choice.setup->list.array, \
4067          timeDomAllocList->choice.setup->list.size);
4068    if(!timeDomAllocList->choice.setup->list.array)
4069    {
4070       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
4071       return RFAILED;
4072    }
4073
4074    for(idx = 0; idx < elementCnt; idx++)
4075    {
4076       timeDomAllocList->choice.setup->list.array[idx] = NULLP;
4077       CU_ALLOC(timeDomAllocList->choice.setup->list.array[idx],\
4078             sizeof(PUSCH_TimeDomainResourceAllocation_t));
4079       if(!timeDomAllocList->choice.setup->list.array[idx])
4080       {
4081          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
4082          return RFAILED;
4083       }
4084    }
4085
4086    idx = 0;
4087    timeDomAlloc = timeDomAllocList->choice.setup->list.array[idx];
4088    CU_ALLOC(timeDomAlloc->k2, sizeof(long));
4089    if(!timeDomAlloc->k2)
4090    {
4091       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
4092       return RFAILED;
4093    }
4094    *(timeDomAlloc->k2) = PUSCH_K2_CFG1;
4095    timeDomAlloc->mappingType = PUSCH_MAPPING_TYPE_A;
4096    timeDomAlloc->startSymbolAndLength = 66;
4097
4098    idx++;
4099    timeDomAlloc = timeDomAllocList->choice.setup->list.array[idx];
4100    CU_ALLOC(timeDomAlloc->k2, sizeof(long));
4101    if(!timeDomAlloc->k2)
4102    {
4103        DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
4104        return RFAILED;
4105    }
4106    *(timeDomAlloc->k2) = PUSCH_K2_CFG2;
4107    timeDomAlloc->mappingType = PUSCH_MAPPING_TYPE_A;
4108    timeDomAlloc->startSymbolAndLength = 66;
4109
4110    return ROK;
4111 }
4112
4113 /*******************************************************************
4114  *
4115  * @brief Builds BWP UL dedicated PUSCH Config
4116  *
4117  * @details
4118  *
4119  *    Function : BuildBWPUlDedPuschCfg
4120  *
4121  *    Functionality:
4122  *      Builds BWP UL dedicated PUSCH Config
4123  *
4124  * @params[in] : PUSCH_Config_t *puschCfg
4125  *
4126  * @return ROK     - success
4127  *         RFAILED - failure
4128  *
4129  * ****************************************************************/
4130 uint8_t BuildBWPUlDedPuschCfg(PUSCH_Config_t *puschCfg)
4131 {
4132    puschCfg->dataScramblingIdentityPUSCH = NULLP;
4133    CU_ALLOC(puschCfg->dataScramblingIdentityPUSCH, sizeof(long));
4134    if(!puschCfg->dataScramblingIdentityPUSCH)
4135    {
4136       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
4137       return RFAILED;
4138    }
4139    *(puschCfg->dataScramblingIdentityPUSCH) = SCRAMBLING_ID;
4140
4141    puschCfg->txConfig = NULLP;
4142    puschCfg->dmrs_UplinkForPUSCH_MappingTypeA = NULLP;
4143    CU_ALLOC(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA, \
4144          sizeof(struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA));
4145    if(!puschCfg->dmrs_UplinkForPUSCH_MappingTypeA)
4146    {
4147       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
4148       return RFAILED;
4149    }
4150
4151    if(BuildDMRSULPuschMapTypeA(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA) != ROK)
4152    {
4153       return RFAILED;
4154    }
4155
4156    puschCfg->dmrs_UplinkForPUSCH_MappingTypeB = NULLP;
4157    puschCfg->pusch_PowerControl = NULLP;
4158    puschCfg->frequencyHopping = NULLP;
4159    puschCfg->frequencyHoppingOffsetLists = NULLP;
4160    puschCfg->resourceAllocation = RES_ALLOC_TYPE;
4161
4162    puschCfg->pusch_TimeDomainAllocationList = NULLP;
4163    CU_ALLOC(puschCfg->pusch_TimeDomainAllocationList, \
4164          sizeof(struct PUSCH_Config__pusch_TimeDomainAllocationList));
4165    if(!puschCfg->pusch_TimeDomainAllocationList)
4166    {
4167       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
4168       return RFAILED;
4169    }
4170
4171    if(BuildPuschTimeDomAllocList(puschCfg->pusch_TimeDomainAllocationList) != ROK)
4172    {
4173       return RFAILED;
4174    }
4175
4176    puschCfg->pusch_AggregationFactor = NULLP;
4177    puschCfg->mcs_Table = NULLP;
4178    puschCfg->mcs_TableTransformPrecoder = NULLP;
4179    puschCfg->transformPrecoder = NULLP;
4180    CU_ALLOC(puschCfg->transformPrecoder, sizeof(long));
4181    if(!puschCfg->transformPrecoder)
4182    {
4183       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
4184       return RFAILED;
4185    }
4186    *(puschCfg->transformPrecoder) = PUSCH_TRANSFORM_PRECODER;
4187
4188    puschCfg->codebookSubset = NULLP;
4189    puschCfg->maxRank = NULLP;
4190    puschCfg->rbg_Size = NULLP;
4191    puschCfg->uci_OnPUSCH = NULLP;
4192    puschCfg->tp_pi2BPSK = NULLP;
4193
4194    return ROK;
4195 }
4196
4197 /*******************************************************************
4198  *
4199  * @brief Builds BWP UL dedicated PUCCH Config
4200  *
4201  * @details
4202  *
4203  *    Function : BuildBWPUlDedPucchCfg
4204  *
4205  *    Functionality:
4206  *      Builds BWP UL dedicated PUCCH Config
4207  *
4208  * @params[in] : PUCCH_Config_t *pucchCfg
4209  *
4210  * @return ROK     - success
4211  *         RFAILED - failure
4212  *
4213  * ****************************************************************/
4214 uint8_t BuildBWPUlDedPucchCfg(PUCCH_Config_t *pucchCfg)
4215 {
4216    uint8_t arrIdx, elementCnt;
4217    uint8_t rsrcIdx, rsrcSetIdx;
4218    PUCCH_ResourceSet_t *rsrcSet = NULLP;
4219    PUCCH_Resource_t *rsrc = NULLP;
4220
4221    //RESOURCE SET
4222    elementCnt = 1;
4223    CU_ALLOC(pucchCfg->resourceSetToAddModList, sizeof(struct PUCCH_Config__resourceSetToAddModList));
4224    pucchCfg->resourceSetToAddModList->list.count = elementCnt;
4225    pucchCfg->resourceSetToAddModList->list.size = elementCnt * sizeof(PUCCH_ResourceSet_t *);
4226    CU_ALLOC(pucchCfg->resourceSetToAddModList->list.array, pucchCfg->resourceSetToAddModList->list.size);
4227    for(rsrcSetIdx=0; rsrcSetIdx < pucchCfg->resourceSetToAddModList->list.count; rsrcSetIdx++)
4228    {
4229       CU_ALLOC(pucchCfg->resourceSetToAddModList->list.array[rsrcSetIdx], sizeof(PUCCH_ResourceSet_t));
4230    }
4231    rsrcSetIdx = 0;
4232    rsrcSet = pucchCfg->resourceSetToAddModList->list.array[rsrcSetIdx];
4233    rsrcSet->pucch_ResourceSetId = 1;
4234    elementCnt = 1;
4235    rsrcSet->resourceList.list.count = elementCnt;
4236    rsrcSet->resourceList.list.size = elementCnt * sizeof(PUCCH_ResourceId_t *);
4237    CU_ALLOC(rsrcSet->resourceList.list.array, rsrcSet->resourceList.list.size);
4238    for(rsrcIdx=0; rsrcIdx < rsrcSet->resourceList.list.count; rsrcIdx++)
4239    {
4240       CU_ALLOC(rsrcSet->resourceList.list.array[rsrcIdx], sizeof(PUCCH_ResourceId_t));
4241    }
4242    rsrcIdx = 0;
4243    *(rsrcSet->resourceList.list.array[rsrcIdx]) = 1;
4244
4245    //RESOURCE
4246    elementCnt = 1;
4247    CU_ALLOC(pucchCfg->resourceToAddModList, sizeof(struct PUCCH_Config__resourceToAddModList));
4248    pucchCfg->resourceToAddModList->list.count = elementCnt;
4249    pucchCfg->resourceToAddModList->list.size = elementCnt * sizeof(PUCCH_Resource_t *);
4250    CU_ALLOC(pucchCfg->resourceToAddModList->list.array, pucchCfg->resourceToAddModList->list.size);
4251    for(rsrcIdx=0; rsrcIdx < pucchCfg->resourceToAddModList->list.count; rsrcIdx++)
4252    {
4253       CU_ALLOC(pucchCfg->resourceToAddModList->list.array[rsrcIdx], sizeof(PUCCH_Resource_t));
4254    }
4255    rsrcIdx = 0;
4256    rsrc = pucchCfg->resourceToAddModList->list.array[rsrcIdx];
4257    rsrc->pucch_ResourceId = 1;
4258    rsrc->startingPRB = 0;
4259    rsrc->format.present = PUCCH_Resource__format_PR_format1;
4260    CU_ALLOC(rsrc->format.choice.format1, sizeof(PUCCH_format1_t));
4261    rsrc->format.choice.format1->initialCyclicShift = 0;
4262    rsrc->format.choice.format1->nrofSymbols = 4;
4263    rsrc->format.choice.format1->startingSymbolIndex = 0;
4264    rsrc->format.choice.format1->timeDomainOCC = 0;
4265
4266    //PUCCH Format 1
4267    CU_ALLOC(pucchCfg->format1, sizeof(struct PUCCH_Config__format1));
4268    pucchCfg->format1->present = PUCCH_Config__format1_PR_setup;
4269    CU_ALLOC(pucchCfg->format1->choice.setup, sizeof(PUCCH_FormatConfig_t));
4270    CU_ALLOC(pucchCfg->format1->choice.setup->nrofSlots, sizeof(long));
4271    *(pucchCfg->format1->choice.setup->nrofSlots) = PUCCH_FormatConfig__nrofSlots_n4;
4272
4273    //DL DATA TO UL ACK
4274    CU_ALLOC(pucchCfg->dl_DataToUL_ACK, sizeof(struct PUCCH_Config__dl_DataToUL_ACK));
4275    if(pucchCfg->dl_DataToUL_ACK == NULLP)
4276    {
4277       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
4278       return RFAILED;
4279    }
4280
4281    elementCnt = 2;
4282    pucchCfg->dl_DataToUL_ACK->list.count = elementCnt;
4283    pucchCfg->dl_DataToUL_ACK->list.size = elementCnt * sizeof(long *);
4284    CU_ALLOC(pucchCfg->dl_DataToUL_ACK->list.array, pucchCfg->dl_DataToUL_ACK->list.size);
4285    if(pucchCfg->dl_DataToUL_ACK->list.array == NULLP)
4286    {
4287       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
4288       return RFAILED;
4289    }
4290
4291    for(arrIdx = 0; arrIdx <  pucchCfg->dl_DataToUL_ACK->list.count; arrIdx++)
4292    {
4293       CU_ALLOC(pucchCfg->dl_DataToUL_ACK->list.array[arrIdx], sizeof(long));
4294       if(pucchCfg->dl_DataToUL_ACK->list.array[arrIdx] == NULLP)
4295       {
4296           DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
4297           return RFAILED;
4298       }
4299    }
4300
4301    arrIdx = 0;
4302    *(pucchCfg->dl_DataToUL_ACK->list.array[arrIdx++]) = 4;
4303    *(pucchCfg->dl_DataToUL_ACK->list.array[arrIdx]) = 5;
4304
4305    return ROK;
4306 }
4307
4308 /*******************************************************************
4309  *
4310  * @brief Fills SRS resource to add/modify list
4311  *
4312  * @details
4313  *
4314  *    Function : BuildSrsRsrcAddModList
4315  *
4316  *    Functionality: Fills SRS resource to add/modify list
4317  *
4318  * @params[in]
4319  * @return ROK     - success
4320  *         RFAILED - failure
4321  *
4322  * ****************************************************************/
4323 uint8_t BuildSrsRsrcAddModList(struct SRS_Config__srs_ResourceToAddModList *resourceList)
4324 {
4325    uint8_t   elementCnt;
4326    uint8_t   rsrcIdx;
4327
4328    elementCnt = 1;
4329    resourceList->list.count = elementCnt;
4330    resourceList->list.size = elementCnt * sizeof(SRS_Resource_t *);
4331    resourceList->list.array = NULLP;
4332    CU_ALLOC(resourceList->list.array, resourceList->list.size);
4333    if(!resourceList->list.array)
4334    {
4335       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed in BuildSrsRsrcAddModList");
4336       return RFAILED;
4337    }
4338
4339    for(rsrcIdx = 0; rsrcIdx < resourceList->list.count; rsrcIdx++)
4340    {
4341       CU_ALLOC(resourceList->list.array[rsrcIdx], sizeof(SRS_Resource_t));
4342       if(!resourceList->list.array[rsrcIdx])
4343       {
4344          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed in BuildSrsRsrcAddModList");
4345          return RFAILED;
4346       }
4347    }
4348
4349    rsrcIdx = 0;
4350    resourceList->list.array[rsrcIdx]->srs_ResourceId = SRS_RSRC_ID;
4351    resourceList->list.array[rsrcIdx]->nrofSRS_Ports = SRS_Resource__nrofSRS_Ports_port1;
4352    resourceList->list.array[rsrcIdx]->transmissionComb.present = SRS_Resource__transmissionComb_PR_n2;
4353
4354    resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2 = NULLP;
4355    CU_ALLOC(resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2, \
4356          sizeof(struct SRS_Resource__transmissionComb__n2));
4357    if(!resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2)
4358    {
4359       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed in BuildSrsRsrcAddModList");
4360       return RFAILED;
4361    }
4362    resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2->combOffset_n2\
4363       = SRS_COMB_OFFSET_N2;
4364    resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2->cyclicShift_n2\
4365       = SRS_CYCLIC_SHIFT_N2;
4366
4367    resourceList->list.array[rsrcIdx]->resourceMapping.startPosition = PUSCH_START_SYMBOL;
4368    resourceList->list.array[rsrcIdx]->resourceMapping.nrofSymbols =  \
4369                                                                      SRS_Resource__resourceMapping__nrofSymbols_n1;
4370    resourceList->list.array[rsrcIdx]->resourceMapping.repetitionFactor = \
4371                                                                          SRS_Resource__resourceMapping__repetitionFactor_n1;
4372
4373    resourceList->list.array[rsrcIdx]->freqDomainPosition = SRS_FREQ_DOM_POS;
4374    resourceList->list.array[rsrcIdx]->freqDomainShift = SRS_FREQ_DOM_SHIFT;
4375    resourceList->list.array[rsrcIdx]->freqHopping.c_SRS = C_SRS;
4376    resourceList->list.array[rsrcIdx]->freqHopping.b_SRS = B_SRS;
4377    resourceList->list.array[rsrcIdx]->freqHopping.b_hop = B_HOP;
4378    resourceList->list.array[rsrcIdx]->groupOrSequenceHopping = \
4379                                                                SRS_Resource__groupOrSequenceHopping_neither;
4380
4381    /* Setting resource type to aperiodic for intergration purposes */
4382    resourceList->list.array[rsrcIdx]->resourceType.present = \
4383                                                              SRS_Resource__resourceType_PR_aperiodic;
4384    resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic = NULLP;
4385    CU_ALLOC(resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic,
4386          sizeof(struct SRS_Resource__resourceType__aperiodic));
4387    if(!resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic)
4388    {
4389       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed in BuildSrsRsrcAddModList");
4390       return RFAILED;
4391    }
4392    resourceList->list.array[rsrcIdx]->sequenceId = SRS_SEQ_ID;
4393
4394    return ROK;
4395 }
4396
4397 /*******************************************************************
4398  *
4399  * @brief Build SRS resource set Add/mod list
4400  *
4401  * @details
4402  *
4403  *    Function : BuildSrsRsrcSetAddModList
4404  *
4405  *    Functionality: Build SRS resource set Add/mod list
4406  *
4407  * @params[in]
4408  * @return ROK     - success
4409  *         RFAILED - failure
4410  *
4411  * ****************************************************************/
4412    uint8_t BuildSrsRsrcSetAddModList
4413 (
4414  struct SRS_Config__srs_ResourceSetToAddModList *rsrcSetList
4415  )
4416 {
4417    uint8_t  elementCnt;
4418    uint8_t  rSetIdx;
4419    uint8_t  rsrcIdx;
4420    struct SRS_ResourceSet__srs_ResourceIdList *rsrcIdList;
4421
4422    elementCnt = 1;
4423    rsrcSetList->list.count = elementCnt;
4424    rsrcSetList->list.size = elementCnt * sizeof(SRS_ResourceSet_t *);
4425    rsrcSetList->list.array = NULLP;
4426    CU_ALLOC(rsrcSetList->list.array, rsrcSetList->list.size);
4427    if(!rsrcSetList->list.array)
4428    {
4429       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed in BuildSrsRsrcSetAddModList");
4430       return RFAILED;
4431    }
4432
4433    for(rSetIdx = 0; rSetIdx < rsrcSetList->list.count; rSetIdx++)
4434    {
4435       CU_ALLOC(rsrcSetList->list.array[rSetIdx], sizeof(SRS_ResourceSet_t));
4436       if(!rsrcSetList->list.array[rSetIdx])
4437       {
4438          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed in BuildSrsRsrcSetAddModList");
4439          return RFAILED;
4440       }
4441    }
4442
4443    rSetIdx = 0;
4444    rsrcSetList->list.array[rSetIdx]->srs_ResourceSetId = SRS_RSET_ID;
4445
4446    /* Fill Resource Id list in resource set */
4447    rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList = NULLP;
4448    CU_ALLOC(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList,\
4449          sizeof(struct SRS_ResourceSet__srs_ResourceIdList));
4450    if(!rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList)
4451    {
4452       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
4453       return RFAILED;
4454    }
4455
4456    elementCnt = 1;
4457    rsrcIdList = rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList;
4458    rsrcIdList->list.count = elementCnt;
4459    rsrcIdList->list.size = elementCnt * sizeof(SRS_ResourceId_t *);
4460    rsrcIdList->list.array = NULLP;
4461    CU_ALLOC(rsrcIdList->list.array, rsrcIdList->list.size);
4462    if(!rsrcIdList->list.array)
4463    {
4464       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed in BuildSrsRsrcSetAddModList");
4465       return RFAILED;
4466    }
4467
4468    for(rsrcIdx = 0; rsrcIdx < rsrcIdList->list.count; rsrcIdx++)
4469    {
4470       CU_ALLOC(rsrcIdList->list.array[rsrcIdx], sizeof(SRS_ResourceId_t));
4471       if(!rsrcIdList->list.array[rsrcIdx])
4472       {
4473          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed in BuildSrsRsrcSetAddModList");
4474          return RFAILED;
4475       }
4476    }
4477
4478    rsrcIdx = 0;
4479    *rsrcIdList->list.array[rsrcIdx] = SRS_RSRC_ID;
4480
4481    /* Fill resource type */
4482    rsrcSetList->list.array[rSetIdx]->resourceType.present = \
4483                                                             SRS_ResourceSet__resourceType_PR_aperiodic;
4484
4485    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic = NULLP;
4486    CU_ALLOC(rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic, \
4487          sizeof(struct SRS_ResourceSet__resourceType__aperiodic));
4488    if(!rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic)
4489    {
4490       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed in BuildSrsRsrcSetAddModList");
4491       return RFAILED;
4492    }
4493    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic->aperiodicSRS_ResourceTrigger \
4494       = APERIODIC_SRS_RESRC_TRIGGER;
4495
4496    /* TODO : Fill values for below IEs as expected by Viavi */
4497    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic->csi_RS = NULLP;
4498    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic->slotOffset = NULLP;
4499
4500
4501    rsrcSetList->list.array[rSetIdx]->usage = SRS_ResourceSet__usage_codebook;
4502    rsrcSetList->list.array[rSetIdx]->alpha = NULLP;
4503    rsrcSetList->list.array[rSetIdx]->p0 = NULLP;
4504    rsrcSetList->list.array[rSetIdx]->pathlossReferenceRS = NULLP;
4505    rsrcSetList->list.array[rSetIdx]->srs_PowerControlAdjustmentStates = NULLP;
4506
4507    return ROK;
4508 }
4509
4510 /*******************************************************************
4511  *
4512  * @brief Builds BWP UL dedicated SRS Config
4513  *
4514  * @details
4515  *
4516  *    Function : BuildBWPUlDedSrsCfg
4517  *
4518  *    Functionality: Builds BWP UL dedicated SRS Config
4519  *
4520  * @params[in] SRS Config
4521  * @return ROK     - success
4522  *         RFAILED - failure
4523  *
4524  * ****************************************************************/
4525 uint8_t BuildBWPUlDedSrsCfg(SRS_Config_t *srsCfg)
4526 {
4527    srsCfg->srs_ResourceSetToReleaseList = NULLP;
4528    srsCfg->srs_ResourceSetToAddModList = NULLP;
4529    CU_ALLOC(srsCfg->srs_ResourceSetToAddModList, \
4530          sizeof(struct SRS_Config__srs_ResourceSetToAddModList));
4531    if(!srsCfg->srs_ResourceSetToAddModList)
4532    {
4533       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed in BuildBWPUlDedSrsCfg");
4534       return RFAILED;
4535    }
4536    if(BuildSrsRsrcSetAddModList(srsCfg->srs_ResourceSetToAddModList) != ROK)
4537    {
4538       return RFAILED;
4539    }
4540
4541    srsCfg->srs_ResourceToReleaseList = NULLP;
4542
4543    /* Resource to Add/Modify list */
4544    srsCfg->srs_ResourceToAddModList = NULLP;
4545    CU_ALLOC(srsCfg->srs_ResourceToAddModList, \
4546          sizeof(struct SRS_Config__srs_ResourceToAddModList));
4547    if(!srsCfg->srs_ResourceToAddModList)
4548    {
4549       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed in BuildBWPUlDedSrsCfg");
4550       return RFAILED;
4551    }
4552
4553    if(BuildSrsRsrcAddModList(srsCfg->srs_ResourceToAddModList) != ROK)
4554    {
4555       return RFAILED;
4556    }
4557
4558    srsCfg->tpc_Accumulation = NULLP;
4559
4560    return ROK;
4561 }
4562
4563 /*******************************************************************
4564  *
4565  * @brief Builds inital UL BWP
4566  *
4567  * @details
4568  *
4569  *    Function : BuildInitialUlBWP
4570  *
4571  *    Functionality: Builds initial UL BWP
4572  *
4573  * @params[in] BWP_UplinkDedicated_t *ulBwp
4574  * @return ROK     - success
4575  *         RFAILED - failure
4576  *
4577  * ****************************************************************/
4578 uint8_t BuildInitialUlBWP(BWP_UplinkDedicated_t *ulBwp)
4579 {
4580    ulBwp->pucch_Config = NULLP;
4581    ulBwp->pucch_Config = NULLP;
4582    CU_ALLOC(ulBwp->pucch_Config, sizeof(struct BWP_UplinkDedicated__pucch_Config));
4583    if(!ulBwp->pucch_Config)
4584    {
4585       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
4586       return RFAILED;
4587    }
4588
4589    ulBwp->pucch_Config->present = BWP_UplinkDedicated__pucch_Config_PR_setup;
4590    ulBwp->pucch_Config->choice.setup = NULLP;
4591    CU_ALLOC(ulBwp->pucch_Config->choice.setup, sizeof(PUCCH_Config_t));
4592    if(!ulBwp->pucch_Config->choice.setup)
4593    {
4594       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
4595       return RFAILED;
4596    }
4597
4598    if(BuildBWPUlDedPucchCfg(ulBwp->pucch_Config->choice.setup) != ROK)
4599    {
4600       return RFAILED;
4601    }
4602
4603    /* Fill BWP UL dedicated PUSCH config */
4604    ulBwp->pusch_Config = NULLP;
4605    CU_ALLOC(ulBwp->pusch_Config, sizeof(struct BWP_UplinkDedicated__pusch_Config));
4606    if(!ulBwp->pusch_Config)
4607    {
4608       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
4609       return RFAILED;
4610    }
4611
4612    ulBwp->pusch_Config->present = BWP_UplinkDedicated__pusch_Config_PR_setup;
4613    ulBwp->pusch_Config->choice.setup = NULLP;
4614    CU_ALLOC(ulBwp->pusch_Config->choice.setup, sizeof(PUSCH_Config_t));
4615    if(!ulBwp->pusch_Config->choice.setup)
4616    {
4617       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
4618       return RFAILED;
4619    }
4620
4621    if(BuildBWPUlDedPuschCfg(ulBwp->pusch_Config->choice.setup) != ROK)
4622    {
4623       return RFAILED;
4624    }
4625
4626    ulBwp->configuredGrantConfig = NULLP;
4627
4628    /* Fill BPW UL dedicated SRS config */
4629    ulBwp->srs_Config = NULLP;
4630    CU_ALLOC(ulBwp->srs_Config, sizeof(struct BWP_UplinkDedicated__srs_Config));
4631    if(!ulBwp->srs_Config)
4632    {
4633       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
4634       return RFAILED;
4635    }
4636
4637    ulBwp->srs_Config->present = BWP_UplinkDedicated__srs_Config_PR_setup;
4638    ulBwp->srs_Config->choice.setup = NULLP;
4639    CU_ALLOC(ulBwp->srs_Config->choice.setup, sizeof(SRS_Config_t));
4640    if(!ulBwp->srs_Config->choice.setup)
4641    {
4642       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
4643       return RFAILED;
4644    }
4645
4646    if(BuildBWPUlDedSrsCfg(ulBwp->srs_Config->choice.setup) != ROK)
4647    {
4648       return RFAILED;
4649    }
4650
4651    ulBwp->beamFailureRecoveryConfig = NULLP;
4652
4653    return ROK;
4654 }
4655
4656 /*******************************************************************
4657  *
4658  * @brief Builds Pusch Serving cell Config
4659  *
4660  * @details
4661  *
4662  *    Function : BuildPuschSrvCellCfg
4663  *
4664  *    Functionality: Builds Pusch Serving cell Config
4665  *
4666  * @params[in] struct UplinkConfig__pusch_ServingCellConfig *puschCfg
4667  *
4668  * @return ROK     - success
4669  *         RFAILED - failure
4670  *
4671  * ****************************************************************/
4672 uint8_t BuildPuschSrvCellCfg(struct UplinkConfig__pusch_ServingCellConfig *puschCfg)
4673 {
4674    puschCfg->present = UplinkConfig__pusch_ServingCellConfig_PR_setup;
4675    puschCfg->choice.setup = NULLP;
4676    CU_ALLOC(puschCfg->choice.setup, sizeof(struct PUSCH_ServingCellConfig));
4677    if(!puschCfg->choice.setup)
4678    {
4679       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
4680       return RFAILED;
4681    }
4682
4683    puschCfg->choice.setup->codeBlockGroupTransmission = NULLP;
4684    puschCfg->choice.setup->rateMatching = NULLP;
4685    puschCfg->choice.setup->xOverhead = NULLP;
4686    puschCfg->choice.setup->ext1 = NULLP;
4687    CU_ALLOC(puschCfg->choice.setup->ext1, sizeof(struct PUSCH_ServingCellConfig__ext1));
4688    if(!puschCfg->choice.setup->ext1)
4689    {
4690       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
4691       return RFAILED;
4692    }
4693
4694    puschCfg->choice.setup->ext1->maxMIMO_Layers = NULLP;
4695    CU_ALLOC(puschCfg->choice.setup->ext1->maxMIMO_Layers, sizeof(long));
4696    if(!puschCfg->choice.setup->ext1->maxMIMO_Layers)
4697    {
4698       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
4699       return RFAILED;
4700    }
4701    *(puschCfg->choice.setup->ext1->maxMIMO_Layers) = PUSCH_MAX_MIMO_LAYERS;
4702
4703    puschCfg->choice.setup->ext1->processingType2Enabled= NULLP;
4704    CU_ALLOC(puschCfg->choice.setup->ext1->processingType2Enabled,sizeof(BOOLEAN_t));
4705    if(!puschCfg->choice.setup->ext1->processingType2Enabled)
4706    {
4707       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
4708       return RFAILED;
4709    }
4710    *(puschCfg->choice.setup->ext1->processingType2Enabled) = PUSCH_PROCESS_TYPE2_ENABLED;
4711    return ROK;
4712 }
4713
4714 /*******************************************************************
4715  *
4716  * @brief Builds UL config
4717  * @details
4718  *
4719  *    Function : BuildUlCfg
4720  *
4721  *    Functionality: Builds UL config in spCellCfgDed
4722  *
4723  * @params[in] UplinkConfig_t *ulCfg
4724  *
4725  * @return ROK     - success
4726  *         RFAILED - failure
4727  *
4728  * ****************************************************************/
4729 uint8_t BuildUlCfg(UplinkConfig_t *ulCfg)
4730 {
4731    ulCfg->initialUplinkBWP = NULLP;
4732    CU_ALLOC(ulCfg->initialUplinkBWP, sizeof(BWP_UplinkDedicated_t));
4733    if(!ulCfg->initialUplinkBWP)
4734    {
4735       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failed in BuildUlCfg");
4736       return RFAILED;
4737    }
4738
4739    if(BuildInitialUlBWP(ulCfg->initialUplinkBWP) != ROK)
4740    {
4741       return RFAILED;
4742    }
4743
4744    ulCfg->uplinkBWP_ToReleaseList = NULLP;
4745    ulCfg->uplinkBWP_ToAddModList = NULLP;
4746    ulCfg->firstActiveUplinkBWP_Id = NULLP;
4747    CU_ALLOC(ulCfg->firstActiveUplinkBWP_Id, sizeof(BWP_Id_t));
4748    if(!ulCfg->firstActiveUplinkBWP_Id)
4749    {
4750       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failed in BuildUlCfg");
4751       return RFAILED;
4752    }
4753    *(ulCfg->firstActiveUplinkBWP_Id) = ACTIVE_UL_BWP_ID;
4754
4755    ulCfg->pusch_ServingCellConfig = NULLP;
4756    CU_ALLOC(ulCfg->pusch_ServingCellConfig, \
4757          sizeof(struct UplinkConfig__pusch_ServingCellConfig));
4758    if(!ulCfg->pusch_ServingCellConfig)
4759    {
4760       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failed in BuildUlCfg");
4761       return RFAILED;
4762    }
4763
4764    if(BuildPuschSrvCellCfg(ulCfg->pusch_ServingCellConfig) != ROK)
4765    {
4766       return RFAILED;
4767    }
4768
4769    ulCfg->carrierSwitching = NULLP;
4770    ulCfg->ext1 = NULLP;
4771    return ROK;
4772 }
4773
4774 /*******************************************************************
4775  *
4776  * @brief Builds PDSCH serving cell config
4777  * @details
4778  *
4779  *    Function : BuildPdschSrvCellCfg
4780  *
4781  *    Functionality: Builds PDSCH serving cell config in spCellCfgDed
4782  *
4783  * @params[in] struct ServingCellConfig__pdsch_ServingCellConfig *pdschCfg
4784  *
4785  * @return ROK     - success
4786  *         RFAILED - failure
4787  *
4788  * ****************************************************************/
4789 uint8_t BuildPdschSrvCellCfg(struct ServingCellConfig__pdsch_ServingCellConfig *pdschCfg)
4790 {
4791    pdschCfg->present =  ServingCellConfig__pdsch_ServingCellConfig_PR_setup;
4792    pdschCfg->choice.setup = NULLP;
4793    CU_ALLOC(pdschCfg->choice.setup, sizeof( struct PDSCH_ServingCellConfig));
4794    if(!pdschCfg->choice.setup)
4795    {
4796       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschSrvCellCfg");
4797       return RFAILED;
4798    }
4799
4800    pdschCfg->choice.setup->codeBlockGroupTransmission = NULLP;
4801    pdschCfg->choice.setup->xOverhead = NULLP;
4802    pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH = NULLP;
4803    CU_ALLOC(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH, sizeof(long));
4804    if(!pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH)
4805    {
4806       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschSrvCellCfg");
4807       return RFAILED;
4808    }
4809    *(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH)= PDSCH_NUM_HARQ_PROC;
4810    pdschCfg->choice.setup->pucch_Cell = NULLP;
4811    pdschCfg->choice.setup->ext1 = NULLP;
4812
4813    return ROK;
4814 }
4815
4816 /*******************************************************************
4817  *
4818  * @brief Builds CSI Meas config
4819  * @details
4820  *
4821  *    Function : BuildCsiMeasCfg
4822  *
4823  *    Functionality: Builds CSI Meas config in spCellCfgDed
4824  *
4825  * @params[in] struct ServingCellConfig__csi_MeasConfig *csiMeasCfg
4826  *
4827  * @return ROK     - success
4828  *         RFAILED - failure
4829  *
4830  * ****************************************************************/
4831 uint8_t BuildCsiMeasCfg(struct ServingCellConfig__csi_MeasConfig *csiMeasCfg)
4832 {
4833
4834    return ROK;
4835 }
4836
4837 /*******************************************************************
4838  *
4839  * @brief Builds Spcell config dedicated
4840  * @details
4841  *
4842  *    Function : BuildSpCellCfgDed
4843  *
4844  *    Functionality: Builds sp cell config dedicated in spCellCfg
4845  *
4846  * @params[in] ServingCellConfig_t srvCellCfg
4847  *
4848  * @return ROK     - success
4849  *         RFAILED - failure
4850  *
4851  * ****************************************************************/
4852 uint8_t BuildSpCellCfgDed(ServingCellConfig_t *srvCellCfg)
4853 {
4854    srvCellCfg->tdd_UL_DL_ConfigurationDedicated = NULLP;
4855
4856    srvCellCfg->initialDownlinkBWP = NULLP;
4857    CU_ALLOC(srvCellCfg->initialDownlinkBWP, sizeof(BWP_DownlinkDedicated_t));
4858    if(!srvCellCfg->initialDownlinkBWP)
4859    {
4860       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
4861       return RFAILED;
4862    }
4863
4864    if(BuildInitialDlBWP(srvCellCfg->initialDownlinkBWP) != ROK)
4865    {
4866       DU_LOG("\nERROR  -->  F1AP : BuildInitialDlBWP failed");
4867       return RFAILED;
4868    }
4869    srvCellCfg->downlinkBWP_ToReleaseList = NULLP;
4870    srvCellCfg->downlinkBWP_ToAddModList = NULLP;
4871
4872    srvCellCfg->firstActiveDownlinkBWP_Id = NULLP;
4873    CU_ALLOC(srvCellCfg->firstActiveDownlinkBWP_Id, sizeof(long));
4874    if(!srvCellCfg->firstActiveDownlinkBWP_Id)
4875    {
4876       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
4877       return RFAILED;
4878    }
4879    *(srvCellCfg->firstActiveDownlinkBWP_Id) = ACTIVE_DL_BWP_ID;
4880
4881    srvCellCfg->bwp_InactivityTimer = NULLP;
4882
4883    srvCellCfg->defaultDownlinkBWP_Id = NULLP;
4884    CU_ALLOC(srvCellCfg->defaultDownlinkBWP_Id, sizeof(long));
4885    if(!srvCellCfg->defaultDownlinkBWP_Id)
4886    {
4887       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
4888       return RFAILED;
4889    }
4890    *(srvCellCfg->defaultDownlinkBWP_Id) = ACTIVE_DL_BWP_ID;
4891
4892    srvCellCfg->uplinkConfig = NULLP;
4893    CU_ALLOC(srvCellCfg->uplinkConfig, sizeof(UplinkConfig_t));
4894    if(!srvCellCfg->uplinkConfig)
4895    {
4896       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
4897       return RFAILED;
4898    }
4899
4900    if(BuildUlCfg(srvCellCfg->uplinkConfig) != ROK)
4901    {
4902       DU_LOG("\nERROR  -->  F1AP : BuildUlCfg failed");
4903       return RFAILED;
4904    }
4905    srvCellCfg->supplementaryUplink = NULLP;
4906    srvCellCfg->pdcch_ServingCellConfig = NULLP;
4907
4908    srvCellCfg->pdsch_ServingCellConfig = NULLP;
4909    CU_ALLOC(srvCellCfg->pdsch_ServingCellConfig, sizeof(struct  ServingCellConfig__pdsch_ServingCellConfig));
4910    if(!srvCellCfg->pdsch_ServingCellConfig)
4911    {
4912       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
4913       return RFAILED;
4914    }
4915
4916    if(BuildPdschSrvCellCfg(srvCellCfg->pdsch_ServingCellConfig) != ROK)
4917    {
4918       DU_LOG("\nERROR  -->  F1AP : BuildPdschSrvCellCfg failed");
4919       return RFAILED;
4920    }
4921
4922    srvCellCfg->csi_MeasConfig = NULLP;
4923 #if 0
4924    CU_ALLOC(srvCellCfg->csi_MeasConfig, sizeof(struct   ServingCellConfig__csi_MeasConfig))
4925       if(!srvCellCfg->csi_MeasConfig)
4926       {
4927          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
4928          return RFAILED;
4929       }
4930
4931    if(BuildCsiMeasCfg(srvCellCfg->csi_MeasConfig) != ROK)
4932    {
4933       DU_LOG("\nF1AP : BuildCsiMeasCfg failed");
4934       return RFAILED;
4935    }
4936 #endif
4937    srvCellCfg->sCellDeactivationTimer = NULLP;
4938    srvCellCfg->crossCarrierSchedulingConfig = NULLP;
4939    srvCellCfg->tag_Id = TAG_ID;
4940    srvCellCfg->dummy = NULLP;
4941    srvCellCfg->pathlossReferenceLinking = NULLP;
4942    srvCellCfg->servingCellMO = NULLP;
4943    srvCellCfg->ext1 = NULLP;
4944
4945    return ROK;
4946 }
4947 /*******************************************************************
4948  *
4949  * @brief Builds Spcell config
4950  *
4951  * @details
4952  *
4953  *    Function : BuildSpCellCfg
4954  *
4955  *    Functionality: Builds sp cell config in DuToCuRrcContainer
4956  *
4957  * @params[in] SpCellConfig_t spCellCfg
4958  *
4959  * @return ROK     - success
4960  *         RFAILED - failure
4961  *
4962  * ****************************************************************/
4963 uint8_t BuildSpCellCfg(SpCellConfig_t *spCellCfg)
4964 {
4965
4966    spCellCfg->servCellIndex = NULLP;
4967    CU_ALLOC(spCellCfg->servCellIndex, sizeof(long));
4968    if(!spCellCfg->servCellIndex)
4969    {
4970       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfg");
4971       return RFAILED;
4972    }
4973    *(spCellCfg->servCellIndex) = SERV_CELL_IDX;
4974
4975    spCellCfg->reconfigurationWithSync = NULLP;
4976    spCellCfg->rlf_TimersAndConstants = NULLP;
4977    spCellCfg->rlmInSyncOutOfSyncThreshold = NULLP;
4978    CU_ALLOC(spCellCfg->rlmInSyncOutOfSyncThreshold, sizeof(long));
4979    if(!spCellCfg->rlmInSyncOutOfSyncThreshold)
4980    {
4981       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfg");
4982       return RFAILED;
4983    }
4984    *(spCellCfg->rlmInSyncOutOfSyncThreshold) = RLM_SYNC_OUT_SYNC_THRESHOLD;
4985
4986    spCellCfg->spCellConfigDedicated = NULLP;
4987    CU_ALLOC(spCellCfg->spCellConfigDedicated, sizeof(ServingCellConfig_t));
4988    if(!spCellCfg->spCellConfigDedicated)
4989    {
4990       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfg");
4991       return RFAILED;
4992    }
4993    if(BuildSpCellCfgDed(spCellCfg->spCellConfigDedicated) != ROK)
4994    {
4995       DU_LOG("\nERROR  -->  F1AP : BuildSpCellCfgDed failed");
4996       return RFAILED;
4997    }
4998    return ROK;
4999 }
5000 /*******************************************************************
5001  *
5002  * @brief Builds Phy cell group config
5003  *
5004  * @details
5005  *
5006  *    Function : BuildPhyCellGrpCfg
5007  *
5008  *    Functionality: Builds Phy cell group config in DuToCuRrcContainer
5009  *
5010  * @params[in] PhysicalCellGroupConfig_t *phyCellGrpCfg
5011  *
5012  * @return ROK     - success
5013  *         RFAILED - failure
5014  *
5015  * ****************************************************************/
5016 uint8_t BuildPhyCellGrpCfg(PhysicalCellGroupConfig_t *phyCellGrpCfg)
5017 {
5018    phyCellGrpCfg->harq_ACK_SpatialBundlingPUCCH = NULLP;
5019    phyCellGrpCfg->harq_ACK_SpatialBundlingPUSCH = NULLP;
5020
5021    phyCellGrpCfg->p_NR_FR1 = NULLP;
5022    CU_ALLOC(phyCellGrpCfg->p_NR_FR1, sizeof(long));
5023    if(!phyCellGrpCfg->p_NR_FR1)
5024    {
5025       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildPhyCellGrpCfg");
5026       return RFAILED;
5027    }
5028    *(phyCellGrpCfg->p_NR_FR1)             = P_NR_FR1;
5029    phyCellGrpCfg->pdsch_HARQ_ACK_Codebook = PDSCH_HARQ_ACK_CODEBOOK;
5030    phyCellGrpCfg->tpc_SRS_RNTI = NULLP;
5031    phyCellGrpCfg->tpc_PUCCH_RNTI = NULLP;
5032    phyCellGrpCfg->tpc_PUSCH_RNTI = NULLP;
5033    phyCellGrpCfg->sp_CSI_RNTI = NULLP;
5034    phyCellGrpCfg->cs_RNTI = NULLP;
5035    phyCellGrpCfg->ext1 = NULLP;
5036    phyCellGrpCfg->ext2 = NULLP;
5037
5038    return ROK;
5039 }
5040
5041 /*******************************************************************
5042  *
5043  * @brief Builds tag config
5044  *
5045  * @details
5046  *
5047  *    Function : BuildTagConfig
5048  *
5049  *    Functionality: Builds tag config in MacCellGroupConfig
5050  *
5051  * @params[in] TAG_Config *tag_Config
5052  *
5053  * @return ROK     - success
5054  *         RFAILED - failure
5055  *
5056  * ****************************************************************/
5057 uint8_t BuildTagConfig(struct TAG_Config *tagConfig)
5058 {
5059    struct TAG_Config__tag_ToAddModList *tagList;
5060    uint8_t                     idx, elementCnt;
5061
5062    tagConfig->tag_ToReleaseList = NULLP;
5063    tagConfig->tag_ToAddModList = NULLP;
5064    CU_ALLOC(tagConfig->tag_ToAddModList, sizeof(struct TAG_Config__tag_ToAddModList));
5065    if(!tagConfig->tag_ToAddModList)
5066    {
5067       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildTagConfig");
5068       return RFAILED;
5069    }
5070
5071    elementCnt = 1; //ODU_VALUE_ONE;
5072    tagList = tagConfig->tag_ToAddModList;
5073    tagList->list.count = elementCnt;
5074    tagList->list.size  =  elementCnt * sizeof(struct TAG *);
5075
5076    tagList->list.array = NULLP;
5077    CU_ALLOC(tagList->list.array, tagList->list.size);
5078    if(!tagList->list.array)
5079    {
5080       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildTagConfig");
5081       return RFAILED;
5082    }
5083
5084    for(idx=0; idx<tagList->list.count; idx++)
5085    {
5086       tagList->list.array[idx] = NULLP;
5087       CU_ALLOC(tagList->list.array[idx], sizeof(struct TAG));
5088       if(!tagList->list.array[idx])
5089       {
5090          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildTagConfig");
5091          return RFAILED;
5092       }
5093    }
5094
5095    idx = 0;
5096    tagList->list.array[idx]->tag_Id = TAG_ID;
5097    tagList->list.array[idx]->timeAlignmentTimer = TIME_ALIGNMENT_TMR;
5098
5099    return ROK;
5100 }
5101
5102 /*******************************************************************
5103  *
5104  * @brief Builds PHR Config
5105  *
5106  * @details
5107  *
5108  *    Function : BuildPhrConfig
5109  *
5110  *    Functionality: Builds phrConfig in MacCellGroupConfig
5111  *
5112  * @params[in] PHR Config *
5113  *
5114  * @return ROK     - success
5115  *         RFAILED - failure
5116  *
5117  * ****************************************************************/
5118 uint8_t BuildPhrConfig(struct MAC_CellGroupConfig__phr_Config *phrConfig)
5119 {
5120
5121    phrConfig->present = MAC_CellGroupConfig__phr_Config_PR_setup;
5122    phrConfig->choice.setup = NULLP;
5123    CU_ALLOC(phrConfig->choice.setup, sizeof(struct PHR_Config));
5124    if(!phrConfig->choice.setup)
5125    {
5126       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildPhrConfig");
5127       return RFAILED;
5128    }
5129
5130    phrConfig->choice.setup->phr_PeriodicTimer        = PHR_PERIODIC_TMR;
5131    phrConfig->choice.setup->phr_ProhibitTimer        = PHR_PROHIBHIT_TMR;
5132    phrConfig->choice.setup->phr_Tx_PowerFactorChange = PHR_PWR_FACTOR_CHANGE;
5133    phrConfig->choice.setup->multiplePHR              = false;
5134    phrConfig->choice.setup->dummy                    = false;
5135    phrConfig->choice.setup->phr_Type2OtherCell       = false;
5136    phrConfig->choice.setup->phr_ModeOtherCG          = PHR_MODE_OTHER_CG;
5137
5138    return ROK;
5139 }
5140
5141 /*******************************************************************
5142  *
5143  * @brief Builds BSR Config
5144  *
5145  * @details
5146  *
5147  *    Function : BuildBsrConfig
5148  *
5149  *    Functionality: Builds BuildBsrConfig in MacCellGroupConfig
5150  *
5151  * @params[in] BSR_Config *bsrConfig
5152  *
5153  * @return ROK     - success
5154  *         RFAILED - failure
5155  *
5156  * ****************************************************************/
5157 uint8_t BuildBsrConfig(struct BSR_Config *bsrConfig)
5158 {
5159    bsrConfig->periodicBSR_Timer = PERIODIC_BSR_TMR;
5160    bsrConfig->retxBSR_Timer     = RETX_BSR_TMR;
5161    bsrConfig->logicalChannelSR_DelayTimer = NULLP;
5162
5163    return ROK;
5164 }
5165
5166 /*******************************************************************
5167  *
5168  * @brief Builds scheduling request config
5169  *
5170  * @details
5171  *
5172  *    Function : BuildSchedulingReqConfig
5173  *
5174  *    Functionality: Builds BuildSchedulingReqConfig in MacCellGroupConfig
5175  *
5176  * @params[in] SchedulingRequestConfig *schedulingRequestConfig
5177  *
5178  * @return ROK     - success
5179  *         RFAILED - failure
5180  *
5181  * ****************************************************************/
5182 uint8_t BuildSchedulingReqConfig(struct SchedulingRequestConfig *schedulingRequestConfig)
5183 {
5184    struct SchedulingRequestConfig__schedulingRequestToAddModList *schReqList;
5185    uint8_t                     idx, elementCnt;
5186
5187    schedulingRequestConfig->schedulingRequestToAddModList = NULLP;
5188    CU_ALLOC(schedulingRequestConfig->schedulingRequestToAddModList,
5189          sizeof(struct SchedulingRequestConfig__schedulingRequestToAddModList));
5190    if(!schedulingRequestConfig->schedulingRequestToAddModList)
5191    {
5192       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSchedulingReqConfig");
5193       return RFAILED;
5194    }
5195
5196    elementCnt = 1; //ODU_VALUE_ONE;
5197    schReqList = schedulingRequestConfig->schedulingRequestToAddModList;
5198    schReqList->list.count = elementCnt;
5199    schReqList->list.size  = elementCnt * sizeof(struct SchedulingRequestToAddMod *);
5200
5201    schReqList->list.array = NULLP;
5202    CU_ALLOC(schReqList->list.array, schReqList->list.size);
5203    if(!schReqList->list.array)
5204    {
5205       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSchedulingReqConfig");
5206       return RFAILED;
5207    }
5208
5209    for(idx=0;idx<schReqList->list.count; idx++)
5210    {
5211       schReqList->list.array[idx] = NULLP;
5212       CU_ALLOC(schReqList->list.array[idx], sizeof(struct SchedulingRequestToAddMod));
5213       if(!schReqList->list.array[idx])
5214       {
5215          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSchedulingReqConfig");
5216          return RFAILED;
5217       }
5218    }
5219
5220    idx = 0;
5221    schReqList->list.array[idx]->schedulingRequestId = SCH_REQ_ID;
5222
5223    schReqList->list.array[idx]->sr_ProhibitTimer = NULLP;
5224    CU_ALLOC(schReqList->list.array[idx]->sr_ProhibitTimer, sizeof(long));
5225    if(!schReqList->list.array[idx]->sr_ProhibitTimer)
5226    {
5227       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSchedulingReqConfig");
5228       return RFAILED;
5229    }
5230    *(schReqList->list.array[idx]->sr_ProhibitTimer) = SR_PROHIBIT_TMR;
5231    schReqList->list.array[idx]->sr_TransMax = SR_TRANS_MAX;
5232    schedulingRequestConfig->schedulingRequestToReleaseList = NULLP;
5233
5234    return ROK;
5235 }
5236 /*******************************************************************
5237  *
5238  * @brief Builds Mac cell group config
5239  *
5240  * @details
5241  *
5242  *    Function : BuildMacCellGrpCfg
5243  *
5244  *    Functionality: Builds Mac cell group config in DuToCuRrcContainer
5245  *
5246  * @params[in] MAC_CellGroupConfig_t *macCellGrpCfg
5247  *
5248  * @return ROK     - success
5249  *         RFAILED - failure
5250  *
5251  * ****************************************************************/
5252 uint8_t BuildMacCellGrpCfg(MAC_CellGroupConfig_t *macCellGrpCfg)
5253 {
5254    macCellGrpCfg->drx_Config = NULLP;
5255    macCellGrpCfg->schedulingRequestConfig = NULLP;
5256    CU_ALLOC(macCellGrpCfg->schedulingRequestConfig, sizeof(struct SchedulingRequestConfig));
5257    if(!macCellGrpCfg->schedulingRequestConfig)
5258    {
5259       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacCellGrpCfg");
5260       return RFAILED;
5261    }
5262
5263    if(BuildSchedulingReqConfig(macCellGrpCfg->schedulingRequestConfig) != ROK)
5264    {
5265       DU_LOG("\nERROR  -->  F1AP : BuildSchedulingReqConfig failed");
5266       return RFAILED;
5267    }
5268
5269    macCellGrpCfg->bsr_Config = NULLP;
5270    CU_ALLOC(macCellGrpCfg->bsr_Config, sizeof(struct BSR_Config));
5271    if(!macCellGrpCfg->bsr_Config)
5272    {
5273       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacCellGrpCfg");
5274       return RFAILED;
5275    }
5276
5277    if(BuildBsrConfig(macCellGrpCfg->bsr_Config) != ROK)
5278    {
5279       DU_LOG("\nERROR  -->  F1AP : BuildBsrConfig failed");
5280       return RFAILED;
5281    }
5282
5283    macCellGrpCfg->tag_Config = NULLP;
5284    CU_ALLOC(macCellGrpCfg->tag_Config, sizeof(struct TAG_Config));
5285    if(!macCellGrpCfg->tag_Config)
5286    {
5287       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacCellGrpCfg");
5288       return RFAILED;
5289    }
5290
5291    if(BuildTagConfig(macCellGrpCfg->tag_Config) != ROK)
5292    {
5293       DU_LOG("\nERROR  -->  F1AP : BuildTagConfig failed");
5294       return RFAILED;
5295    }
5296
5297    macCellGrpCfg->phr_Config = NULLP;
5298    CU_ALLOC(macCellGrpCfg->phr_Config, sizeof(struct MAC_CellGroupConfig__phr_Config));
5299    if(!macCellGrpCfg->phr_Config)
5300    {
5301       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacCellGrpCfg");
5302       return RFAILED;
5303    }
5304
5305    if(BuildPhrConfig(macCellGrpCfg->phr_Config) != ROK)
5306    {
5307       DU_LOG("\nERROR  -->  F1AP : BuildPhrConfig failed");
5308       return RFAILED;
5309    }
5310
5311    macCellGrpCfg->skipUplinkTxDynamic = false;
5312    macCellGrpCfg->ext1 = NULLP;
5313
5314    return ROK;
5315 }
5316 /*******************************************************************
5317  *
5318  * @brief Frees memeory allocated for SearchSpcToAddModList
5319  *
5320  * @details
5321  *
5322  *    Function : FreeSearchSpcToAddModList
5323  *
5324  *    Functionality: Deallocating memory of SearchSpcToAddModList
5325  *
5326  * @params[in] struct PDCCH_Config__searchSpacesToAddModList *searchSpcList
5327  *
5328  * @return void
5329  *
5330  4221 * ****************************************************************/
5331 void FreeSearchSpcToAddModList(struct PDCCH_Config__searchSpacesToAddModList *searchSpcList)
5332 {
5333    uint8_t idx1=0;
5334    uint8_t idx2=0;
5335    struct  SearchSpace *searchSpc=NULLP;
5336
5337    if(searchSpcList->list.array)
5338    {
5339       if(searchSpcList->list.array[idx2])
5340       {
5341          searchSpc = searchSpcList->list.array[idx2];
5342          if(searchSpc->controlResourceSetId)
5343          {
5344             if(searchSpc->monitoringSlotPeriodicityAndOffset)
5345             {
5346                if(searchSpc->monitoringSymbolsWithinSlot)
5347                {
5348                   if(searchSpc->monitoringSymbolsWithinSlot->buf)
5349                   {
5350                      if(searchSpc->nrofCandidates)
5351                      {
5352                         if(searchSpc->searchSpaceType)
5353                         {
5354                            CU_FREE(searchSpc->searchSpaceType->choice.ue_Specific,\
5355                                  sizeof(struct SearchSpace__searchSpaceType__ue_Specific));
5356                            CU_FREE(searchSpc->searchSpaceType, sizeof(struct
5357                                     SearchSpace__searchSpaceType));
5358                         }
5359                         CU_FREE(searchSpc->nrofCandidates,
5360                               sizeof(struct SearchSpace__nrofCandidates));
5361                      }
5362                      CU_FREE(searchSpc->monitoringSymbolsWithinSlot->buf, \
5363                            searchSpc->monitoringSymbolsWithinSlot->size);
5364                   }
5365                   CU_FREE(searchSpc->monitoringSymbolsWithinSlot,
5366                         sizeof(BIT_STRING_t));
5367                }
5368                CU_FREE(searchSpc->monitoringSlotPeriodicityAndOffset, \
5369                      sizeof(struct SearchSpace__monitoringSlotPeriodicityAndOffset));
5370             }
5371             CU_FREE(searchSpc->controlResourceSetId,
5372                   sizeof(ControlResourceSetId_t));
5373          }
5374       }
5375       for(idx1 = 0; idx1 < searchSpcList->list.count; idx1++)
5376       {
5377          CU_FREE(searchSpcList->list.array[idx1],
5378                sizeof(struct SearchSpace));
5379       }
5380       CU_FREE(searchSpcList->list.array,searchSpcList->list.size);
5381    }
5382 }
5383 /*******************************************************************
5384  *
5385  * @brief Frees memory allocated for PdschTimeDomAllocList
5386  *
5387  * @details
5388  *
5389  *    Function : FreePdschTimeDomAllocList
5390  *
5391  *    Functionality: Deallocating memory of PdschTimeDomAllocList
5392  *
5393  * @params[in] struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList
5394  *
5395  * @return void
5396  *
5397  4221 * ****************************************************************/
5398 void FreePdschTimeDomAllocList( struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList)
5399 {
5400    uint8_t idx1=0;
5401
5402    if(timeDomAllocList->choice.setup)
5403    {
5404       if(timeDomAllocList->choice.setup->list.array)
5405       {
5406          for(idx1 = 0; idx1 <timeDomAllocList->choice.setup->list.count ; idx1++)
5407          {
5408             CU_FREE(timeDomAllocList->choice.setup->list.array[idx1],
5409                   sizeof(struct PDSCH_TimeDomainResourceAllocation));
5410          }
5411          CU_FREE(timeDomAllocList->choice.setup->list.array, \
5412                timeDomAllocList->choice.setup->list.size);
5413       }
5414       CU_FREE(timeDomAllocList->choice.setup,\
5415             sizeof(struct PDSCH_TimeDomainResourceAllocationList));
5416    }
5417 }
5418 /*******************************************************************
5419  *
5420  * @brief Frees memory allocated for PuschTimeDomAllocList
5421  *
5422  *@details
5423  *
5424  *    Function : FreePuschTimeDomAllocList
5425  *
5426  *    Functionality: Deallocating memory of PuschTimeDomAllocList
5427  *
5428  * @params[in] PUSCH_Config_t *puschCfg
5429  *
5430  * @return void
5431  *
5432  ***********************************************************************/
5433 void FreePuschTimeDomAllocList(PUSCH_Config_t *puschCfg)
5434 {
5435    uint8_t idx1=0;
5436    uint8_t idx2=0;
5437    struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList_t=NULLP;
5438
5439    if(puschCfg->pusch_TimeDomainAllocationList)
5440    {
5441       timeDomAllocList_t=puschCfg->pusch_TimeDomainAllocationList;
5442       if(timeDomAllocList_t->choice.setup)
5443       {
5444          if(timeDomAllocList_t->choice.setup->list.array)
5445          {
5446             CU_FREE(timeDomAllocList_t->choice.setup->list.array[idx2]->k2, sizeof(long));
5447             for(idx1 = 0; idx1<timeDomAllocList_t->choice.setup->list.count; idx1++)
5448             {
5449                CU_FREE(timeDomAllocList_t->choice.setup->list.array[idx1],\
5450                      sizeof(PUSCH_TimeDomainResourceAllocation_t));
5451             }
5452             CU_FREE(timeDomAllocList_t->choice.setup->list.array, \
5453                   timeDomAllocList_t->choice.setup->list.size);
5454          }
5455          CU_FREE(timeDomAllocList_t->choice.setup, \
5456                sizeof(struct PUSCH_TimeDomainResourceAllocationList));
5457       }
5458       CU_FREE(puschCfg->transformPrecoder, sizeof(long));
5459       CU_FREE(puschCfg->pusch_TimeDomainAllocationList, \
5460             sizeof(struct PUSCH_Config__pusch_TimeDomainAllocationList));
5461    }
5462
5463 }
5464
5465 /*******************************************************************
5466  *
5467  * @brief Frees memory allocated for Dedicated PUCCH config
5468  *
5469  * @details
5470  *
5471  *    Function : FreeBWPUlDedPucchCfg
5472  *
5473  *    Functionality: Deallocating memory of Dedicated PUCCH cfg
5474  *
5475  * @params[in] BWP_UplinkDedicated__pucch_Config *ulBwpPucchCfg
5476  *
5477  * @return void
5478  *
5479  * ****************************************************************/
5480 void FreeBWPUlDedPucchCfg(struct BWP_UplinkDedicated__pucch_Config *ulBwpPucchCfg)
5481 {
5482    uint8_t arrIdx, rsrcIdx, rsrcSetIdx;
5483    PUCCH_Config_t *pucchCfg = NULLP;
5484    PUCCH_ResourceSet_t *rsrcSet = NULLP;
5485    PUCCH_Resource_t *rsrc = NULLP;
5486
5487    if(ulBwpPucchCfg)
5488    {
5489       if(ulBwpPucchCfg->choice.setup)
5490       {
5491          pucchCfg = ulBwpPucchCfg->choice.setup;
5492
5493          //Free resource set list
5494          if(pucchCfg->resourceSetToAddModList)
5495          {
5496             if(pucchCfg->resourceSetToAddModList->list.array)
5497             {
5498                for(rsrcSetIdx=0; rsrcSetIdx < pucchCfg->resourceSetToAddModList->list.count; rsrcSetIdx++)
5499                {
5500                   rsrcSet = pucchCfg->resourceSetToAddModList->list.array[rsrcSetIdx];
5501                   if(rsrcSet->resourceList.list.array)
5502                   {
5503                      for(rsrcIdx=0; rsrcIdx < rsrcSet->resourceList.list.count; rsrcIdx++)
5504                      {
5505                         CU_FREE(rsrcSet->resourceList.list.array[rsrcIdx], sizeof(PUCCH_ResourceId_t));
5506                      }
5507                      CU_FREE(rsrcSet->resourceList.list.array, rsrcSet->resourceList.list.size);
5508                   }
5509                   CU_FREE(pucchCfg->resourceSetToAddModList->list.array[rsrcSetIdx], sizeof(PUCCH_ResourceSet_t));
5510                }
5511                CU_FREE(pucchCfg->resourceSetToAddModList->list.array, pucchCfg->resourceSetToAddModList->list.size);
5512             }
5513             CU_FREE(pucchCfg->resourceSetToAddModList, sizeof(struct PUCCH_Config__resourceSetToAddModList));
5514          }
5515
5516          //Free resource list
5517          if(pucchCfg->resourceToAddModList)
5518          {
5519             if(pucchCfg->resourceToAddModList->list.array)
5520             {
5521                for(rsrcIdx=0; rsrcIdx < pucchCfg->resourceToAddModList->list.count; rsrcIdx++)
5522                {
5523                   rsrc = pucchCfg->resourceToAddModList->list.array[rsrcIdx];
5524                   CU_FREE(rsrc->format.choice.format1, sizeof(PUCCH_format1_t));
5525                   CU_FREE(pucchCfg->resourceToAddModList->list.array[rsrcIdx], sizeof(PUCCH_Resource_t));
5526                }
5527                CU_FREE(pucchCfg->resourceToAddModList->list.array, pucchCfg->resourceToAddModList->list.size);
5528             }
5529             CU_FREE(pucchCfg->resourceToAddModList, sizeof(struct PUCCH_Config__resourceToAddModList));
5530          }
5531
5532          //PUCCH Format 1
5533          if(pucchCfg->format1)
5534          {
5535             if(pucchCfg->format1->choice.setup)
5536             {
5537                CU_FREE(pucchCfg->format1->choice.setup->nrofSlots, sizeof(long));
5538                CU_FREE(pucchCfg->format1->choice.setup, sizeof(PUCCH_FormatConfig_t));
5539             }
5540             CU_FREE(pucchCfg->format1, sizeof(struct PUCCH_Config__format1));
5541          }
5542
5543          //DL DATA TO UL ACK
5544          if(pucchCfg->dl_DataToUL_ACK)
5545          {
5546             if(pucchCfg->dl_DataToUL_ACK->list.array)
5547             {
5548                for(arrIdx = 0; arrIdx <  pucchCfg->dl_DataToUL_ACK->list.count; arrIdx++)
5549                {
5550                   CU_FREE(pucchCfg->dl_DataToUL_ACK->list.array[arrIdx], sizeof(long));
5551                }
5552                CU_FREE(pucchCfg->dl_DataToUL_ACK->list.array, pucchCfg->dl_DataToUL_ACK->list.size);
5553             }
5554             CU_FREE(pucchCfg->dl_DataToUL_ACK, sizeof(struct PUCCH_Config__dl_DataToUL_ACK));
5555          }
5556
5557          CU_FREE(ulBwpPucchCfg->choice.setup, sizeof(PUCCH_Config_t));
5558       }
5559       CU_FREE(ulBwpPucchCfg, sizeof(struct BWP_UplinkDedicated__pucch_Config));
5560    }
5561 }
5562
5563 /*******************************************************************
5564  *
5565  * @brief Frees memory allocated for InitialUlBWP
5566  *
5567  * @details
5568  *
5569  *    Function : FreeInitialUlBWP
5570  *
5571  *    Functionality: Deallocating memory of InitialUlBWP
5572  *
5573  * @params[in] BWP_UplinkDedicated_t *ulBwp
5574  *
5575  * @return void
5576  *
5577  * ****************************************************************/
5578 void FreeInitialUlBWP(BWP_UplinkDedicated_t *ulBwp)
5579 {
5580    uint8_t  rSetIdx, rsrcIdx;
5581    SRS_Config_t   *srsCfg = NULLP;
5582    PUSCH_Config_t *puschCfg = NULLP;
5583    struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA *dmrsUlCfg = NULLP;
5584    struct SRS_Config__srs_ResourceSetToAddModList *rsrcSetList = NULLP;
5585    struct SRS_ResourceSet__srs_ResourceIdList *rsrcIdList = NULLP;
5586    struct SRS_Config__srs_ResourceToAddModList *resourceList = NULLP;
5587
5588    FreeBWPUlDedPucchCfg(ulBwp->pucch_Config);
5589
5590    if(ulBwp->pusch_Config)
5591    {
5592       if(ulBwp->pusch_Config->choice.setup)
5593       {
5594          puschCfg=ulBwp->pusch_Config->choice.setup;
5595          if(puschCfg->dataScramblingIdentityPUSCH)
5596          {
5597             if(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA)
5598             {
5599                FreePuschTimeDomAllocList(puschCfg);
5600                dmrsUlCfg=puschCfg->dmrs_UplinkForPUSCH_MappingTypeA;
5601                if(dmrsUlCfg->choice.setup)
5602                {
5603                   if(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition)
5604                   {
5605                      if(dmrsUlCfg->choice.setup->transformPrecodingDisabled)
5606                      {
5607                         CU_FREE(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0,\
5608                               sizeof(long));
5609                         CU_FREE(dmrsUlCfg->choice.setup->transformPrecodingDisabled,
5610                               sizeof(struct DMRS_UplinkConfig__transformPrecodingDisabled));
5611                      }
5612                      CU_FREE(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition,
5613                            sizeof(long));
5614                   }
5615                   CU_FREE(dmrsUlCfg->choice.setup,sizeof(DMRS_UplinkConfig_t));
5616                }
5617                CU_FREE(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA, \
5618                      sizeof(struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA));
5619             }
5620             CU_FREE(puschCfg->dataScramblingIdentityPUSCH, sizeof(long));
5621          }
5622          CU_FREE(ulBwp->pusch_Config->choice.setup, sizeof(PUSCH_Config_t));
5623       }
5624       CU_FREE(ulBwp->pusch_Config, sizeof(struct BWP_UplinkDedicated__pusch_Config));
5625
5626       /* Free SRS-Config */
5627       if(ulBwp->srs_Config)
5628       {
5629          if(ulBwp->srs_Config->choice.setup)
5630          {
5631             srsCfg = ulBwp->srs_Config->choice.setup;
5632
5633             /* Free Resource Set to add/mod list */
5634             if(srsCfg->srs_ResourceSetToAddModList)
5635             {
5636                rsrcSetList = srsCfg->srs_ResourceSetToAddModList;
5637                if(rsrcSetList->list.array)
5638                {
5639                   rSetIdx = 0;
5640
5641                   /* Free SRS resource Id list in this SRS resource set */
5642                   if(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList)
5643                   {
5644                      rsrcIdList = rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList;
5645
5646                      if(rsrcIdList->list.array)
5647                      {
5648                         for(rsrcIdx = 0; rsrcIdx < rsrcIdList->list.count; rsrcIdx++)
5649                         {
5650                            CU_FREE(rsrcIdList->list.array[rsrcIdx], sizeof(SRS_ResourceId_t));
5651                         }
5652                         CU_FREE(rsrcIdList->list.array, rsrcIdList->list.size);
5653                      }
5654                      CU_FREE(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList,\
5655                            sizeof(struct SRS_ResourceSet__srs_ResourceIdList));
5656                   }
5657
5658                   /* Free resource type info for this SRS resource set */
5659                   CU_FREE(rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic, \
5660                         sizeof(struct SRS_ResourceSet__resourceType__aperiodic));
5661
5662                   /* Free memory for each resource set */
5663                   for(rSetIdx = 0; rSetIdx < rsrcSetList->list.count; rSetIdx++)
5664                   {
5665                      CU_FREE(rsrcSetList->list.array[rSetIdx], sizeof(SRS_ResourceSet_t));
5666                   }
5667                   CU_FREE(rsrcSetList->list.array, rsrcSetList->list.size);
5668                }
5669                CU_FREE(srsCfg->srs_ResourceSetToAddModList, \
5670                      sizeof(struct SRS_Config__srs_ResourceSetToAddModList));
5671             }
5672
5673             /* Free resource to add/modd list */
5674             if(srsCfg->srs_ResourceToAddModList)
5675             {
5676                resourceList = srsCfg->srs_ResourceToAddModList;
5677                if(resourceList->list.array)
5678                {
5679                   rsrcIdx = 0;
5680                   CU_FREE(resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2,\
5681                         sizeof(struct SRS_Resource__transmissionComb__n2));
5682                   CU_FREE(resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic,\
5683                         sizeof(struct SRS_Resource__resourceType__aperiodic));
5684
5685                   for(rsrcIdx = 0; rsrcIdx < resourceList->list.count; rsrcIdx++)
5686                   {
5687                      CU_FREE(resourceList->list.array[rsrcIdx], sizeof(SRS_Resource_t));
5688                   }
5689                   CU_FREE(resourceList->list.array, resourceList->list.size);
5690                }
5691                CU_FREE(srsCfg->srs_ResourceToAddModList, \
5692                      sizeof(struct SRS_Config__srs_ResourceToAddModList));
5693             }
5694
5695             CU_FREE(ulBwp->srs_Config->choice.setup, sizeof(SRS_Config_t));
5696          }
5697          CU_FREE(ulBwp->srs_Config, sizeof(struct BWP_UplinkDedicated__srs_Config));
5698       }
5699    }
5700 }
5701 /*******************************************************************
5702  *
5703  * @brief Frees memory allocated for initialUplinkBWP
5704  *
5705  * @details
5706  *
5707  *    Function : FreeinitialUplinkBWP
5708  *
5709  *    Functionality: Deallocating memory of initialUplinkBWP
5710  *
5711  * @params[in] UplinkConfig_t *ulCfg
5712  *
5713  * @return void
5714  *
5715  *
5716  * ****************************************************************/
5717 void FreeinitialUplinkBWP(UplinkConfig_t *ulCfg)
5718 {
5719    BWP_UplinkDedicated_t *ulBwp=NULLP;
5720    struct UplinkConfig__pusch_ServingCellConfig *puschCfg=NULLP;
5721
5722    if(ulCfg->initialUplinkBWP)
5723    {
5724       ulBwp=ulCfg->initialUplinkBWP;
5725       if(ulCfg->firstActiveUplinkBWP_Id)
5726       {
5727          if(ulCfg->pusch_ServingCellConfig)
5728          {
5729             puschCfg=ulCfg->pusch_ServingCellConfig;
5730             if(puschCfg->choice.setup)
5731             {
5732                if(puschCfg->choice.setup->ext1)
5733                {
5734                   CU_FREE(puschCfg->choice.setup->ext1->\
5735                         processingType2Enabled,sizeof(BOOLEAN_t));
5736                   CU_FREE(puschCfg->choice.setup->ext1->\
5737                         maxMIMO_Layers,sizeof(long));
5738                   CU_FREE(puschCfg->choice.setup->ext1, \
5739                         sizeof(struct PUSCH_ServingCellConfig__ext1));
5740                }
5741                CU_FREE(puschCfg->choice.setup, sizeof(struct PUSCH_ServingCellConfig));
5742             }
5743             CU_FREE(ulCfg->pusch_ServingCellConfig, sizeof(struct UplinkConfig__pusch_ServingCellConfig));
5744          }
5745          CU_FREE(ulCfg->firstActiveUplinkBWP_Id, sizeof(BWP_Id_t));
5746       }
5747       FreeInitialUlBWP(ulBwp);
5748       CU_FREE(ulCfg->initialUplinkBWP, sizeof(BWP_UplinkDedicated_t));
5749    }
5750 }
5751 /*******************************************************************
5752  *
5753  * @brief Frees emmory allocated for BWPDlDedPdschCfg
5754  *
5755  * @details
5756  *
5757  *    Function : FreeBWPDlDedPdschCfg
5758  *
5759  *    Functionality: Deallocating memory of BWPDlDedPdschCfg
5760  *
5761  * @params[in] BWP_DownlinkDedicated_t *dlBwp
5762  *
5763  * @return void
5764  *
5765  *
5766  * ****************************************************************/
5767 void FreeBWPDlDedPdschCfg(BWP_DownlinkDedicated_t *dlBwp)
5768 {
5769    struct PDSCH_Config *pdschCfg=NULLP;
5770    struct PDSCH_Config__prb_BundlingType *prbBndlType=NULLP;
5771    struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList=NULLP;
5772    struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA *dmrsDlCfg=NULLP;
5773
5774    if(dlBwp->pdsch_Config->choice.setup)
5775    {
5776       pdschCfg=dlBwp->pdsch_Config->choice.setup;
5777       if(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA)
5778       {
5779          if(pdschCfg->pdsch_TimeDomainAllocationList)
5780          {
5781             timeDomAllocList=pdschCfg->pdsch_TimeDomainAllocationList;
5782             if(pdschCfg->maxNrofCodeWordsScheduledByDCI)
5783             {
5784                prbBndlType=&pdschCfg->prb_BundlingType;
5785                CU_FREE(prbBndlType->choice.staticBundling,\
5786                      sizeof(struct PDSCH_Config__prb_BundlingType__staticBundling));
5787                CU_FREE(pdschCfg->maxNrofCodeWordsScheduledByDCI, sizeof(long));
5788             }
5789             FreePdschTimeDomAllocList(timeDomAllocList);
5790             CU_FREE(pdschCfg->pdsch_TimeDomainAllocationList, \
5791                   sizeof(struct PDSCH_Config__pdsch_TimeDomainAllocationList));
5792          }
5793          dmrsDlCfg=pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA;
5794          if(dmrsDlCfg->choice.setup)
5795          {
5796             CU_FREE(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition,
5797                   sizeof(long));
5798             CU_FREE(dmrsDlCfg->choice.setup, sizeof(struct DMRS_DownlinkConfig));
5799          }
5800          CU_FREE(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA, \
5801                sizeof(struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA));
5802       }
5803       CU_FREE(dlBwp->pdsch_Config->choice.setup, sizeof(struct PDSCH_Config));
5804    }
5805 }
5806 /*******************************************************************
5807  *
5808  * @brief Frees emmory allocated for BWPDlDedPdcchCfg
5809  *
5810  * @details
5811  *
5812  *    Function : FreeBWPDlDedPdcchCfg
5813  *
5814  *    Functionality: Deallocating memory of BWPDlDedPdcchCfg
5815  *
5816  * @params[in] BWP_DownlinkDedicated_t *dlBwp
5817  *
5818  * @return void
5819  *
5820  *
5821  * ****************************************************************/
5822 void FreeBWPDlDedPdcchCfg(BWP_DownlinkDedicated_t *dlBwp)
5823 {
5824    uint8_t idx1=0;
5825    uint8_t idx2=0;
5826    struct PDCCH_Config *pdcchCfg=NULLP;
5827    struct ControlResourceSet *controlRSet=NULLP;
5828    struct PDCCH_Config__controlResourceSetToAddModList *controlRSetList=NULLP;
5829
5830    if(dlBwp->pdcch_Config->choice.setup)
5831    {
5832       pdcchCfg=dlBwp->pdcch_Config->choice.setup;
5833       if(pdcchCfg->controlResourceSetToAddModList)
5834       {
5835          controlRSetList = pdcchCfg->controlResourceSetToAddModList;
5836          if(controlRSetList->list.array)
5837          {
5838             controlRSet = controlRSetList->list.array[idx2];
5839             if(controlRSet)
5840             {
5841                if(controlRSet->frequencyDomainResources.buf)
5842                {
5843                   if(controlRSet->pdcch_DMRS_ScramblingID)
5844                   {
5845                      if(pdcchCfg->searchSpacesToAddModList)
5846                      {
5847                         FreeSearchSpcToAddModList(pdcchCfg->searchSpacesToAddModList);
5848                         CU_FREE(pdcchCfg->searchSpacesToAddModList, \
5849                               sizeof(struct PDCCH_Config__searchSpacesToAddModList));
5850                      }
5851                      CU_FREE(controlRSet->pdcch_DMRS_ScramblingID, sizeof(long));
5852                   }
5853                   CU_FREE(controlRSet->frequencyDomainResources.buf, \
5854                         controlRSet->frequencyDomainResources.size);
5855                }
5856             }
5857             for(idx1 = 0; idx1 <controlRSetList->list.count; idx1++)
5858             {
5859                CU_FREE(controlRSetList->list.array[idx1], sizeof(struct ControlResourceSet));
5860             }
5861             CU_FREE(controlRSetList->list.array, controlRSetList->list.size);
5862          }
5863          CU_FREE(pdcchCfg->controlResourceSetToAddModList, \
5864                sizeof(struct PDCCH_Config__controlResourceSetToAddModList));
5865       }
5866       CU_FREE(dlBwp->pdcch_Config->choice.setup, sizeof(struct PDCCH_Config));
5867    }
5868 }
5869 /*******************************************************************
5870  *
5871  * @brief Builds RLC Config
5872  *
5873  * @details
5874  *
5875  *    Function : BuildRlcConfig
5876  *
5877  *    Functionality: Builds RLC Config in BuildRlcBearerToAddModList
5878  *
5879  * @params[in] RLC_Config *rlcConfig
5880  *
5881  * @return ROK     - success
5882  *         RFAILED - failure
5883  *
5884  * ****************************************************************/
5885 uint8_t BuildRlcConfig(RlcLcCfg rlcLcCfgDb, struct RLC_Config *rlcConfig)
5886 {
5887    rlcConfig->present = rlcLcCfgDb.rlcMode;
5888
5889    switch(rlcConfig->present)
5890    {
5891       case RLC_Config_PR_am:
5892          {
5893             rlcConfig->choice.am = NULLP;
5894             CU_ALLOC(rlcConfig->choice.am, sizeof(struct RLC_Config__am));
5895             if(!rlcConfig->choice.am)
5896             {
5897                DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfig");
5898                return RFAILED;
5899             }
5900
5901             /* UL */
5902             rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength = NULLP;
5903             CU_ALLOC(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
5904             if(!rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength)
5905             {
5906                DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfig");
5907                return RFAILED;
5908             }
5909             *(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength) = rlcLcCfgDb.u.amCfg.ulAmCfg.snLenUl;
5910             rlcConfig->choice.am->ul_AM_RLC.t_PollRetransmit  = rlcLcCfgDb.u.amCfg.ulAmCfg.pollRetxTmr;
5911             rlcConfig->choice.am->ul_AM_RLC.pollPDU           = rlcLcCfgDb.u.amCfg.ulAmCfg.pollPdu;
5912             rlcConfig->choice.am->ul_AM_RLC.pollByte          = rlcLcCfgDb.u.amCfg.ulAmCfg.pollByte;
5913             rlcConfig->choice.am->ul_AM_RLC.maxRetxThreshold  = rlcLcCfgDb.u.amCfg.ulAmCfg.maxRetxTh;
5914
5915             /* DL */
5916             rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength = NULLP;
5917             CU_ALLOC(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
5918             if(!rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength)
5919             {
5920                DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfig");
5921                return RFAILED;
5922             }
5923             *(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength) = rlcLcCfgDb.u.amCfg.dlAmCfg.snLenDl;
5924             rlcConfig->choice.am->dl_AM_RLC.t_Reassembly      = rlcLcCfgDb.u.amCfg.dlAmCfg.reAssemTmr;
5925             rlcConfig->choice.am->dl_AM_RLC.t_StatusProhibit  = rlcLcCfgDb.u.amCfg.dlAmCfg.statProhTmr;
5926
5927             break;
5928          }
5929
5930       case RLC_Config_PR_um_Bi_Directional:
5931          {
5932             rlcConfig->choice.um_Bi_Directional = NULLP;
5933             CU_ALLOC(rlcConfig->choice.um_Bi_Directional, sizeof(struct RLC_Config__um_Bi_Directional));
5934             if(!rlcConfig->choice.um_Bi_Directional)
5935             {
5936                DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfig");
5937                return RFAILED;
5938             }
5939
5940             /* UL */
5941             rlcConfig->choice.um_Bi_Directional->ul_UM_RLC.sn_FieldLength = NULLP;
5942             CU_ALLOC(rlcConfig->choice.um_Bi_Directional->ul_UM_RLC.sn_FieldLength, sizeof(SN_FieldLengthUM_t));
5943             if(!rlcConfig->choice.um_Bi_Directional->ul_UM_RLC.sn_FieldLength)
5944             {
5945                DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfig");
5946                return RFAILED;
5947             }
5948             *(rlcConfig->choice.um_Bi_Directional->ul_UM_RLC.sn_FieldLength) = rlcLcCfgDb.u.umBiDirCfg.ulUmCfg.snLenUlUm;
5949
5950             /* DL */
5951             rlcConfig->choice.um_Bi_Directional->dl_UM_RLC.sn_FieldLength = NULLP;
5952             CU_ALLOC(rlcConfig->choice.um_Bi_Directional->dl_UM_RLC.sn_FieldLength, sizeof(SN_FieldLengthUM_t));
5953             if(!rlcConfig->choice.um_Bi_Directional->dl_UM_RLC.sn_FieldLength)
5954             {
5955                DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfig");
5956                return RFAILED;
5957             }
5958             *(rlcConfig->choice.um_Bi_Directional->dl_UM_RLC.sn_FieldLength) = rlcLcCfgDb.u.umBiDirCfg.dlUmCfg.snLenDlUm;
5959             rlcConfig->choice.um_Bi_Directional->dl_UM_RLC.t_Reassembly = rlcLcCfgDb.u.umBiDirCfg.dlUmCfg.reAssemTmr;
5960             break;
5961          }
5962    }
5963    return ROK;
5964 }
5965
5966 /*******************************************************************
5967  *
5968  * @brief Builds MAC LC Config
5969  *
5970  * @details
5971  *
5972  *    Function : BuildMacLCConfig
5973  *
5974  *    Functionality: Builds MAC LC Config in BuildRlcBearerToAddModList
5975  *
5976  * @params[in] struct LogicalChannelConfig macLcConfig
5977  *
5978  * @return ROK     - success
5979  *         RFAILED - failure
5980  *
5981  * ****************************************************************/
5982 uint8_t BuildMacLCConfig(MacLcCfg macLcCfgDb, struct LogicalChannelConfig *macLcConfig)
5983 {
5984
5985    macLcConfig->ul_SpecificParameters = NULLP;
5986    CU_ALLOC(macLcConfig->ul_SpecificParameters, sizeof(struct LogicalChannelConfig__ul_SpecificParameters));
5987    if(!macLcConfig->ul_SpecificParameters)
5988    {
5989       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacLCConfig");
5990       return RFAILED;
5991    }
5992
5993    macLcConfig->ul_SpecificParameters->priority = macLcCfgDb.priority;
5994    macLcConfig->ul_SpecificParameters->prioritisedBitRate =     macLcCfgDb.pbr;
5995    macLcConfig->ul_SpecificParameters->bucketSizeDuration =     macLcCfgDb.bsd;
5996    macLcConfig->ul_SpecificParameters->allowedServingCells = NULLP;
5997    macLcConfig->ul_SpecificParameters->allowedSCS_List = NULLP;
5998    macLcConfig->ul_SpecificParameters->maxPUSCH_Duration = NULLP;
5999    macLcConfig->ul_SpecificParameters->configuredGrantType1Allowed = NULLP;
6000
6001    macLcConfig->ul_SpecificParameters->logicalChannelGroup = NULLP;
6002    CU_ALLOC(macLcConfig->ul_SpecificParameters->logicalChannelGroup,    sizeof(long));
6003    if(!macLcConfig->ul_SpecificParameters->logicalChannelGroup)
6004    {
6005       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacLCConfig");
6006       return RFAILED;
6007    }
6008    *(macLcConfig->ul_SpecificParameters->logicalChannelGroup) = macLcCfgDb.lcGroup;
6009
6010    macLcConfig->ul_SpecificParameters->schedulingRequestID = NULLP;
6011    CU_ALLOC(macLcConfig->ul_SpecificParameters->schedulingRequestID,    sizeof(SchedulingRequestId_t));
6012    if(!macLcConfig->ul_SpecificParameters->schedulingRequestID)
6013    {
6014       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacLCConfig");
6015       return RFAILED;
6016    }
6017    *(macLcConfig->ul_SpecificParameters->schedulingRequestID) = macLcCfgDb.schReqId;
6018
6019    macLcConfig->ul_SpecificParameters->logicalChannelSR_Mask = false;
6020    macLcConfig->ul_SpecificParameters->logicalChannelSR_DelayTimerApplied = false;
6021    macLcConfig->ul_SpecificParameters->bitRateQueryProhibitTimer = NULLP;
6022
6023    return ROK;
6024 }
6025 /*******************************************************************
6026  *
6027  * @brief Builds RLC Bearer to Add/Mod list
6028  *
6029  * @details
6030  *
6031  *    Function :BuildRlcBearerToAddModList
6032  *
6033  *    Functionality: Builds RLC Bearer to Add/Mod list in DuToCuRrcContainer
6034  *
6035  * @params[in] rlc_BearerToAddModList
6036  *
6037  * @return ROK     - success
6038  *         RFAILED - failure
6039  *
6040  * ****************************************************************/
6041 uint8_t BuildRlcBearerToAddModList(CuUeCb *ueCb, struct CellGroupConfigRrc__rlc_BearerToAddModList *rlcBearerList, bool updateAllRbCfg)
6042 {
6043    uint8_t idx, srbIdx = 0, drbIdx = 0, elementCnt=0;
6044
6045    if(updateAllRbCfg)
6046       elementCnt = ueCb->numSrb + ueCb->numDrb;
6047    else
6048    {
6049       for(srbIdx = 0; srbIdx< ueCb->numSrb; srbIdx++)
6050       {
6051          if(ueCb->srbList[srbIdx].cfgSentToUe == false)
6052             elementCnt++;
6053       }
6054
6055       for(drbIdx = 0; drbIdx< ueCb->numDrb; drbIdx++)
6056       {
6057          if(ueCb->drbList[drbIdx].cfgSentToUe == false)
6058             elementCnt++;
6059       }
6060    }
6061
6062    if(!elementCnt)
6063    {
6064       DU_LOG("INFO  --> F1AP : No  RLC Bearer available to add or modify");
6065       return ROK;
6066    }
6067    CU_ALLOC(rlcBearerList, sizeof(struct CellGroupConfigRrc__rlc_BearerToAddModList));
6068    if(!rlcBearerList)
6069    {
6070       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in CellGrpConfig");
6071       return RFAILED;
6072    }
6073    rlcBearerList->list.count = elementCnt;
6074    rlcBearerList->list.size  = elementCnt * sizeof(struct RLC_BearerConfig *);
6075
6076    rlcBearerList->list.array = NULLP;
6077    CU_ALLOC(rlcBearerList->list.array, rlcBearerList->list.size);
6078    if(!rlcBearerList->list.array)
6079    {
6080       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
6081       return RFAILED;
6082    }
6083
6084    for(idx=0; idx<rlcBearerList->list.count; idx++)
6085    {
6086       rlcBearerList->list.array[idx] = NULLP;
6087       CU_ALLOC(rlcBearerList->list.array[idx], sizeof(struct RLC_BearerConfig));
6088       if(!rlcBearerList->list.array[idx])
6089       {
6090          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
6091          return RFAILED;
6092       }
6093    }
6094
6095    idx = 0;
6096
6097    for(srbIdx=0; srbIdx < ueCb->numSrb; srbIdx++)
6098    {
6099       if(!updateAllRbCfg && ueCb->srbList[srbIdx].cfgSentToUe)
6100          continue;
6101
6102       rlcBearerList->list.array[idx]->logicalChannelIdentity = ueCb->srbList[srbIdx].lcId;
6103
6104       CU_ALLOC(rlcBearerList->list.array[idx]->servedRadioBearer, sizeof(struct RLC_BearerConfig__servedRadioBearer));
6105       if(!rlcBearerList->list.array[idx]->servedRadioBearer)
6106       {
6107          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
6108          return RFAILED;
6109       }
6110
6111       rlcBearerList->list.array[idx]->servedRadioBearer->present = RLC_BearerConfig__servedRadioBearer_PR_srb_Identity;
6112       rlcBearerList->list.array[idx]->servedRadioBearer->choice.srb_Identity = ueCb->srbList[srbIdx].srbId;
6113
6114       rlcBearerList->list.array[idx]->reestablishRLC = NULLP;
6115       rlcBearerList->list.array[idx]->rlc_Config = NULLP;
6116       CU_ALLOC(rlcBearerList->list.array[idx]->rlc_Config, sizeof(struct RLC_Config));
6117       if(!rlcBearerList->list.array[idx]->rlc_Config)
6118       {
6119          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
6120          return RFAILED;
6121       }
6122
6123       if(BuildRlcConfig(ueCb->srbList[srbIdx].rlcLcCfg, rlcBearerList->list.array[idx]->rlc_Config) != ROK)
6124       {
6125          DU_LOG("\nERROR  -->  F1AP : BuildRlcConfig failed");
6126          return RFAILED;
6127       }
6128
6129       rlcBearerList->list.array[idx]->mac_LogicalChannelConfig = NULLP;
6130       CU_ALLOC(rlcBearerList->list.array[idx]->mac_LogicalChannelConfig, sizeof(struct LogicalChannelConfig));
6131       if(!rlcBearerList->list.array[idx]->mac_LogicalChannelConfig)
6132       {
6133          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
6134          return RFAILED;
6135       }
6136
6137       if(BuildMacLCConfig(ueCb->srbList[srbIdx].macLcCfg, rlcBearerList->list.array[idx]->mac_LogicalChannelConfig) != ROK)
6138       {
6139          DU_LOG("\nERROR  -->  F1AP : BuildMacLCConfig failed");
6140          return RFAILED;
6141       }
6142       idx++;
6143    }
6144
6145    for(drbIdx=0; drbIdx < ueCb->numDrb; drbIdx++)
6146    {
6147       if(!updateAllRbCfg && ueCb->drbList[drbIdx].cfgSentToUe)
6148          continue;
6149
6150       rlcBearerList->list.array[idx]->logicalChannelIdentity = ueCb->drbList[drbIdx].lcId;
6151
6152       CU_ALLOC(rlcBearerList->list.array[idx]->servedRadioBearer, sizeof(struct RLC_BearerConfig__servedRadioBearer));
6153       if(!rlcBearerList->list.array[idx]->servedRadioBearer)
6154       {
6155          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
6156          return RFAILED;
6157       }
6158
6159       rlcBearerList->list.array[idx]->servedRadioBearer->present = RLC_BearerConfig__servedRadioBearer_PR_drb_Identity;
6160       rlcBearerList->list.array[idx]->servedRadioBearer->choice.drb_Identity = ueCb->drbList[drbIdx].drbId;
6161
6162       rlcBearerList->list.array[idx]->reestablishRLC = NULLP;
6163       rlcBearerList->list.array[idx]->rlc_Config = NULLP;
6164       CU_ALLOC(rlcBearerList->list.array[idx]->rlc_Config, sizeof(struct RLC_Config));
6165       if(!rlcBearerList->list.array[idx]->rlc_Config)
6166       {
6167          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
6168          return RFAILED;
6169       }
6170
6171       if(BuildRlcConfig(ueCb->drbList[drbIdx].rlcLcCfg, rlcBearerList->list.array[idx]->rlc_Config) != ROK)
6172       {
6173          DU_LOG("\nERROR  -->  F1AP : BuildRlcConfig failed");
6174          return RFAILED;
6175       }
6176
6177       rlcBearerList->list.array[idx]->mac_LogicalChannelConfig = NULLP;
6178       CU_ALLOC(rlcBearerList->list.array[idx]->mac_LogicalChannelConfig, sizeof(struct LogicalChannelConfig));
6179       if(!rlcBearerList->list.array[idx]->mac_LogicalChannelConfig)
6180       {
6181          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
6182          return RFAILED;
6183       }
6184
6185       if(BuildMacLCConfig(ueCb->drbList[drbIdx].macLcCfg, rlcBearerList->list.array[idx]->mac_LogicalChannelConfig) != ROK)
6186       {
6187          DU_LOG("\nERROR  -->  F1AP : BuildMacLCConfig failed");
6188          return RFAILED;
6189       }
6190       idx++;
6191    }
6192    return ROK;
6193 }
6194
6195 /*******************************************************************
6196  *
6197  * @brief Free memory allocated for CellGroupConfig
6198  *
6199  * @details
6200  *
6201  *    Function : FreeMemCellGrpCfg
6202  *
6203  *    Functionality: Deallocating memory of CellGroupConfig
6204  *
6205  * @params[in] pointer to CellGroupConfigRrc_t
6206  *
6207  * @return ROK     - success
6208  *         RFAILED - failure
6209  *
6210  ******************************************************************/
6211 uint8_t FreeMemCellGrpCfg(CellGroupConfigRrc_t *cellGrpCfg)
6212 {
6213    uint8_t idx=0;
6214    SpCellConfig_t *spCellCfg=NULLP;
6215    ServingCellConfig_t *srvCellCfg=NULLP;
6216    BWP_DownlinkDedicated_t *dlBwp=NULLP;
6217    MAC_CellGroupConfig_t *macCellGrpCfg=NULLP;
6218    PhysicalCellGroupConfig_t *phyCellGrpCfg=NULLP;
6219    struct CellGroupConfigRrc__rlc_BearerToAddModList *rlcBearerList=NULLP;
6220    struct RLC_Config *rlcConfig=NULLP;
6221    struct LogicalChannelConfig *macLcConfig=NULLP;
6222    struct SchedulingRequestConfig *schedulingRequestConfig=NULLP;
6223    struct SchedulingRequestConfig__schedulingRequestToAddModList *schReqList=NULLP;
6224    struct TAG_Config *tagConfig=NULLP;
6225    struct TAG_Config__tag_ToAddModList *tagList=NULLP;
6226    struct MAC_CellGroupConfig__phr_Config *phrConfig=NULLP;
6227    struct ServingCellConfig__pdsch_ServingCellConfig *pdschCfg=NULLP;
6228
6229    rlcBearerList = cellGrpCfg->rlc_BearerToAddModList;
6230    if(rlcBearerList)
6231    {
6232       if(rlcBearerList->list.array)
6233       {
6234          for(idx=0; idx<rlcBearerList->list.count; idx++)
6235          {
6236             if(rlcBearerList->list.array[idx])
6237             {
6238                rlcConfig   = rlcBearerList->list.array[idx]->rlc_Config;
6239                macLcConfig = rlcBearerList->list.array[idx]->mac_LogicalChannelConfig;
6240                if(rlcConfig)
6241                {
6242                   if(rlcConfig->choice.am)
6243                   {
6244                      CU_FREE(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
6245                      CU_FREE(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
6246                      CU_FREE(rlcConfig->choice.am, sizeof(struct RLC_Config__am));
6247                   }
6248                   CU_FREE(rlcConfig, sizeof(struct RLC_Config));
6249                }
6250                CU_FREE(rlcBearerList->list.array[idx]->servedRadioBearer, sizeof(struct RLC_BearerConfig__servedRadioBearer));
6251                if(macLcConfig)
6252                {
6253                   if(macLcConfig->ul_SpecificParameters)
6254                   {
6255                      CU_FREE(macLcConfig->ul_SpecificParameters->schedulingRequestID,   sizeof(SchedulingRequestId_t));
6256                      CU_FREE(macLcConfig->ul_SpecificParameters->logicalChannelGroup,   sizeof(long));
6257                      CU_FREE(macLcConfig->ul_SpecificParameters, sizeof(struct LogicalChannelConfig__ul_SpecificParameters));
6258                   }
6259                   CU_FREE(rlcBearerList->list.array[idx]->mac_LogicalChannelConfig, sizeof(struct LogicalChannelConfig));
6260                }
6261                CU_FREE(rlcBearerList->list.array[idx], sizeof(struct RLC_BearerConfig));
6262             }
6263          }
6264          CU_FREE(rlcBearerList->list.array, rlcBearerList->list.size);
6265       }
6266       CU_FREE(cellGrpCfg->rlc_BearerToAddModList, sizeof(struct CellGroupConfigRrc__rlc_BearerToAddModList));
6267    }
6268
6269    macCellGrpCfg = cellGrpCfg->mac_CellGroupConfig;
6270    if(macCellGrpCfg)
6271    {
6272       schedulingRequestConfig = macCellGrpCfg->schedulingRequestConfig;
6273       if(schedulingRequestConfig)
6274       {
6275          schReqList = schedulingRequestConfig->schedulingRequestToAddModList;
6276          if(schReqList)
6277          {
6278             if(schReqList->list.array)
6279             {
6280                for(idx=0;idx<schReqList->list.count; idx++)
6281                {
6282                   if(schReqList->list.array[idx])
6283                   {
6284                      CU_FREE(schReqList->list.array[idx]->sr_ProhibitTimer, sizeof(long));
6285                      CU_FREE(schReqList->list.array[idx], sizeof(struct SchedulingRequestToAddMod));
6286                   }
6287                }
6288                CU_FREE(schReqList->list.array, schReqList->list.size);
6289             }
6290             CU_FREE(schedulingRequestConfig->schedulingRequestToAddModList,\
6291                   sizeof(struct SchedulingRequestConfig__schedulingRequestToAddModList));    }
6292             CU_FREE(macCellGrpCfg->schedulingRequestConfig, sizeof(struct SchedulingRequestConfig));
6293       }
6294       if(macCellGrpCfg->bsr_Config)
6295       {
6296          CU_FREE(macCellGrpCfg->bsr_Config, sizeof(struct BSR_Config));
6297       }
6298       tagConfig = macCellGrpCfg->tag_Config;
6299       if(tagConfig)
6300       {
6301          tagList = tagConfig->tag_ToAddModList;
6302          if(tagList)
6303          {
6304             if(tagList->list.array)
6305             {
6306                for(idx=0; idx<tagList->list.count; idx++)
6307                {
6308                   CU_FREE(tagList->list.array[idx], sizeof(struct TAG));
6309                }
6310                CU_FREE(tagList->list.array, tagList->list.size);
6311             }
6312             CU_FREE(tagConfig->tag_ToAddModList, sizeof(struct TAG_Config__tag_ToAddModList));
6313          }
6314          CU_FREE(tagConfig, sizeof(struct TAG_Config));
6315       }
6316
6317       phrConfig = macCellGrpCfg->phr_Config;
6318       if(phrConfig)
6319       {
6320          CU_FREE(phrConfig->choice.setup, sizeof(struct PHR_Config));
6321          CU_FREE(phrConfig, sizeof(struct MAC_CellGroupConfig__phr_Config));
6322       }
6323
6324       CU_FREE(macCellGrpCfg, sizeof(MAC_CellGroupConfig_t));
6325    }
6326
6327    phyCellGrpCfg = cellGrpCfg->physicalCellGroupConfig;
6328    if(phyCellGrpCfg)
6329    {
6330       CU_FREE(phyCellGrpCfg->p_NR_FR1, sizeof(long));
6331       CU_FREE(phyCellGrpCfg, sizeof(PhysicalCellGroupConfig_t));
6332    }
6333
6334    spCellCfg = cellGrpCfg->spCellConfig;
6335    if(spCellCfg)
6336    {
6337       if(spCellCfg->servCellIndex)
6338       {
6339          if(spCellCfg->rlmInSyncOutOfSyncThreshold)
6340          {
6341             if(spCellCfg->spCellConfigDedicated)
6342             {
6343                srvCellCfg = spCellCfg->spCellConfigDedicated;
6344                if(srvCellCfg->initialDownlinkBWP)
6345                {
6346                   dlBwp = srvCellCfg->initialDownlinkBWP;
6347                   if(srvCellCfg->firstActiveDownlinkBWP_Id)
6348                   {
6349                      if(srvCellCfg->defaultDownlinkBWP_Id)
6350                      {
6351                         if(srvCellCfg->uplinkConfig)
6352                         {
6353                            if(srvCellCfg->pdsch_ServingCellConfig)
6354                            {
6355                               pdschCfg= srvCellCfg->pdsch_ServingCellConfig;
6356                               if(pdschCfg->choice.setup)
6357                               {
6358                                  CU_FREE(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH,sizeof(long));
6359                                  CU_FREE(pdschCfg->choice.setup, sizeof( struct PDSCH_ServingCellConfig));
6360                               }
6361                               CU_FREE(srvCellCfg->pdsch_ServingCellConfig, sizeof(struct
6362                                        ServingCellConfig__pdsch_ServingCellConfig));
6363                            }
6364                            FreeinitialUplinkBWP(srvCellCfg->uplinkConfig);
6365                            CU_FREE(srvCellCfg->uplinkConfig, sizeof(UplinkConfig_t));
6366                         }
6367                         CU_FREE(srvCellCfg->defaultDownlinkBWP_Id, sizeof(long));
6368                      }
6369                      CU_FREE(srvCellCfg->firstActiveDownlinkBWP_Id, sizeof(long));
6370                   }
6371                   if(dlBwp->pdcch_Config)
6372                   {
6373                      if(dlBwp->pdsch_Config)
6374                      {
6375                         FreeBWPDlDedPdschCfg(dlBwp);
6376                         CU_FREE(dlBwp->pdsch_Config, sizeof(struct BWP_DownlinkDedicated__pdsch_Config));
6377                      }
6378                      FreeBWPDlDedPdcchCfg(dlBwp);
6379                      CU_FREE(dlBwp->pdcch_Config, sizeof(struct BWP_DownlinkDedicated__pdcch_Config));
6380                   }
6381                   CU_FREE(srvCellCfg->initialDownlinkBWP, sizeof(BWP_DownlinkDedicated_t));
6382                }
6383                CU_FREE(spCellCfg->spCellConfigDedicated, sizeof(ServingCellConfig_t));
6384             }
6385             CU_FREE(spCellCfg->rlmInSyncOutOfSyncThreshold, sizeof(long));
6386          }
6387          CU_FREE(spCellCfg->servCellIndex, sizeof(long));
6388       }
6389       CU_FREE(spCellCfg,sizeof(SpCellConfig_t));
6390    }
6391    return ROK;
6392 }
6393
6394 /*******************************************************************
6395  *
6396  * @brief Fills CellGroupConfig
6397  *
6398  * @details
6399  *
6400  *    Function : fillCellGrpCfg
6401  *
6402  *    Functionality: Fills CellGroupConfig
6403  *
6404  * @params[in] pointer to CellGroupConfigRrc_t
6405  *
6406  * @return ROK     - success
6407  *         RFAILED - failure
6408  *
6409  ******************************************************************/
6410
6411 uint8_t fillCellGrpCfg(CuUeCb *ueCb, OCTET_STRING_t *cellGrp, bool updateAllRbCfg)
6412 {
6413    uint8_t               ret = RFAILED;
6414    CellGroupConfigRrc_t  cellGrpCfg;
6415    asn_enc_rval_t        encRetVal;
6416
6417    while(true)
6418    {
6419       cellGrpCfg.cellGroupId = CELL_GRP_ID;
6420
6421       cellGrpCfg.rlc_BearerToAddModList = NULLP;
6422
6423       if(BuildRlcBearerToAddModList(ueCb, cellGrpCfg.rlc_BearerToAddModList, updateAllRbCfg) != ROK)
6424       {
6425          DU_LOG("\nERROR  -->  F1AP : fillCellGrpCfg failed");
6426          break;
6427       }
6428
6429       cellGrpCfg.rlc_BearerToReleaseList = NULLP;
6430       cellGrpCfg.mac_CellGroupConfig = NULLP;
6431       CU_ALLOC(cellGrpCfg.mac_CellGroupConfig, sizeof(MAC_CellGroupConfig_t));
6432       if(!cellGrpCfg.mac_CellGroupConfig)
6433       {
6434          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in fillCellGrpCfg");
6435          break;
6436       }
6437       if(BuildMacCellGrpCfg(cellGrpCfg.mac_CellGroupConfig) != ROK)
6438       {
6439          DU_LOG("\nERROR  -->  F1AP : BuildMacCellGrpCfg failed");
6440          break;
6441       }
6442
6443       cellGrpCfg.physicalCellGroupConfig = NULLP;
6444       CU_ALLOC(cellGrpCfg.physicalCellGroupConfig, sizeof(PhysicalCellGroupConfig_t));
6445       if(!cellGrpCfg.physicalCellGroupConfig)
6446       {
6447          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildDuToCuRrcContainer");
6448          break;
6449       }
6450       if(BuildPhyCellGrpCfg(cellGrpCfg.physicalCellGroupConfig) != ROK)
6451       {
6452          DU_LOG("\nERROR  -->  F1AP : BuildPhyCellGrpCfg failed");
6453          break;
6454       }
6455
6456       cellGrpCfg.spCellConfig = NULLP;
6457       CU_ALLOC(cellGrpCfg.spCellConfig, sizeof(SpCellConfig_t));
6458       if(!cellGrpCfg.spCellConfig)
6459       {
6460          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildDuToCuRrcContainer");
6461          break;
6462       }
6463       if(BuildSpCellCfg(cellGrpCfg.spCellConfig) != ROK)
6464       {
6465          DU_LOG("\nERROR  -->  F1AP : BuildSpCellCfg failed");
6466          break;
6467       }
6468
6469       cellGrpCfg.sCellToAddModList = NULLP;
6470       cellGrpCfg.sCellToReleaseList = NULLP;
6471       cellGrpCfg.ext1 = NULLP;
6472
6473       /* encode cellGrpCfg into duToCuRrcContainer */
6474       xer_fprint(stdout, &asn_DEF_CellGroupConfigRrc, &cellGrpCfg);
6475       cmMemset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
6476       encBufSize = 0;
6477       encRetVal = aper_encode(&asn_DEF_CellGroupConfigRrc, 0, &cellGrpCfg, PrepFinalEncBuf, encBuf);
6478       /* Encode results */
6479       if(encRetVal.encoded == ENCODE_FAIL)
6480       {
6481          DU_LOG( "\nERROR  -->  F1AP : Could not encode DuToCuRrcContainer (at %s)\n",\
6482                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
6483          break;
6484       }
6485       else
6486       {
6487          DU_LOG("\nDEBUG  -->  F1AP : Created APER encodedbuffer for DuToCuRrcContainer\n");
6488          for(int i=0; i< encBufSize; i++)
6489          {
6490             DU_LOG("%x",encBuf[i]);
6491          }
6492       }
6493
6494       cellGrp->size = encBufSize;
6495       CU_ALLOC(cellGrp->buf, cellGrp->size);
6496       if(!cellGrp->buf)
6497       {
6498          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDuToCuRrcContainer");
6499          break;
6500       }
6501       memcpy(cellGrp->buf, encBuf, cellGrp->size);
6502       ret = ROK;
6503       break;
6504    }
6505    FreeMemCellGrpCfg(&cellGrpCfg);
6506    return ret;
6507 }
6508
6509 /*******************************************************************
6510  *
6511  * @brief Free UE Capability RAT container
6512  *
6513  * @details
6514  *
6515  *    Function : freeUeCapRatCont
6516  *
6517  *    Functionality:
6518  *       Free UE Capability RAT conatiner
6519  *
6520  * @params[in]
6521  * @return ROK     - success
6522  *         RFAILED - failure
6523  *
6524  * ****************************************************************/
6525 void freeUeCapRatCont(UE_NR_Capability_t *ueNrCap)
6526 {
6527    uint8_t idx;
6528    FeatureSets_t *featureSets;
6529
6530    if(ueNrCap->rf_Parameters.supportedBandListNR.list.array)
6531    {
6532       for(idx = 0; idx < ueNrCap->rf_Parameters.supportedBandListNR.list.count; idx++)
6533       {
6534          if(ueNrCap->rf_Parameters.supportedBandListNR.list.array[idx])
6535             CU_FREE(ueNrCap->rf_Parameters.supportedBandListNR.list.array[idx], sizeof(struct BandNR));
6536       }
6537       CU_FREE(ueNrCap->rf_Parameters.supportedBandListNR.list.array, ueNrCap->rf_Parameters.supportedBandListNR.list.size);
6538    }
6539
6540    if(ueNrCap->featureSets)
6541    {
6542       featureSets = ueNrCap->featureSets;
6543       if(featureSets->featureSetsDownlinkPerCC)
6544       {
6545          if(featureSets->featureSetsDownlinkPerCC->list.array)
6546          {
6547             for(idx = 0; idx < featureSets->featureSetsDownlinkPerCC->list.count; idx++)
6548             {
6549                   if(featureSets->featureSetsDownlinkPerCC->list.array[idx]->supportedModulationOrderDL)
6550                      CU_FREE(featureSets->featureSetsDownlinkPerCC->list.array[idx]->supportedModulationOrderDL, \
6551                         sizeof(ModulationOrder_t));
6552                   CU_FREE(featureSets->featureSetsDownlinkPerCC->list.array[idx], sizeof(struct FeatureSetDownlinkPerCC));
6553             }
6554             CU_FREE(featureSets->featureSetsDownlinkPerCC->list.array, featureSets->featureSetsDownlinkPerCC->list.size);
6555          }
6556          CU_FREE(featureSets->featureSetsDownlinkPerCC, sizeof(struct FeatureSets__featureSetsDownlinkPerCC));
6557       }
6558
6559       if(featureSets->featureSetsUplinkPerCC)
6560       {
6561          if(featureSets->featureSetsUplinkPerCC->list.array)
6562          {
6563             for(idx = 0; idx < featureSets->featureSetsUplinkPerCC->list.count; idx++)
6564             {
6565                if(featureSets->featureSetsUplinkPerCC->list.array[idx])
6566                {
6567                   if(featureSets->featureSetsUplinkPerCC->list.array[idx]->supportedModulationOrderUL)
6568                      CU_FREE(featureSets->featureSetsUplinkPerCC->list.array[idx]->supportedModulationOrderUL,\
6569                          sizeof(ModulationOrder_t));
6570                   CU_FREE(featureSets->featureSetsUplinkPerCC->list.array[idx], sizeof(struct FeatureSetUplinkPerCC));
6571                }
6572             }
6573             CU_FREE(featureSets->featureSetsUplinkPerCC->list.array,  featureSets->featureSetsUplinkPerCC->list.size);
6574          }
6575          CU_FREE(featureSets->featureSetsUplinkPerCC, sizeof(struct FeatureSets__featureSetsUplinkPerCC));
6576       }
6577       CU_FREE(ueNrCap->featureSets, sizeof(struct FeatureSets));
6578    }
6579 }
6580
6581 /*******************************************************************
6582  *
6583  * @brief Free UE capability RAT container list
6584  *
6585  * @details
6586  *
6587  *    Function : freeUeCapRatContList
6588  *
6589  *    Functionality: Free UE capability RAT container list
6590  *
6591  * @params[in]
6592  * @return ROK     - success
6593  *         RFAILED - failure
6594  *
6595  * ****************************************************************/
6596 void freeUeCapRatContList(UE_CapabilityRAT_ContainerListRRC_t *ueCapablityList)
6597 {
6598    uint8_t idx;
6599    if(ueCapablityList->list.array)
6600    {
6601       for(idx = 0; idx < ueCapablityList->list.count; idx++)
6602       {
6603          if(ueCapablityList->list.array[idx])
6604             CU_FREE(ueCapablityList->list.array[idx], sizeof(UE_CapabilityRAT_Container_t));
6605       }
6606       CU_FREE(ueCapablityList->list.array, ueCapablityList->list.size);
6607    }
6608 }
6609
6610 /*******************************************************************
6611  *
6612  * @brief Free Handover preparation information
6613  *
6614  * @details
6615  *
6616  *    Function : freeHOPreparationInfo
6617  *
6618  *    Functionality: Free Handover preparation information
6619  *
6620  * @params[in]
6621  * @return ROK     - success
6622  *         RFAILED - failure
6623  *
6624  * ****************************************************************/
6625 void freeHOPreparationInfo(HandoverPreparationInformationRrc_t *hoPrep)
6626 {
6627    HandoverPreparationInformationRrc_IEs_t *hoPrepInfoIe;
6628
6629    if(hoPrep->criticalExtensions.choice.c1)
6630    {
6631       if(hoPrep->criticalExtensions.choice.c1->choice.handoverPreparationInformation)
6632       {
6633          hoPrepInfoIe = hoPrep->criticalExtensions.choice.c1->choice.handoverPreparationInformation;
6634          freeUeCapRatContList(&hoPrepInfoIe->ue_CapabilityRAT_List);
6635          CU_FREE(hoPrep->criticalExtensions.choice.c1->choice.handoverPreparationInformation , \
6636                sizeof(HandoverPreparationInformationRrc_IEs_t));
6637       }
6638       CU_FREE(hoPrep->criticalExtensions.choice.c1, sizeof(struct HandoverPreparationInformationRrc__criticalExtensions__c1));
6639    }
6640 }
6641
6642 /*******************************************************************
6643  *
6644  * @brief Fill feature sets
6645  *
6646  * @details
6647  *
6648  *    Function : fillFeatureSets
6649  *
6650  *    Functionality: Fill feature sets
6651  *
6652  * @params[in]
6653  * @return ROK     - success
6654  *         RFAILED - failure
6655  *
6656  * ****************************************************************/
6657 uint8_t fillFeatureSets(FeatureSets_t *featureSets)
6658 {
6659    uint8_t idx, elementCnt;
6660
6661    featureSets->featureSetsDownlink = NULLP;
6662    CU_ALLOC(featureSets->featureSetsDownlinkPerCC, sizeof(struct FeatureSets__featureSetsDownlinkPerCC));
6663    if(!featureSets->featureSetsDownlinkPerCC)
6664    {
6665       DU_LOG("\nERROR  --> F1AP : Memory allocation failed in fillFeatureSets");
6666       return RFAILED;
6667    }
6668
6669    elementCnt = 1;
6670    featureSets->featureSetsDownlinkPerCC->list.count = elementCnt;
6671    featureSets->featureSetsDownlinkPerCC->list.size = elementCnt * sizeof(struct FeatureSetDownlinkPerCC *);
6672    CU_ALLOC(featureSets->featureSetsDownlinkPerCC->list.array, featureSets->featureSetsDownlinkPerCC->list.size);
6673    if(!featureSets->featureSetsDownlinkPerCC->list.array)
6674    {
6675       DU_LOG("\nERROR  --> F1AP : Memory allocation failed in fillFeatureSets");
6676       return RFAILED;
6677    }
6678
6679    for(idx = 0; idx < elementCnt; idx++)
6680    {
6681       CU_ALLOC(featureSets->featureSetsDownlinkPerCC->list.array[idx], sizeof(struct FeatureSetDownlinkPerCC));
6682       if(!featureSets->featureSetsDownlinkPerCC->list.array[idx])
6683       {
6684          DU_LOG("\nERROR  --> F1AP : Memory allocation failed in fillFeatureSets");
6685          return RFAILED;
6686       }
6687    }
6688
6689    idx = 0;
6690    featureSets->featureSetsDownlinkPerCC->list.array[idx]->supportedSubcarrierSpacingDL = SubcarrierSpacing_kHz15;
6691    featureSets->featureSetsDownlinkPerCC->list.array[idx]->supportedBandwidthDL.present = SupportedBandwidth_PR_fr1;
6692    featureSets->featureSetsDownlinkPerCC->list.array[idx]->supportedBandwidthDL.choice.fr1 = SupportedBandwidth__fr1_mhz20;
6693    featureSets->featureSetsDownlinkPerCC->list.array[idx]->channelBW_90mhz = NULLP;
6694    featureSets->featureSetsDownlinkPerCC->list.array[idx]->maxNumberMIMO_LayersPDSCH = NULLP;
6695
6696    CU_ALLOC(featureSets->featureSetsDownlinkPerCC->list.array[idx]->supportedModulationOrderDL, sizeof(ModulationOrder_t));
6697    if(!featureSets->featureSetsDownlinkPerCC->list.array[idx]->supportedModulationOrderDL)
6698    {
6699       DU_LOG("\nERROR  --> F1AP : Memory allocation failed in fillFeatureSets");
6700       return RFAILED;
6701    }
6702    *(featureSets->featureSetsDownlinkPerCC->list.array[idx]->supportedModulationOrderDL) = ModulationOrder_qam64;
6703
6704    featureSets->featureSetsUplink = NULLP;
6705    CU_ALLOC(featureSets->featureSetsUplinkPerCC, sizeof(struct FeatureSets__featureSetsUplinkPerCC));
6706    if(!featureSets->featureSetsUplinkPerCC)
6707    {
6708       DU_LOG("\nERROR  --> F1AP : Memory allocation failed in fillFeatureSets");
6709       return RFAILED;
6710    }
6711
6712    elementCnt = 1;
6713    featureSets->featureSetsUplinkPerCC->list.count = elementCnt;
6714    featureSets->featureSetsUplinkPerCC->list.size = elementCnt * sizeof(struct FeatureSetUplinkPerCC *);
6715    CU_ALLOC(featureSets->featureSetsUplinkPerCC->list.array, featureSets->featureSetsUplinkPerCC->list.size);
6716    if(!featureSets->featureSetsUplinkPerCC->list.array)
6717    {
6718       DU_LOG("\nERROR  --> F1AP : Memory allocation failed in fillFeatureSets");
6719       return RFAILED;
6720    }
6721
6722    for(idx = 0; idx < elementCnt; idx++)
6723    {
6724       CU_ALLOC(featureSets->featureSetsUplinkPerCC->list.array[idx], sizeof(struct FeatureSetUplinkPerCC));
6725       if(!featureSets->featureSetsUplinkPerCC->list.array[idx])
6726       {
6727          DU_LOG("\nERROR  --> F1AP : Memory allocation failed in fillFeatureSets");
6728          return RFAILED;
6729       }
6730    }
6731
6732    idx = 0;
6733    featureSets->featureSetsUplinkPerCC->list.array[idx]->supportedSubcarrierSpacingUL = SubcarrierSpacing_kHz15;
6734    featureSets->featureSetsUplinkPerCC->list.array[idx]->supportedBandwidthUL.present = SupportedBandwidth_PR_fr1;
6735    featureSets->featureSetsUplinkPerCC->list.array[idx]->supportedBandwidthUL.choice.fr1 = SupportedBandwidth__fr1_mhz20;
6736    featureSets->featureSetsUplinkPerCC->list.array[idx]->channelBW_90mhz = NULLP;
6737    featureSets->featureSetsUplinkPerCC->list.array[idx]->mimo_CB_PUSCH = NULLP;
6738    featureSets->featureSetsUplinkPerCC->list.array[idx]->maxNumberMIMO_LayersNonCB_PUSCH = NULLP;
6739
6740    CU_ALLOC(featureSets->featureSetsUplinkPerCC->list.array[idx]->supportedModulationOrderUL, sizeof(ModulationOrder_t));
6741    if(!featureSets->featureSetsUplinkPerCC->list.array[idx]->supportedModulationOrderUL)
6742    {
6743       DU_LOG("\nERROR  --> F1AP : Memory allocation failed in fillFeatureSets");
6744       return RFAILED;
6745    }
6746    *(featureSets->featureSetsUplinkPerCC->list.array[idx]->supportedModulationOrderUL) = ModulationOrder_qam16;
6747
6748    return ROK;
6749 }
6750
6751 /*******************************************************************
6752  *
6753  * @brief Fill UE capability RAT container
6754  *
6755  * @details
6756  *
6757  *    Function : fillUeCapRatCont
6758  *
6759  *    Functionality: Fill UE capability RAT container
6760  *
6761  * @params[in] UE Capability RAT container buffer
6762  * @return ROK     - success
6763  *         RFAILED - failure
6764  *
6765  * ****************************************************************/
6766 uint8_t fillUeCapRatCont(OCTET_STRING_t *ueCapRatContBuf)
6767 {
6768    uint8_t             ret = ROK;
6769    uint8_t             idx, elementCnt;
6770    asn_enc_rval_t      encRetVal;
6771    UE_NR_Capability_t  ueNrCap;
6772
6773    while(true)
6774    {
6775       ueNrCap.accessStratumRelease = AccessStratumRelease_rel15;
6776
6777       /* Filling PDCP parameters */
6778       ueNrCap.pdcp_Parameters.supportedROHC_Profiles.profile0x0000 = false;
6779       ueNrCap.pdcp_Parameters.supportedROHC_Profiles.profile0x0001 = false;
6780       ueNrCap.pdcp_Parameters.supportedROHC_Profiles.profile0x0002 = false;
6781       ueNrCap.pdcp_Parameters.supportedROHC_Profiles.profile0x0003 = false;
6782       ueNrCap.pdcp_Parameters.supportedROHC_Profiles.profile0x0004 = false;
6783       ueNrCap.pdcp_Parameters.supportedROHC_Profiles.profile0x0006 = false;
6784       ueNrCap.pdcp_Parameters.supportedROHC_Profiles.profile0x0101 = false;
6785       ueNrCap.pdcp_Parameters.supportedROHC_Profiles.profile0x0102 = false;
6786       ueNrCap.pdcp_Parameters.supportedROHC_Profiles.profile0x0103 = false;
6787       ueNrCap.pdcp_Parameters.supportedROHC_Profiles.profile0x0104 = false;
6788       ueNrCap.pdcp_Parameters.maxNumberROHC_ContextSessions = PDCP_Parameters__maxNumberROHC_ContextSessions_cs2;
6789       ueNrCap.pdcp_Parameters.uplinkOnlyROHC_Profiles = NULLP;
6790       ueNrCap.pdcp_Parameters.continueROHC_Context = NULLP;
6791       ueNrCap.pdcp_Parameters.outOfOrderDelivery = NULLP;
6792       ueNrCap.pdcp_Parameters.shortSN = NULLP;
6793       ueNrCap.pdcp_Parameters.pdcp_DuplicationSRB = NULLP;
6794       ueNrCap.pdcp_Parameters.pdcp_DuplicationMCG_OrSCG_DRB = NULLP;
6795
6796       ueNrCap.rlc_Parameters = NULLP;
6797       ueNrCap.mac_Parameters = NULLP;
6798
6799       /* Filling PHY parameters */
6800       ueNrCap.phy_Parameters.phy_ParametersCommon = NULLP;
6801       ueNrCap.phy_Parameters.phy_ParametersXDD_Diff = NULLP;
6802       ueNrCap.phy_Parameters.phy_ParametersFRX_Diff = NULLP;
6803       ueNrCap.phy_Parameters.phy_ParametersFR1 = NULLP;
6804       ueNrCap.phy_Parameters.phy_ParametersFR2 = NULLP;
6805
6806       /* Filling RF parameters */
6807       elementCnt = 1;
6808       ueNrCap.rf_Parameters.supportedBandListNR.list.count = elementCnt;
6809       ueNrCap.rf_Parameters.supportedBandListNR.list.size = elementCnt * sizeof(struct BandNR *);
6810       CU_ALLOC(ueNrCap.rf_Parameters.supportedBandListNR.list.array, ueNrCap.rf_Parameters.supportedBandListNR.list.size);
6811       if(!ueNrCap.rf_Parameters.supportedBandListNR.list.array)
6812       {
6813          DU_LOG("\nERROR  --> F1AP : Memory allocation failed in fillUeCapRatCont");
6814          ret = RFAILED;
6815          break;
6816       }
6817
6818       for(idx = 0; idx < elementCnt; idx++)
6819       {
6820          CU_ALLOC(ueNrCap.rf_Parameters.supportedBandListNR.list.array[idx], sizeof(struct BandNR));
6821          if(!ueNrCap.rf_Parameters.supportedBandListNR.list.array[idx])
6822          {
6823             ret = RFAILED;
6824             break;
6825          }
6826       }
6827       if(ret == RFAILED)
6828          break;
6829
6830       idx = 0;
6831       ueNrCap.rf_Parameters.supportedBandListNR.list.array[idx]->bandNR = 1;
6832       ueNrCap.rf_Parameters.supportedBandCombinationList = NULLP;
6833       ueNrCap.rf_Parameters.appliedFreqBandListFilter = NULLP;
6834
6835       ueNrCap.measAndMobParameters = NULLP;
6836       ueNrCap.fdd_Add_UE_NR_Capabilities = NULLP;
6837       ueNrCap.tdd_Add_UE_NR_Capabilities = NULLP;
6838       ueNrCap.fr1_Add_UE_NR_Capabilities = NULLP;
6839       ueNrCap.fr2_Add_UE_NR_Capabilities = NULLP;
6840       ueNrCap.featureSets = NULLP;
6841
6842       CU_ALLOC(ueNrCap.featureSets, sizeof(struct FeatureSets));
6843       if(!ueNrCap.featureSets)
6844       {
6845          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in fillUeCapRatCont");
6846          ret = RFAILED;
6847          break;
6848       }
6849
6850       if(fillFeatureSets(ueNrCap.featureSets) != ROK)
6851       {
6852          DU_LOG("\nERROR  -->  fillDLFeatureSets() failed ");
6853          ret = RFAILED;
6854          break;
6855       }
6856
6857       ueNrCap.featureSetCombinations = NULLP;
6858       ueNrCap.lateNonCriticalExtension = NULLP;
6859       ueNrCap.nonCriticalExtension = NULLP;
6860
6861       /* encode UE Capability RAT Container List into duToCuRrcContainer */
6862       xer_fprint(stdout, &asn_DEF_UE_NR_Capability, &ueNrCap);
6863       cmMemset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
6864       encBufSize = 0;
6865       encRetVal = aper_encode(&asn_DEF_UE_NR_Capability, 0, &ueNrCap, PrepFinalEncBuf, encBuf);
6866
6867       /* Encode results */
6868       if(encRetVal.encoded == ENCODE_FAIL)
6869       {
6870          DU_LOG( "\nERROR  -->  F1AP : Could not encode UE Capability RAT Container (at %s)\n",\
6871             encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
6872          break;
6873       }
6874       else
6875       {
6876          DU_LOG("\nDEBUG  -->  F1AP : Created APER encodedbuffer for UE Capability RAT Container\n");
6877          for(int i=0; i< encBufSize; i++)
6878          {
6879             DU_LOG("%x",encBuf[i]);
6880          }
6881       }
6882
6883       ueCapRatContBuf->size = encBufSize;
6884       CU_ALLOC(ueCapRatContBuf->buf, ueCapRatContBuf->size);
6885       if(!ueCapRatContBuf->buf)
6886       {
6887          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in fillUeCapabilityContainer");
6888          break;
6889       }
6890       memcpy(ueCapRatContBuf->buf, encBuf, ueCapRatContBuf->size);
6891       ret = ROK;
6892       break;
6893    }
6894    freeUeCapRatCont(&ueNrCap);
6895    return ROK;
6896 }
6897
6898 /*******************************************************************
6899  *
6900  * @brief Fill UE Capability RAT container list
6901  *
6902  * @details
6903  *
6904  *    Function : fillUeCapRatContList
6905  *
6906  *    Functionality: Fill UE Capability RAT container list
6907
6908  *
6909  * @params[in] UE capability RAT container list
6910  * @return ROK     - success
6911  *         RFAILED - failure
6912  *
6913  * ****************************************************************/
6914 uint8_t fillUeCapRatContList(UE_CapabilityRAT_ContainerListRRC_t  *ueCapablityList)
6915 {
6916     uint8_t          ret = RFAILED;
6917     uint8_t          idx, elementCnt;
6918
6919     while(true)
6920     {
6921        elementCnt = 1;
6922        ueCapablityList->list.count = elementCnt;
6923        ueCapablityList->list.size = elementCnt * sizeof(UE_CapabilityRAT_Container_t *);
6924
6925        CU_ALLOC(ueCapablityList->list.array, ueCapablityList->list.size);
6926        if(!ueCapablityList->list.array)
6927        {
6928           DU_LOG("\nERROR  -->  Memory allocation failed in fillUeCapRatContList");
6929           ret = RFAILED;
6930           break;
6931        }
6932
6933        for(idx=0; idx<elementCnt; idx++)
6934        {
6935           CU_ALLOC(ueCapablityList->list.array[idx], sizeof(UE_CapabilityRAT_Container_t));
6936           if(ueCapablityList->list.array[idx] == NULLP)
6937           {
6938              DU_LOG("\nERROR  -->  Memory allocation failed in fillUeCapRatContList");
6939              ret = RFAILED;
6940              break;
6941           }
6942        }
6943        idx = 0;
6944        ueCapablityList->list.array[idx]->rat_Type = RAT_Type_nr;
6945        if(fillUeCapRatCont(&ueCapablityList->list.array[idx]->ue_CapabilityRAT_Container) != ROK)
6946        {
6947           DU_LOG("\nERROR  -->  F1AP : Failed to fill UE capability RAT Conatiner");
6948           ret = RFAILED;
6949           break;
6950        }
6951
6952        ret = ROK;
6953        break;
6954     }
6955     return ret;
6956 }
6957
6958 /*******************************************************************
6959  *
6960  * @brief Fill UE Capability RAT container list octet string
6961  *
6962  * @details
6963  *
6964  *    Function : fillUeCapRatContListBuf
6965  *
6966  *    Functionality: Fill UE Capability RAT container list octet string
6967
6968  *
6969  * @params[in] UE capability RAT container list buffer
6970  * @return ROK     - success
6971  *         RFAILED - failure
6972  *
6973  * ****************************************************************/
6974 uint8_t fillUeCapRatContListBuf(UE_CapabilityRAT_ContainerList_t *ueCapablityListBuf)
6975 {
6976    uint8_t          ret = RFAILED;
6977    asn_enc_rval_t   encRetVal;
6978    UE_CapabilityRAT_ContainerListRRC_t  ueCapablityList;
6979
6980    while(true)
6981    {
6982       ret = fillUeCapRatContList(&ueCapablityList);
6983       if(ret != ROK)
6984       {
6985          DU_LOG( "\nERROR  -->  F1AP : Failed to fill UE Capability RAT container list");
6986          break;
6987       }
6988
6989       /* encode UE Capability RAT Container List into duToCuRrcContainer */
6990       xer_fprint(stdout, &asn_DEF_UE_CapabilityRAT_ContainerListRRC, &ueCapablityList);
6991       cmMemset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
6992       encBufSize = 0;
6993       encRetVal = aper_encode(&asn_DEF_UE_CapabilityRAT_ContainerListRRC, 0, \
6994             &ueCapablityList, PrepFinalEncBuf, encBuf);
6995
6996       /* Encode results */
6997       if(encRetVal.encoded == ENCODE_FAIL)
6998       {
6999          DU_LOG( "\nERROR  -->  F1AP : Could not encode UE Capability RAT Container (at %s)\n",\
7000                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
7001          break;
7002       }
7003       else
7004       {
7005          DU_LOG("\nDEBUG  -->  F1AP : Created APER encodedbuffer for UE Capability RAT Container\n");
7006          for(int i=0; i< encBufSize; i++)
7007          {
7008             DU_LOG("%x",encBuf[i]);
7009          }
7010       }
7011
7012       ueCapablityListBuf->size = encBufSize;
7013       CU_ALLOC(ueCapablityListBuf->buf, ueCapablityListBuf->size);
7014       if(!ueCapablityListBuf->buf)
7015       {
7016          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in fillUeCapabilityContainer");
7017          break;
7018       }
7019       memcpy(ueCapablityListBuf->buf, encBuf, ueCapablityListBuf->size);
7020       ret = ROK;
7021       break;
7022    }
7023    freeUeCapRatContList(&ueCapablityList);
7024    return ret;
7025 }
7026
7027 /*******************************************************************
7028  *
7029  * @brief Free Measurement Timing Configuration
7030  *
7031  * @details
7032  *
7033  *    Function : freeMeasuementTimingConfig
7034  *
7035  *    Functionality: Free Measurement Timing Configuration
7036  *
7037  * @params[in] MeasurementTimingConfiguration_IEs_t measTimingCfg
7038  * @return void
7039  *
7040  * ****************************************************************/
7041 void freeMeasuementTimingConfig(MeasurementTimingConfigurationRrc_t measTimingConfig)
7042 {
7043    uint8_t measCfgIdx;
7044    MeasurementTimingConfigurationRrc_IEs_t *measTimingCfg = NULLP;
7045    MeasTiming_t *measTiming = NULLP;
7046
7047    if(measTimingConfig.criticalExtensions.choice.c1)
7048    {
7049       if(measTimingConfig.criticalExtensions.choice.c1->choice.measTimingConf)
7050       {
7051          measTimingCfg = measTimingConfig.criticalExtensions.choice.c1->choice.measTimingConf;
7052          if(measTimingCfg->measTiming)
7053          {
7054             if(measTimingCfg->measTiming->list.array)
7055             {
7056                for(measCfgIdx = 0; measCfgIdx < measTimingCfg->measTiming->list.count; measCfgIdx++)
7057                {
7058                   measTiming = measTimingCfg->measTiming->list.array[measCfgIdx];
7059                   CU_FREE(measTiming->frequencyAndTiming, sizeof(struct MeasTiming__frequencyAndTiming));
7060                   CU_FREE(measTimingCfg->measTiming->list.array[measCfgIdx], sizeof(MeasTiming_t));
7061                }
7062                CU_FREE(measTimingCfg->measTiming->list.array, measTimingCfg->measTiming->list.size);
7063             }
7064             CU_FREE(measTimingCfg->measTiming, sizeof(MeasTimingList_t));
7065          }
7066          CU_FREE(measTimingConfig.criticalExtensions.choice.c1->choice.measTimingConf, sizeof(struct MeasurementTimingConfigurationRrc_IEs));
7067       }
7068       CU_FREE(measTimingConfig.criticalExtensions.choice.c1, sizeof(struct MeasurementTimingConfigurationRrc__criticalExtensions__c1));
7069    }
7070 }
7071
7072 /*******************************************************************
7073  *
7074  * @brief Fill Measurement Timing Configuration
7075  *
7076  * @details
7077  *
7078  *    Function : fillMeasTimingCfg
7079  *
7080  *    Functionality: Fill Measurement Timing Configuration
7081  *
7082  * @params[in] MeasurementTimingConfiguration_IEs_t measTimingCfg
7083  * @return ROK     - success
7084  *         RFAILED - failure
7085  *
7086  * ****************************************************************/
7087 uint8_t fillMeasTimingCfg(MeasurementTimingConfigurationRrc_IEs_t *measTimingCfg)
7088 {
7089    uint8_t elementCnt = 0;
7090    uint8_t measCfgIdx = 0;
7091    MeasTiming_t *measTiming;
7092    SSB_MTC_t *smtc;
7093
7094    CU_ALLOC(measTimingCfg->measTiming, sizeof(MeasTimingList_t));
7095    if(!measTimingCfg->measTiming)
7096    {
7097       DU_LOG( "\nERROR  -->  F1AP : Failed to allocated memory  for measTiming in fillMeasTimingCfg");
7098       return RFAILED;
7099    }
7100
7101    elementCnt = 1;
7102    measTimingCfg->measTiming->list.count = elementCnt;
7103    measTimingCfg->measTiming->list.size = measTimingCfg->measTiming->list.count * sizeof(MeasTiming_t *);
7104    CU_ALLOC(measTimingCfg->measTiming->list.array, measTimingCfg->measTiming->list.size);
7105    if(!measTimingCfg->measTiming->list.array)
7106    {
7107       DU_LOG( "\nERROR  -->  F1AP : Failed to allocated memory for measTiming array in fillMeasTimingCfg");
7108       return RFAILED;
7109    }
7110
7111    for(measCfgIdx = 0; measCfgIdx < measTimingCfg->measTiming->list.count; measCfgIdx++)
7112    {
7113       CU_ALLOC(measTimingCfg->measTiming->list.array[measCfgIdx], sizeof(MeasTiming_t));
7114       if(!measTimingCfg->measTiming->list.array[measCfgIdx])
7115       {
7116          DU_LOG( "\nERROR  -->  F1AP : Failed to allocated memory for measTiming array element in fillMeasTimingCfg");
7117          return RFAILED;
7118       }
7119    }
7120
7121    measCfgIdx = 0;
7122    measTiming = measTimingCfg->measTiming->list.array[measCfgIdx];
7123    CU_ALLOC(measTiming->frequencyAndTiming, sizeof(struct MeasTiming__frequencyAndTiming));
7124    if(!measTiming->frequencyAndTiming)
7125    {
7126       DU_LOG( "\nERROR  -->  F1AP : Failed to allocated memory for frequency and timing IE in fillMeasTimingCfg");
7127       return RFAILED;
7128    }
7129
7130    measTiming->frequencyAndTiming->carrierFreq =  623800; /* This is a randomly chosen value since ARFCN configured in DU is 623400 */
7131    measTiming->frequencyAndTiming->ssbSubcarrierSpacing = SubcarrierSpacing_kHz15;
7132
7133    smtc = &measTiming->frequencyAndTiming->ssb_MeasurementTimingConfiguration;
7134    smtc->periodicityAndOffset.present = SSB_MTC__periodicityAndOffset_PR_sf20;
7135    smtc->periodicityAndOffset.choice.sf20 = 0;
7136    smtc->duration = SSB_MTC__duration_sf1;
7137    return ROK;
7138 }
7139
7140 /*******************************************************************
7141  *
7142  * @brief Fill Measurement Timing Configuration Octet string
7143  *
7144  * @details
7145  *
7146  *    Function : fillMeasConfigBuf
7147  *
7148  *    Functionality: Fill Measurement Timing Configuration Octet string
7149
7150  *
7151  * @params[in] MeasConfig_t *measConfgBuf
7152  * @return ROK     - success
7153  *         RFAILED - failure
7154  *
7155  * ****************************************************************/
7156 uint8_t fillMeasTimingConfigBuf(MeasConfig_t *measTimingConfigBuf)
7157 {
7158    uint8_t          ret = RFAILED;
7159    asn_enc_rval_t   encRetVal;
7160    MeasurementTimingConfigurationRrc_t measTimingConfig;
7161
7162    while(true)
7163    {
7164       measTimingConfig.criticalExtensions.present = MeasurementTimingConfigurationRrc__criticalExtensions_PR_c1;
7165       CU_ALLOC(measTimingConfig.criticalExtensions.choice.c1, sizeof(struct MeasurementTimingConfigurationRrc__criticalExtensions__c1));
7166       if(!measTimingConfig.criticalExtensions.choice.c1)
7167       {
7168          DU_LOG( "\nERROR  -->  F1AP : Failed to allocated memory for measurement configuration extension");
7169          return RFAILED;
7170       }
7171       measTimingConfig.criticalExtensions.choice.c1->present = MeasurementTimingConfigurationRrc__criticalExtensions__c1_PR_measTimingConf;
7172
7173       CU_ALLOC(measTimingConfig.criticalExtensions.choice.c1->choice.measTimingConf, sizeof(struct MeasurementTimingConfigurationRrc_IEs));
7174       if(!measTimingConfig.criticalExtensions.choice.c1->choice.measTimingConf)
7175       {
7176          DU_LOG( "\nERROR  -->  F1AP : Failed to allocated memory for measurement timing configuration IE");
7177          return RFAILED;
7178       }
7179
7180       ret = fillMeasTimingCfg(measTimingConfig.criticalExtensions.choice.c1->choice.measTimingConf);
7181       if(ret != ROK)
7182       {
7183          DU_LOG( "\nERROR  -->  F1AP : Failed to fill measurement timing configuration IE");
7184          break;
7185       }
7186
7187       /* Encode measurement timing configuration into octet string */
7188       xer_fprint(stdout, &asn_DEF_MeasurementTimingConfigurationRrc, &measTimingConfig);
7189       cmMemset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
7190       encBufSize = 0;
7191       encRetVal = aper_encode(&asn_DEF_MeasurementTimingConfigurationRrc, 0, &measTimingConfig, PrepFinalEncBuf, encBuf);
7192
7193       /* Encode results */
7194       if(encRetVal.encoded == ENCODE_FAIL)
7195       {
7196          DU_LOG( "\nERROR  -->  F1AP : Could not encode Measurement Timing Configuration (at %s)\n",\
7197                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
7198          break;
7199       }
7200       else
7201       {
7202          DU_LOG("\nDEBUG  -->  F1AP : Created APER encodedbuffer for Measurement timing configuration\n");
7203          for(int i=0; i< encBufSize; i++)
7204          {
7205             DU_LOG("%x",encBuf[i]);
7206          }
7207       }
7208
7209       measTimingConfigBuf->size = encBufSize;
7210       CU_ALLOC(measTimingConfigBuf->buf, measTimingConfigBuf->size);
7211       if(!measTimingConfigBuf->buf)
7212       {
7213          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed fillMeasTimingConfigBuf");
7214          break;
7215       }
7216       memcpy(measTimingConfigBuf->buf, encBuf, measTimingConfigBuf->size);
7217       ret = ROK;
7218       break;
7219    }
7220    freeMeasuementTimingConfig(measTimingConfig);
7221    return ret;
7222 }
7223
7224 /******************************************************************
7225  *
7226  * @brief Free RRC reconfiguration non-critical extension
7227  *
7228  * @details
7229  *
7230  *    Function : freeRrcReconfigNonCriticalExt
7231  *
7232  *    Functionality: Free RRC reconfiguration non-critical extension
7233  *
7234  * @params[in] RRC reconfiguration IE
7235  * @return void
7236  *
7237  * ****************************************************************/
7238 void freeRrcReconfigNonCriticalExt(RRCReconfiguration_v1530_IEs_t *rrcRecfg)
7239 {
7240    if(rrcRecfg->masterCellGroup)
7241    {
7242       CU_FREE(rrcRecfg->masterCellGroup, sizeof(OCTET_STRING_t));
7243    }
7244 }
7245
7246 /******************************************************************
7247  *
7248  * @brief Free measurement object addmod list
7249  *
7250  * @details
7251  *
7252  *    Function : freeMeasObjToAddModList
7253  *
7254  *    Functionality: Free measurement object add mod list
7255  *
7256  * @params[in] Measurement object add/mod list
7257  * @return void
7258  *
7259  * ****************************************************************/
7260 void freeMeasObjToAddModList(MeasObjectToAddModList_t *measObjList)
7261 {
7262    uint8_t objIdx;
7263    MeasObjectNR_t *measObject;
7264
7265    if(measObjList->list.array)
7266    {
7267       for(objIdx = 0; objIdx < measObjList->list.size; objIdx++)
7268       {
7269          if(measObjList->list.array[objIdx])
7270          {
7271             if(measObjList->list.array[objIdx]->measObject.choice.measObjectNR)
7272             {
7273                measObject = measObjList->list.array[objIdx]->measObject.choice.measObjectNR;
7274                CU_FREE(measObject->ssbFrequency, sizeof(ARFCN_ValueNR_t));
7275                CU_FREE(measObject->ssbSubcarrierSpacing, sizeof(SubcarrierSpacing_t));
7276                CU_FREE(measObject->smtc1 , sizeof(SSB_MTC_t));
7277                if(measObject->absThreshSS_BlocksConsolidation)
7278                {
7279                   CU_FREE(measObject->absThreshSS_BlocksConsolidation->thresholdRSRP, sizeof(RSRP_Range_t));
7280                   CU_FREE(measObject->absThreshSS_BlocksConsolidation->thresholdRSRQ, sizeof(RSRQ_Range_t));
7281                   CU_FREE(measObject->absThreshSS_BlocksConsolidation->thresholdSINR, sizeof(SINR_Range_t));
7282                   CU_FREE(measObject->absThreshSS_BlocksConsolidation, sizeof(ThresholdNR_t));
7283                }
7284                CU_FREE(measObject->nrofSS_BlocksToAverage, sizeof(long));
7285                CU_FREE(measObject->offsetMO.rsrpOffsetSSB, sizeof(Q_OffsetRange_t));
7286                CU_FREE(measObject->offsetMO.rsrqOffsetSSB, sizeof(Q_OffsetRange_t));
7287                CU_FREE(measObject->offsetMO.sinrOffsetSSB, sizeof(Q_OffsetRange_t));
7288                CU_FREE(measObjList->list.array[objIdx]->measObject.choice.measObjectNR, sizeof(MeasObjectNR_t));
7289             }
7290             CU_FREE(measObjList->list.array[objIdx], sizeof(MeasObjectToAddMod_t));
7291          }
7292       }
7293       CU_FREE(measObjList->list.array, measObjList->list.size);
7294    }
7295 }
7296
7297 /******************************************************************
7298  *
7299  * @brief Free report config add mod list
7300  *
7301  * @details
7302  *
7303  *    Function : freeReportCfgToAddModList
7304  *
7305  *    Functionality: Free report config add mod list
7306  *
7307  * @params[in] Report config list
7308  * @return void
7309  *
7310  * ****************************************************************/
7311 void freeReportCfgToAddModList(ReportConfigToAddModList_t *reportCfgList)
7312 {
7313    uint8_t reportCfgIdx;
7314    ReportConfigToAddMod_t *reportCfg;
7315    ReportConfigNR_t *reportCfgNr;
7316    EventTriggerConfig_t *eventTriggCfg;
7317
7318    if(reportCfgList->list.array)
7319    {
7320       for(reportCfgIdx=0; reportCfgIdx < reportCfgList->list.count; reportCfgIdx++)
7321       {
7322          if(reportCfgList->list.array[reportCfgIdx])
7323          {
7324             reportCfg = reportCfgList->list.array[reportCfgIdx];
7325             if(reportCfg->reportConfig.choice.reportConfigNR)
7326             {
7327                reportCfgNr = reportCfg->reportConfig.choice.reportConfigNR;
7328                if(reportCfgNr->reportType.choice.eventTriggered)
7329                {
7330                   eventTriggCfg = reportCfgNr->reportType.choice.eventTriggered;
7331                   CU_FREE(eventTriggCfg->eventId.choice.eventA3, sizeof(struct EventTriggerConfig__eventId__eventA3));
7332                   CU_FREE(eventTriggCfg->reportQuantityRS_Indexes, sizeof(MeasReportQuantity_t));
7333                   CU_FREE(eventTriggCfg->maxNrofRS_IndexesToReport, sizeof(long));
7334                   CU_FREE(reportCfgNr->reportType.choice.eventTriggered, sizeof(EventTriggerConfig_t));
7335                }
7336             }
7337          }
7338          CU_FREE(reportCfgList->list.array[reportCfgIdx], sizeof(ReportConfigToAddMod_t));
7339       }
7340       CU_FREE(reportCfgList->list.array, reportCfgList->list.size);
7341    }
7342 }
7343
7344 /******************************************************************
7345  *
7346  * @brief Free measurement id to add mod list
7347  *
7348  * @details
7349  *
7350  *    Function : freeMeasIdToAddModList
7351  *
7352  *    Functionality: Free measurement id to add mod list
7353  *
7354  * @params[in] Measurement id to add mod list
7355  * @return void
7356  *
7357  * ****************************************************************/
7358 void freeMeasIdToAddModList(MeasIdToAddModList_t *measIdList)
7359 {
7360    uint8_t measIdIdx;
7361    if(measIdList->list.array)
7362    {
7363       for(measIdIdx=0; measIdIdx < measIdList->list.count; measIdIdx++)
7364       {
7365          CU_FREE(measIdList->list.array[measIdIdx], sizeof(MeasIdToAddMod_t));
7366       }
7367       CU_FREE(measIdList->list.array, measIdList->list.size);
7368    }
7369 }
7370
7371 /*******************************************************************
7372  *
7373  * @brief Free quantity config
7374  *
7375  * @details
7376  *
7377  *    Function : freeQunatityConfig
7378  *
7379  *    Functionality: Free quantity config
7380  *
7381  * @params[in] Quantity Config
7382  * @return void
7383  *
7384  * ****************************************************************/
7385 void freeQuantityConfig(QuantityConfig_t *quantityCfg)
7386 {
7387    uint8_t quanCfgIdx;
7388    QuantityConfigNR_t *quantityCfgNr;
7389
7390    if(quantityCfg->quantityConfigNR_List)
7391    {
7392       if(quantityCfg->quantityConfigNR_List->list.array)
7393       {
7394          for(quanCfgIdx = 0; quanCfgIdx < quantityCfg->quantityConfigNR_List->list.count; quanCfgIdx++)
7395          {
7396             if(quantityCfg->quantityConfigNR_List->list.array[quanCfgIdx])
7397             {
7398                quantityCfgNr = quantityCfg->quantityConfigNR_List->list.array[quanCfgIdx];
7399                CU_FREE(quantityCfgNr->quantityConfigCell.ssb_FilterConfig.filterCoefficientRSRP, sizeof(FilterCoefficient_t));
7400                CU_FREE(quantityCfgNr->quantityConfigCell.ssb_FilterConfig.filterCoefficientRSRQ, sizeof(FilterCoefficient_t));
7401                CU_FREE(quantityCfgNr->quantityConfigCell.ssb_FilterConfig.filterCoefficientRS_SINR, sizeof(FilterCoefficient_t));
7402                if(quantityCfgNr->quantityConfigRS_Index)
7403                {
7404                   CU_FREE(quantityCfgNr->quantityConfigRS_Index->ssb_FilterConfig.filterCoefficientRSRP, sizeof(FilterCoefficient_t));
7405                   CU_FREE(quantityCfgNr->quantityConfigRS_Index->ssb_FilterConfig.filterCoefficientRSRQ, sizeof(FilterCoefficient_t));
7406                   CU_FREE(quantityCfgNr->quantityConfigRS_Index->ssb_FilterConfig.filterCoefficientRS_SINR, sizeof(FilterCoefficient_t));
7407                   CU_FREE(quantityCfgNr->quantityConfigRS_Index, sizeof(QuantityConfigRS_t));
7408                }
7409                CU_FREE(quantityCfg->quantityConfigNR_List->list.array[quanCfgIdx], sizeof(QuantityConfigNR_t));
7410             }
7411          }
7412          CU_FREE(quantityCfg->quantityConfigNR_List->list.array, quantityCfg->quantityConfigNR_List->list.size);
7413       }
7414       CU_FREE(quantityCfg->quantityConfigNR_List, sizeof(struct QuantityConfig__quantityConfigNR_List));
7415    }
7416 }
7417
7418 /******************************************************************
7419  *
7420  * @brief Free measurement Config
7421  *
7422  * @details
7423  *
7424  *    Function : freeMeasConfig
7425  *
7426  *    Functionality: Free measurement config
7427  *
7428  * @params[in] Measurement config
7429  * @return void
7430  *
7431  * ****************************************************************/
7432 void freeMeasConfig(MeasConfigRrc_t *measConfig)
7433 {
7434    if(measConfig->measObjectToAddModList)
7435    {
7436       freeMeasObjToAddModList(measConfig->measObjectToAddModList);
7437       CU_FREE(measConfig->measObjectToAddModList, sizeof(MeasObjectToAddModList_t));
7438    }
7439    if(measConfig->reportConfigToAddModList)
7440    {
7441       freeReportCfgToAddModList(measConfig->reportConfigToAddModList);
7442       CU_FREE(measConfig->reportConfigToAddModList, sizeof(ReportConfigToAddModList_t));
7443    }
7444    if(measConfig->measIdToAddModList)
7445    {
7446       freeMeasIdToAddModList(measConfig->measIdToAddModList);
7447       CU_FREE(measConfig->measIdToAddModList, sizeof(MeasIdToAddModList_t));
7448    }
7449    if(measConfig->s_MeasureConfig)
7450    {
7451       CU_FREE(measConfig->s_MeasureConfig, sizeof(struct MeasConfigRrc__s_MeasureConfig));
7452    }
7453    if(measConfig->quantityConfig)
7454    {
7455       freeQuantityConfig(measConfig->quantityConfig);
7456       CU_FREE(measConfig->quantityConfig, sizeof(QuantityConfig_t));
7457    }
7458 }
7459 /******************************************************************
7460  *
7461  * @brief Free DRB to AddMod List
7462  *
7463  * @details
7464  *
7465  *    Function : freeDrbToAddModList
7466  *
7467  *    Functionality: Free SRB to AddMod List
7468  *
7469  * @params[in] SBR to add/mod list
7470  * @return void
7471  *
7472  * ****************************************************************/
7473 void freeDrbToAddModList(DRB_ToAddModList_t *drbToAddList)
7474 {
7475    uint8_t drbIdx;
7476    if(drbToAddList->list.array)
7477    {
7478       for(drbIdx = 0; drbIdx < drbToAddList->list.count; drbIdx++)
7479       {
7480          if(drbToAddList->list.array[drbIdx]->pdcp_Config)
7481          {
7482             if(drbToAddList->list.array[drbIdx]->pdcp_Config->drb)
7483             {
7484                CU_FREE(drbToAddList->list.array[drbIdx]->pdcp_Config->drb->discardTimer, sizeof(long));
7485                CU_FREE(drbToAddList->list.array[drbIdx]->pdcp_Config->drb->pdcp_SN_SizeUL, sizeof(long));
7486                CU_FREE(drbToAddList->list.array[drbIdx]->pdcp_Config->drb->pdcp_SN_SizeDL, sizeof(long));
7487                CU_FREE(drbToAddList->list.array[drbIdx]->pdcp_Config->drb, sizeof(struct PDCP_Config__drb));
7488             }
7489             CU_FREE(drbToAddList->list.array[drbIdx]->pdcp_Config->t_Reordering, sizeof(long));
7490             CU_FREE(drbToAddList->list.array[drbIdx]->pdcp_Config, sizeof(PDCP_Config_t));
7491          }
7492          CU_FREE(drbToAddList->list.array[drbIdx], sizeof(DRB_ToAddMod_t));
7493       }
7494       CU_FREE(drbToAddList->list.array, drbToAddList->list.size);
7495    }
7496 }
7497
7498 /******************************************************************
7499  *
7500  * @brief Free SRB to AddMod List
7501  *
7502  * @details
7503  *
7504  *    Function : freeSrbToAddModList
7505  *
7506  *    Functionality: Free SRB to AddMod List
7507  *
7508  * @params[in] SBR to add/mod list
7509  * @return void
7510  *
7511  * ****************************************************************/
7512 void freeSrbToAddModList(SRB_ToAddModList_t *srbToAddList)
7513 {
7514    uint8_t srbIdx;
7515    if(srbToAddList->list.array)
7516    {
7517       for(srbIdx = 0; srbIdx < srbToAddList->list.count; srbIdx++)
7518       {
7519          CU_FREE(srbToAddList->list.array[srbIdx]->reestablishPDCP, sizeof(long));
7520          if(srbToAddList->list.array[srbIdx]->pdcp_Config)
7521          {
7522             CU_FREE(srbToAddList->list.array[srbIdx]->pdcp_Config->t_Reordering, sizeof(long));
7523             CU_FREE(srbToAddList->list.array[srbIdx]->pdcp_Config, sizeof(PDCP_Config_t));
7524          }
7525
7526          CU_FREE(srbToAddList->list.array[srbIdx], sizeof(SRB_ToAddMod_t));
7527       }
7528       CU_FREE(srbToAddList->list.array, srbToAddList->list.size);
7529    }
7530 }
7531
7532 /******************************************************************
7533  *
7534  * @brief Free Radio Bearer Config
7535  *
7536  * @details
7537  *
7538  *    Function : fillRadioBearerConfig
7539  *
7540  *    Functionality: Free Radio Bearer config
7541  *
7542  * @params[in] Radio bearer config
7543  * @return void
7544  *
7545  * ****************************************************************/
7546 void freeRadioBearerConfig(RadioBearerConfig_t *radioBearerConfig)
7547 {
7548    if(radioBearerConfig->srb_ToAddModList)
7549    {
7550       freeSrbToAddModList(radioBearerConfig->srb_ToAddModList);
7551       CU_FREE(radioBearerConfig->srb_ToAddModList, sizeof(SRB_ToAddModList_t));
7552    }
7553    if(radioBearerConfig->drb_ToAddModList)
7554    {
7555       freeDrbToAddModList(radioBearerConfig->drb_ToAddModList);
7556       CU_FREE(radioBearerConfig->drb_ToAddModList, sizeof(DRB_ToAddModList_t));
7557    }
7558 }
7559
7560 /******************************************************************
7561  *
7562  * @brief Free reconfiguration message
7563  *
7564  * @details
7565  *
7566  *    Function : freeRrcReconfig
7567  *
7568  *    Functionality: Free reconfiguration message
7569  *
7570  * @params[in] RRC Reconfiguration message
7571  * @return void
7572  *
7573  * ****************************************************************/
7574 void freeRrcReconfig(RRCReconfiguration_t *rrcReconfig)
7575 {
7576    if(rrcReconfig->criticalExtensions.choice.rrcReconfiguration)
7577    {
7578       if(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->radioBearerConfig)
7579       {
7580          freeRadioBearerConfig(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->radioBearerConfig);
7581          CU_FREE(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->radioBearerConfig, sizeof(RadioBearerConfig_t));
7582       }
7583       if(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->measConfig)
7584       {
7585          freeMeasConfig(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->measConfig);
7586          CU_FREE(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->measConfig, sizeof(MeasConfigRrc_t));
7587       }
7588       if(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->nonCriticalExtension)
7589       {
7590          freeRrcReconfigNonCriticalExt(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->nonCriticalExtension);
7591          CU_FREE(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->nonCriticalExtension, sizeof(struct RRCReconfiguration_v1530_IEs));
7592       }
7593       CU_FREE(rrcReconfig->criticalExtensions.choice.rrcReconfiguration, sizeof(RRCReconfiguration_IEs_t));
7594    }
7595 }
7596
7597 /******************************************************************
7598  *
7599  * @brief Fill SRB To Add Mod list
7600  *
7601  * @details
7602  *
7603  *    Function : fillSrbToAddModList
7604  *
7605  *    Functionality: fill SRB to Add Mod list
7606  *
7607  * @params[in] UE control block
7608  *             SRB to Add/Mod list
7609  * @return ROK     - success
7610  *         RFAILED - failure
7611  *
7612  * ****************************************************************/
7613 uint8_t fillSrbToAddModList(CuUeCb *ueCb, SRB_ToAddModList_t *srbToAddList, bool updateAllRbCfg)
7614 {
7615    uint8_t srbIdx, srbDbIdx, elementCnt = 0;
7616
7617    if(updateAllRbCfg)
7618       elementCnt = ueCb->numSrb;
7619    else
7620    {
7621       for(srbDbIdx=0; srbDbIdx < ueCb->numSrb; srbDbIdx++)
7622       {
7623          if(ueCb->srbList[srbDbIdx].cfgSentToUe == false)
7624             elementCnt++;
7625       }
7626    }
7627
7628    if(!elementCnt)
7629    {
7630       DU_LOG("INFO  --> F1AP : No SRB available to add or modify");
7631       return ROK;
7632    }
7633
7634    CU_ALLOC(srbToAddList, sizeof(SRB_ToAddModList_t));
7635    if(!srbToAddList)
7636    {
7637       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for SRB to AddMod List in fillRadioBearerConfig");
7638       return RFAILED;
7639    }
7640    srbToAddList->list.count = elementCnt;
7641    srbToAddList->list.size = srbToAddList->list.count * sizeof(SRB_ToAddMod_t *);
7642
7643    CU_ALLOC(srbToAddList->list.array, srbToAddList->list.size);
7644    if(!srbToAddList->list.array)
7645    {
7646       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for SRB to AddMod list array in fillSrbToAddModList");
7647       return RFAILED;
7648    }
7649
7650    srbIdx = 0;
7651    for(srbDbIdx = 0; srbDbIdx < ueCb->numSrb; srbDbIdx++)
7652    {
7653       if(!updateAllRbCfg && ueCb->srbList[srbDbIdx].cfgSentToUe)
7654          continue;
7655
7656       CU_ALLOC(srbToAddList->list.array[srbIdx], sizeof(SRB_ToAddMod_t));
7657       if(!srbToAddList->list.array[srbIdx])
7658       {
7659          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for SRB to AddMod list element in fillSrbToAddModList");
7660          return RFAILED;
7661       }
7662
7663       srbToAddList->list.array[srbIdx]->srb_Identity = ueCb->srbList[srbDbIdx].srbId;
7664
7665       /* Reestablish PDCP */
7666       CU_ALLOC(srbToAddList->list.array[srbIdx]->reestablishPDCP, sizeof(long));
7667       if(!srbToAddList->list.array[srbIdx]->reestablishPDCP)
7668       {
7669          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for reestablish PDCP IE in fillSrbToAddModList");
7670          return RFAILED;
7671       }
7672       *(srbToAddList->list.array[srbIdx]->reestablishPDCP) = SRB_ToAddMod__reestablishPDCP_true;
7673
7674       /* PDCP configuration */
7675       CU_ALLOC(srbToAddList->list.array[srbIdx]->pdcp_Config, sizeof(PDCP_Config_t));
7676       if(!srbToAddList->list.array[srbIdx]->pdcp_Config)
7677       {
7678          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for PDCP config IE in fillSrbToAddModList");
7679          return RFAILED;
7680       }
7681
7682       /* Reordering timer */
7683       CU_ALLOC(srbToAddList->list.array[srbIdx]->pdcp_Config->t_Reordering, sizeof(long));
7684       if(!srbToAddList->list.array[srbIdx]->pdcp_Config->t_Reordering)
7685       {
7686          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for reordering timer in fillSrbToAddModList");
7687          return RFAILED;
7688       }
7689       *(srbToAddList->list.array[srbIdx]->pdcp_Config->t_Reordering) = PDCP_Config__t_Reordering_ms40;
7690
7691       srbIdx++;
7692    }
7693    return ROK;
7694 }
7695
7696 /******************************************************************
7697  *
7698  * @biief Fill DRBeTo Add Mod list
7699  *
7700  * @details
7701  *
7702  *    Function : fillDrbToAddModList
7703  *
7704  *    Functionality: fill DRB to Add Mod list
7705  *
7706  * @params[in] UE control block
7707  *             DRB to Add/Mod list
7708  * @return ROK     - success
7709  *         RFAILED - failure
7710  *
7711  * ****************************************************************/
7712 uint8_t fillDrbToAddModList(CuUeCb *ueCb, DRB_ToAddModList_t *drbToAddList, bool updateAllRbCfg)
7713 {
7714    uint8_t drbIdx, drbDbIdx, elementCnt = 0;
7715
7716    if(updateAllRbCfg)
7717       elementCnt = ueCb->numDrb;
7718    else
7719    {
7720       for(drbDbIdx=0; drbDbIdx < ueCb->numDrb; drbDbIdx++)
7721       {
7722          if(ueCb->drbList[drbDbIdx].cfgSentToUe == false)
7723             elementCnt++;
7724       }
7725    }
7726
7727    if(!elementCnt)
7728    {
7729       DU_LOG("INFO  --> F1AP : No DRB available to add or modify");
7730       return ROK;
7731    }
7732
7733    /* DRB To Add/Mod List */
7734    CU_ALLOC(drbToAddList, sizeof(DRB_ToAddModList_t));
7735    if(!drbToAddList)
7736    {
7737       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for DRB to AddMod List in fillRadioBearerConfig");
7738       return RFAILED;
7739    }
7740
7741    drbToAddList->list.count = elementCnt;
7742    drbToAddList->list.size = drbToAddList->list.count * sizeof(DRB_ToAddMod_t *);
7743
7744    CU_ALLOC(drbToAddList->list.array, drbToAddList->list.size);
7745    if(!drbToAddList->list.array)
7746    {
7747       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for DRB to AddMod list array in fillDrbToAddModList");
7748       return RFAILED;
7749    }
7750
7751    drbIdx = 0;
7752    for(drbDbIdx=0; drbDbIdx < ueCb->numDrb; drbDbIdx++)
7753    {
7754       if(!updateAllRbCfg && ueCb->drbList[drbDbIdx].cfgSentToUe)
7755          continue;
7756
7757       CU_ALLOC(drbToAddList->list.array[drbIdx], sizeof(DRB_ToAddMod_t));
7758       if(!drbToAddList->list.array[drbIdx])
7759       {
7760          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for DRB to AddMod list elements in fillDrbToAddModList");
7761          return RFAILED;
7762       }
7763
7764       /* DRB Id */
7765       drbToAddList->list.array[drbIdx]->drb_Identity = ueCb->drbList[drbDbIdx].drbId;
7766
7767       /* PDCP Config */
7768       CU_ALLOC(drbToAddList->list.array[drbIdx]->pdcp_Config, sizeof(PDCP_Config_t));
7769       if(!drbToAddList->list.array[drbIdx]->pdcp_Config)
7770       {
7771          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for PDCP config IE in fillDrbToAddModList");
7772          return RFAILED;
7773       }
7774
7775       /* PDCP Config -> DRB */
7776       CU_ALLOC(drbToAddList->list.array[drbIdx]->pdcp_Config->drb, sizeof(struct PDCP_Config__drb));
7777       if(!drbToAddList->list.array[drbIdx]->pdcp_Config->drb)
7778       {
7779          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for PDCP config drb in fillDrbToAddModList");
7780          return RFAILED;
7781       }
7782
7783       /* DRB -> Discard Timer */
7784       CU_ALLOC(drbToAddList->list.array[drbIdx]->pdcp_Config->drb->discardTimer, sizeof(long));
7785       if(!drbToAddList->list.array[drbIdx]->pdcp_Config->drb->discardTimer)
7786       {
7787          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for DRB discard timer in fillDrbToAddModList");
7788          return RFAILED;
7789       }
7790       *(drbToAddList->list.array[drbIdx]->pdcp_Config->drb->discardTimer) = PDCP_Config__drb__discardTimer_infinity;
7791
7792       /* UL PDCP SN length */
7793       CU_ALLOC(drbToAddList->list.array[drbIdx]->pdcp_Config->drb->pdcp_SN_SizeUL, sizeof(long));
7794       if(!drbToAddList->list.array[drbIdx]->pdcp_Config->drb->pdcp_SN_SizeUL)
7795       {
7796          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for UL SN length in fillDrbToAddModList");
7797          return RFAILED;
7798       }
7799       *(drbToAddList->list.array[drbIdx]->pdcp_Config->drb->pdcp_SN_SizeUL) = PDCP_Config__drb__pdcp_SN_SizeUL_len12bits;
7800
7801       /* DL PDCP SN length */
7802       CU_ALLOC(drbToAddList->list.array[drbIdx]->pdcp_Config->drb->pdcp_SN_SizeDL, sizeof(long));
7803       if(!drbToAddList->list.array[drbIdx]->pdcp_Config->drb->pdcp_SN_SizeDL)
7804       {
7805          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for DL SN length in fillDrbToAddModList");
7806          return RFAILED;
7807       }
7808       *(drbToAddList->list.array[drbIdx]->pdcp_Config->drb->pdcp_SN_SizeDL) = PDCP_Config__drb__pdcp_SN_SizeDL_len12bits;
7809
7810       /* Header Compression */
7811       drbToAddList->list.array[drbIdx]->pdcp_Config->drb->headerCompression.present = PDCP_Config__drb__headerCompression_PR_notUsed;
7812        drbToAddList->list.array[drbIdx]->pdcp_Config->drb->headerCompression.choice.notUsed = NULLP;
7813
7814       /* Reordering timer */
7815       CU_ALLOC(drbToAddList->list.array[drbIdx]->pdcp_Config->t_Reordering, sizeof(long));
7816       if(!drbToAddList->list.array[drbIdx]->pdcp_Config->t_Reordering)
7817       {
7818          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for reordering timer in fillDrbToAddModList");
7819          return RFAILED;
7820       }
7821       *(drbToAddList->list.array[drbIdx]->pdcp_Config->t_Reordering) = PDCP_Config__t_Reordering_ms40;
7822
7823       drbIdx++;
7824    }
7825
7826    return ROK;
7827 }
7828
7829 /******************************************************************
7830  *
7831  * @brief Fill Radio bearer configuration
7832  *
7833  * @details
7834  *
7835  *    Function : fillRadioBearerConfig
7836  *
7837  *    Functionality: Fill Radio bearer configuration
7838  *
7839  * @params[in] UE control block
7840  *             Radio bearer config pointer
7841  * @return ROK     - success
7842  *         RFAILED - failure
7843  *
7844  * ****************************************************************/
7845 uint8_t fillRadioBearerConfig(CuUeCb *ueCb, RadioBearerConfig_t *radioBearerConfig, bool updateAllRbCfg)
7846 {
7847    /* SRB To Add/Mod List */
7848    if(fillSrbToAddModList(ueCb, radioBearerConfig->srb_ToAddModList, updateAllRbCfg) != ROK)
7849    {
7850       return RFAILED;
7851    }
7852
7853    if(fillDrbToAddModList(ueCb, radioBearerConfig->drb_ToAddModList, updateAllRbCfg) != ROK)
7854    {
7855       return RFAILED;
7856    }
7857
7858    return ROK;
7859 }
7860
7861 /*******************************************************************
7862  *
7863  * @brief Fill measurement object to add/mod list
7864  *
7865  * @details
7866  *
7867  *    Function : fillMeasObjToAddModList
7868  *
7869  *    Functionality: Fill measurement object to add/mod list
7870  *
7871  * @params[in] Measurement object to add/mod list
7872  * @return ROK     - success
7873  *         RFAILED - failure
7874  *
7875  * ****************************************************************/
7876 uint8_t fillMeasObjToAddModList(MeasObjectToAddModList_t *measObjList)
7877 {
7878    uint8_t elementCnt, objIdx;
7879    MeasObjectNR_t *measObject;
7880
7881    elementCnt = 1;
7882    measObjList->list.count = elementCnt;
7883    measObjList->list.size = measObjList->list.count * sizeof(MeasObjectToAddMod_t *);
7884
7885    CU_ALLOC(measObjList->list.array, measObjList->list.size);
7886    if(!measObjList->list.array)
7887    {
7888       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for measurement object list's array");
7889       return RFAILED;
7890    }
7891
7892    for(objIdx = 0; objIdx < measObjList->list.size; objIdx++)
7893    {
7894       CU_ALLOC(measObjList->list.array[objIdx], sizeof(MeasObjectToAddMod_t));
7895       if(!measObjList->list.array[objIdx])
7896       {
7897          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for measurement object list's array element");
7898          return RFAILED;
7899       }
7900    }
7901
7902    objIdx = 0;
7903    measObjList->list.array[objIdx]->measObjectId = 1;
7904    measObjList->list.array[objIdx]->measObject.present = MeasObjectToAddMod__measObject_PR_measObjectNR;
7905    CU_ALLOC(measObjList->list.array[objIdx]->measObject.choice.measObjectNR, sizeof(MeasObjectNR_t));
7906    if(!measObjList->list.array[objIdx]->measObject.choice.measObjectNR)
7907    {
7908       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for mesurement object NR");
7909       return RFAILED;
7910    }
7911
7912    measObject = measObjList->list.array[objIdx]->measObject.choice.measObjectNR;
7913
7914    /* SSB frequency */
7915    CU_ALLOC(measObject->ssbFrequency, sizeof(ARFCN_ValueNR_t));
7916    if(!measObject->ssbFrequency)
7917    {
7918       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for SSB frequency in fillMeasObjToAddModList");
7919       return RFAILED;
7920    }
7921    *(measObject->ssbFrequency) = 620736; /* Value picked from reference PCAP logs */
7922
7923    /* Subcarrier spacing */
7924    CU_ALLOC(measObject->ssbSubcarrierSpacing, sizeof(SubcarrierSpacing_t));
7925    if(!measObject->ssbSubcarrierSpacing)
7926    {
7927       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for SSB subcarrier spacing in fillMeasObjToAddModList");
7928       return RFAILED;
7929    }
7930    *(measObject->ssbSubcarrierSpacing) = SubcarrierSpacing_kHz15;
7931
7932    /* SMTC1 */
7933    CU_ALLOC(measObject->smtc1 , sizeof(SSB_MTC_t));
7934    if(!measObject->smtc1)
7935    {
7936       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for SMTC1 in fillMeasObjToAddModList");
7937       return RFAILED;
7938    }
7939    measObject->smtc1->duration = SSB_MTC__duration_sf1;
7940    measObject->smtc1->periodicityAndOffset.present = SSB_MTC__periodicityAndOffset_PR_sf20;
7941    measObject->smtc1->periodicityAndOffset.choice.sf20 = 0;
7942
7943    /* Absoulute threshold SSB consolidation */
7944    CU_ALLOC(measObject->absThreshSS_BlocksConsolidation, sizeof(ThresholdNR_t));
7945    if(!measObject->absThreshSS_BlocksConsolidation)
7946    {
7947       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for absolute threshold SSB consolidation in fillMeasObjToAddModList");
7948       return RFAILED;
7949    }
7950
7951    /* RSRP threshold */
7952    CU_ALLOC(measObject->absThreshSS_BlocksConsolidation->thresholdRSRP, sizeof(RSRP_Range_t));
7953    if(!measObject->absThreshSS_BlocksConsolidation->thresholdRSRP)
7954    {
7955       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for threshold RSRP in fillMeasObjToAddModList");
7956       return RFAILED;
7957    }
7958    *(measObject->absThreshSS_BlocksConsolidation->thresholdRSRP) = 1;
7959
7960    /* RSRQ threshold */
7961    CU_ALLOC(measObject->absThreshSS_BlocksConsolidation->thresholdRSRQ, sizeof(RSRQ_Range_t));
7962    if(!measObject->absThreshSS_BlocksConsolidation->thresholdRSRQ)
7963    {
7964       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for threshold RSRQ in fillMeasObjToAddModList");
7965       return RFAILED;
7966    }
7967    *(measObject->absThreshSS_BlocksConsolidation->thresholdRSRQ) = 1;
7968
7969    /* SINR threshold */
7970    CU_ALLOC(measObject->absThreshSS_BlocksConsolidation->thresholdSINR, sizeof(SINR_Range_t));
7971    if(!measObject->absThreshSS_BlocksConsolidation->thresholdSINR)
7972    {
7973       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for threshold SINR in fillMeasObjToAddModList");
7974       return RFAILED;
7975    }
7976    *(measObject->absThreshSS_BlocksConsolidation->thresholdSINR) = 1;
7977
7978    /* Number of SSBs to average */
7979    CU_ALLOC(measObject->nrofSS_BlocksToAverage, sizeof(long));
7980    if(!measObject->nrofSS_BlocksToAverage)
7981    {
7982       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for number of SSB to average in fillMeasObjToAddModList");
7983       return RFAILED;
7984    }
7985    *(measObject->nrofSS_BlocksToAverage) = 2;
7986
7987    /* Quantity Config index */
7988    measObject->quantityConfigIndex = 1;
7989
7990    /* Offset MO */
7991    /* RSRP offset for SSB */
7992    CU_ALLOC(measObject->offsetMO.rsrpOffsetSSB, sizeof(Q_OffsetRange_t));
7993    if(!measObject->offsetMO.rsrpOffsetSSB)
7994    {
7995       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for SSB RSRP offset in fillMeasObjToAddModList");
7996       return RFAILED;
7997    }
7998    *(measObject->offsetMO.rsrpOffsetSSB) = Q_OffsetRange_dB0;
7999
8000    /* RSRQ offset for SSB */
8001    CU_ALLOC(measObject->offsetMO.rsrqOffsetSSB, sizeof(Q_OffsetRange_t));
8002    if(!measObject->offsetMO.rsrpOffsetSSB)
8003    {
8004       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for SSB RSRQ offset in fillMeasObjToAddModList");
8005       return RFAILED;
8006    }
8007    *(measObject->offsetMO.rsrqOffsetSSB) = Q_OffsetRange_dB0;
8008
8009    /* SINR offset for SSB */
8010    CU_ALLOC(measObject->offsetMO.sinrOffsetSSB, sizeof(Q_OffsetRange_t));
8011    if(!measObject->offsetMO.sinrOffsetSSB)
8012    {
8013       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for SSB SINR offset in fillMeasObjToAddModList");
8014       return RFAILED;
8015    }
8016    *(measObject->offsetMO.sinrOffsetSSB) = Q_OffsetRange_dB0;
8017
8018    return ROK;
8019 }
8020
8021 /*******************************************************************
8022  *
8023  * @brief Fill Report configuration to Add/mod list
8024  *
8025  * @details
8026  *
8027  *    Function : fillReportCfgToAddModList
8028  *
8029  *    Functionality: Fill Report configuration to Add/mod list
8030  *
8031  * @params[in] Report Config To Add/Mod List
8032  * @return ROK     - success
8033  *         RFAILED - failure
8034  *
8035  * ****************************************************************/
8036 uint8_t fillReportCfgToAddModList(ReportConfigToAddModList_t *reportCfgList)
8037 {
8038    uint8_t elementCnt;
8039    uint8_t reportCfgIdx;
8040    ReportConfigToAddMod_t *reportCfg;
8041    ReportConfigNR_t *reportCfgNr;
8042    EventTriggerConfig_t *eventTriggCfg;
8043
8044    elementCnt = 1;
8045    reportCfgList->list.count = elementCnt;
8046    reportCfgList->list.size = reportCfgList->list.count * sizeof(ReportConfigToAddMod_t *);
8047
8048    CU_ALLOC(reportCfgList->list.array, reportCfgList->list.size);
8049    if(!reportCfgList->list.array)
8050    {
8051       DU_LOG("\nERROR  -->  F1AP: fillReportCfgToAddModList() :Memory allocation failed for report config list's array");
8052       return RFAILED;
8053    }
8054
8055    for(reportCfgIdx=0; reportCfgIdx < reportCfgList->list.count; reportCfgIdx++)
8056    {
8057       CU_ALLOC(reportCfgList->list.array[reportCfgIdx], sizeof(ReportConfigToAddMod_t));
8058       if(!reportCfgList->list.array[reportCfgIdx])
8059       {
8060          DU_LOG("\nERROR  -->  F1AP: fillReportCfgToAddModList(): Memory allocation failed for report config list's array element");
8061          return RFAILED;
8062       }
8063    }
8064
8065    reportCfgIdx = 0;
8066    reportCfg = reportCfgList->list.array[reportCfgIdx];
8067    reportCfg->reportConfigId = 1;
8068    reportCfg->reportConfig.present = ReportConfigToAddMod__reportConfig_PR_reportConfigNR;
8069
8070    /* Report Configuration for NR */
8071    CU_ALLOC(reportCfg->reportConfig.choice.reportConfigNR, sizeof(ReportConfigNR_t));
8072    if(!reportCfg->reportConfig.choice.reportConfigNR)
8073    {
8074       DU_LOG("\nERROR  -->  F1AP: fillReportCfgToAddModList(): Memory allocation failed for report config NR");
8075       return RFAILED;
8076    }
8077    reportCfgNr = reportCfg->reportConfig.choice.reportConfigNR;
8078
8079    /* Report Type */
8080    reportCfgNr->reportType.present = ReportConfigNR__reportType_PR_eventTriggered;
8081    CU_ALLOC(reportCfgNr->reportType.choice.eventTriggered, sizeof(EventTriggerConfig_t));
8082    if(!reportCfgNr->reportType.choice.eventTriggered)
8083    {
8084       DU_LOG("\nERROR  -->  F1AP: fillReportCfgToAddModList(): Memory allocation failed for event triggerred");
8085       return RFAILED;
8086    }
8087    eventTriggCfg = reportCfgNr->reportType.choice.eventTriggered;
8088
8089    /* Event 3 */
8090    eventTriggCfg->eventId.present = EventTriggerConfig__eventId_PR_eventA3;
8091    CU_ALLOC(eventTriggCfg->eventId.choice.eventA3, sizeof(struct EventTriggerConfig__eventId__eventA3));
8092    if(!eventTriggCfg->eventId.choice.eventA3)
8093    {
8094       DU_LOG("\nERROR  -->  F1AP: fillReportCfgToAddModList(): Memory allocation failed for event A3");
8095       return RFAILED;
8096    }
8097
8098    eventTriggCfg->eventId.choice.eventA3->a3_Offset.present = MeasTriggerQuantityOffset_PR_rsrp;
8099    eventTriggCfg->eventId.choice.eventA3->a3_Offset.choice.rsrp = 6; /* i.e. 3.0db . From Reference pcap log */
8100    eventTriggCfg->eventId.choice.eventA3->reportOnLeave = false;
8101    eventTriggCfg->eventId.choice.eventA3->hysteresis = 0;
8102    eventTriggCfg->eventId.choice.eventA3->timeToTrigger = TimeToTrigger_ms40;
8103    eventTriggCfg->eventId.choice.eventA3->useWhiteCellList = false;
8104
8105    /* Reference Signal Type */
8106    eventTriggCfg->rsType = NR_RS_Type_ssb;
8107
8108    /* Report Interval */
8109    eventTriggCfg->reportInterval = ReportInterval_ms1024;
8110
8111    /* Report Amount */
8112    eventTriggCfg->reportAmount = EventTriggerConfig__reportAmount_r8;
8113
8114    /* Report Quantity cell */
8115    eventTriggCfg->reportQuantityCell.rsrp = true;
8116    eventTriggCfg->reportQuantityCell.rsrq = false;
8117    eventTriggCfg->reportQuantityCell.sinr = false;
8118
8119    /* Maximum reported cells */
8120    eventTriggCfg->maxReportCells = 3;
8121
8122    /* Report qunatity RS Indexes */
8123    CU_ALLOC(eventTriggCfg->reportQuantityRS_Indexes, sizeof(MeasReportQuantity_t));
8124    if(!eventTriggCfg->reportQuantityRS_Indexes)
8125    {
8126       DU_LOG("\nERROR  -->  F1AP: fillReportCfgToAddModList(): Memory allocation failed for report qunatity RS indexes");
8127       return RFAILED;
8128    }
8129    eventTriggCfg->reportQuantityRS_Indexes->rsrp = true;
8130    eventTriggCfg->reportQuantityRS_Indexes->rsrq = false;
8131    eventTriggCfg->reportQuantityRS_Indexes->sinr = false;
8132
8133    /* Maximum number of RS indexes to report */
8134    CU_ALLOC(eventTriggCfg->maxNrofRS_IndexesToReport, sizeof(long));
8135    if(!eventTriggCfg->maxNrofRS_IndexesToReport)
8136    {
8137       DU_LOG("\nERROR  -->  F1AP: fillReportCfgToAddModList(): Memory allocation failed for max number of RS indexes to report");
8138       return RFAILED;
8139    }
8140    *(eventTriggCfg->maxNrofRS_IndexesToReport) = 1;
8141
8142    /* Include Beam measurement */
8143    eventTriggCfg->includeBeamMeasurements = false;
8144
8145    return ROK;
8146 }
8147
8148 /*******************************************************************
8149  *
8150  * @brief Fill measurement Id to add/mod list
8151
8152  * @details
8153  *
8154  *    Function : fillMeasIdToAddModList
8155  *
8156  *    Functionality: Fill measurement Id to add/mod list
8157  *
8158  * @params[in] Measurement Id to add/mod list
8159  * @return ROK     - success
8160  *         RFAILED - failure
8161  *
8162  * ****************************************************************/
8163 uint8_t fillMeasIdToAddModList(MeasIdToAddModList_t *measIdList)
8164 {
8165    uint8_t elementCnt;
8166    uint8_t measIdIdx;
8167
8168    elementCnt = 1;
8169    measIdList->list.count = elementCnt;
8170    measIdList->list.size = measIdList->list.count *sizeof(MeasIdToAddMod_t *);
8171
8172    CU_ALLOC(measIdList->list.array, measIdList->list.size);
8173    if(!measIdList->list.array)
8174    {
8175       return RFAILED;
8176    }
8177
8178    for(measIdIdx=0; measIdIdx < measIdList->list.count; measIdIdx++)
8179    {
8180       CU_ALLOC(measIdList->list.array[measIdIdx], sizeof(MeasIdToAddMod_t));
8181       if(!measIdList->list.array[measIdIdx])
8182       {
8183          return RFAILED;
8184       }
8185
8186       measIdIdx=0;
8187       measIdList->list.array[measIdIdx]->measId = 1;
8188       measIdList->list.array[measIdIdx]->measObjectId = 1;
8189       measIdList->list.array[measIdIdx]->reportConfigId = 1;
8190    }
8191    return ROK;
8192 }
8193
8194 /*******************************************************************
8195  *
8196  * @brief Fill s-measurement configuration
8197  *
8198  * @details
8199  *
8200  *    Function : fillSMeasConfig
8201  *
8202  *    Functionality: Fill s-measurement configuration
8203  *
8204  * @params[in] s-Measurement config
8205  * @return ROK     - success
8206  *         RFAILED - failure
8207  *
8208  * ****************************************************************/
8209 uint8_t fillSMeasConfig(struct MeasConfigRrc__s_MeasureConfig *sMeasCfg)
8210 {
8211    sMeasCfg->present = MeasConfigRrc__s_MeasureConfig_PR_ssb_RSRP;
8212    sMeasCfg->choice.ssb_RSRP = 100; /* Value taken from reference PCAP log */
8213
8214    return ROK;
8215 }
8216
8217 /*******************************************************************
8218  *
8219  * @brief Fill quantity config
8220  *
8221  * @details
8222  *
8223  *    Function : fillQunatityConfig
8224  *
8225  *    Functionality: Fill quantity config
8226  *
8227  * @params[in] Quantity Config
8228  * @return ROK     - success
8229  *         RFAILED - failure
8230  *
8231  * ****************************************************************/
8232 uint8_t fillQuantityConfig(QuantityConfig_t *quantityCfg)
8233 {
8234    uint8_t elementCnt = 0;
8235    uint8_t quanCfgIdx = 0;
8236    QuantityConfigNR_t *quantityCfgNr;
8237
8238    CU_ALLOC(quantityCfg->quantityConfigNR_List, sizeof(struct QuantityConfig__quantityConfigNR_List));
8239    if(!quantityCfg->quantityConfigNR_List)
8240    {
8241       return RFAILED;
8242    }
8243
8244    elementCnt = 1;
8245    quantityCfg->quantityConfigNR_List->list.count = elementCnt;
8246    quantityCfg->quantityConfigNR_List->list.size = elementCnt * sizeof(QuantityConfigNR_t *);
8247
8248    CU_ALLOC(quantityCfg->quantityConfigNR_List->list.array, quantityCfg->quantityConfigNR_List->list.size);
8249    if(!quantityCfg->quantityConfigNR_List->list.array)
8250    {
8251       return RFAILED;
8252    }
8253
8254    for(quanCfgIdx = 0; quanCfgIdx < quantityCfg->quantityConfigNR_List->list.count; quanCfgIdx++)
8255    {
8256       CU_ALLOC(quantityCfg->quantityConfigNR_List->list.array[quanCfgIdx], sizeof(QuantityConfigNR_t));
8257       if(!quantityCfg->quantityConfigNR_List->list.array[quanCfgIdx])
8258       {
8259          return RFAILED;
8260       }
8261    }
8262
8263    quanCfgIdx = 0;
8264    quantityCfgNr = quantityCfg->quantityConfigNR_List->list.array[quanCfgIdx];
8265
8266    /* Quantity Config of Reference signal */
8267    CU_ALLOC(quantityCfgNr->quantityConfigCell.ssb_FilterConfig.filterCoefficientRSRP, sizeof(FilterCoefficient_t));
8268    if(!quantityCfgNr->quantityConfigCell.ssb_FilterConfig.filterCoefficientRSRP)
8269    {
8270       return RFAILED;
8271    }
8272    *(quantityCfgNr->quantityConfigCell.ssb_FilterConfig.filterCoefficientRSRP) = FilterCoefficient_fc4;
8273
8274    CU_ALLOC(quantityCfgNr->quantityConfigCell.ssb_FilterConfig.filterCoefficientRSRQ, sizeof(FilterCoefficient_t));
8275    if(!quantityCfgNr->quantityConfigCell.ssb_FilterConfig.filterCoefficientRSRQ)
8276    {
8277       return RFAILED;
8278    }
8279    *(quantityCfgNr->quantityConfigCell.ssb_FilterConfig.filterCoefficientRSRQ) = FilterCoefficient_fc4;
8280
8281    CU_ALLOC(quantityCfgNr->quantityConfigCell.ssb_FilterConfig.filterCoefficientRS_SINR, sizeof(FilterCoefficient_t));
8282    if(!quantityCfgNr->quantityConfigCell.ssb_FilterConfig.filterCoefficientRS_SINR)
8283    {
8284       return RFAILED;
8285    }
8286    *(quantityCfgNr->quantityConfigCell.ssb_FilterConfig.filterCoefficientRS_SINR) = FilterCoefficient_fc4;
8287
8288    /* Quantity Config RS index */
8289    CU_ALLOC(quantityCfgNr->quantityConfigRS_Index, sizeof(QuantityConfigRS_t));
8290    if(!quantityCfgNr->quantityConfigRS_Index)
8291    {
8292       return RFAILED;
8293    }
8294
8295    CU_ALLOC(quantityCfgNr->quantityConfigRS_Index->ssb_FilterConfig.filterCoefficientRSRP, sizeof(FilterCoefficient_t));
8296    if(!quantityCfgNr->quantityConfigRS_Index->ssb_FilterConfig.filterCoefficientRSRP)
8297    {
8298       return RFAILED;
8299    }
8300    *(quantityCfgNr->quantityConfigRS_Index->ssb_FilterConfig.filterCoefficientRSRP) = FilterCoefficient_fc4;
8301
8302    CU_ALLOC(quantityCfgNr->quantityConfigRS_Index->ssb_FilterConfig.filterCoefficientRSRQ, sizeof(FilterCoefficient_t));
8303    if(!quantityCfgNr->quantityConfigRS_Index->ssb_FilterConfig.filterCoefficientRSRQ)
8304    {
8305       return RFAILED;
8306    }
8307    *(quantityCfgNr->quantityConfigRS_Index->ssb_FilterConfig.filterCoefficientRSRQ) = FilterCoefficient_fc4;
8308
8309    CU_ALLOC(quantityCfgNr->quantityConfigRS_Index->ssb_FilterConfig.filterCoefficientRS_SINR, sizeof(FilterCoefficient_t));
8310    if(!quantityCfgNr->quantityConfigRS_Index->ssb_FilterConfig.filterCoefficientRS_SINR)
8311    {
8312       return RFAILED;
8313    }
8314    *(quantityCfgNr->quantityConfigRS_Index->ssb_FilterConfig.filterCoefficientRS_SINR) = FilterCoefficient_fc4;
8315
8316    return ROK;
8317 }
8318
8319 /*******************************************************************
8320  *
8321  * @brief Fill measurement configuration
8322  *
8323  * @details
8324  *
8325  *    Function : fillMeasConfig
8326  *
8327  *    Functionality: Fill measurement configuration
8328  *
8329  * @params[in] Measurement config
8330  * @return ROK     - success
8331  *         RFAILED - failure
8332  *
8333  * ****************************************************************/
8334 uint8_t fillMeasConfig(MeasConfigRrc_t *measConfig)
8335 {
8336    /* Measurement object to add/mod list */
8337    CU_ALLOC(measConfig->measObjectToAddModList, sizeof(MeasObjectToAddModList_t));
8338    if(!measConfig->measObjectToAddModList)
8339    {
8340       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for measurement object list in fillMeasConfig");
8341       return RFAILED;
8342    }
8343    if(fillMeasObjToAddModList(measConfig->measObjectToAddModList) != ROK)
8344    {
8345       DU_LOG("\nERROR  -->  F1AP: Failure in fillMeasObjToAddModList");
8346       return RFAILED;
8347    }
8348
8349    /* Report Config To add/mod list */
8350    CU_ALLOC(measConfig->reportConfigToAddModList, sizeof(ReportConfigToAddModList_t));
8351    if(!measConfig->reportConfigToAddModList)
8352    {
8353       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for report config list in  fillMeasConfig");
8354       return RFAILED;
8355    }
8356    if(fillReportCfgToAddModList(measConfig->reportConfigToAddModList) != ROK)
8357    {
8358       DU_LOG("\nERROR  -->  F1AP: Failure in fillReportCfgToAddModList");
8359       return RFAILED;
8360    }
8361
8362    /* Measurement Id to add/mod list */
8363    CU_ALLOC(measConfig->measIdToAddModList, sizeof(MeasIdToAddModList_t));
8364    if(!measConfig->measIdToAddModList)
8365    {
8366       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for measuerment id list in  fillMeasConfig");
8367       return RFAILED;
8368    }
8369    if(fillMeasIdToAddModList(measConfig->measIdToAddModList) != ROK)
8370    {
8371       DU_LOG("\nERROR  -->  F1AP: Failure in fillMeasIdToAddModList");
8372       return RFAILED;
8373    }
8374
8375    /* S-Measurement config */
8376    CU_ALLOC(measConfig->s_MeasureConfig, sizeof(struct MeasConfigRrc__s_MeasureConfig));
8377    if(!measConfig->s_MeasureConfig)
8378    {
8379       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for s measuerment config in  fillMeasConfig");
8380       return RFAILED;
8381    }
8382    if(fillSMeasConfig(measConfig->s_MeasureConfig) != ROK)
8383    {
8384       DU_LOG("\nERROR  -->  F1AP: Failure in fillSMeasConfig");
8385       return RFAILED;
8386    }
8387
8388    /* Qunatity Config */
8389    CU_ALLOC(measConfig->quantityConfig, sizeof(QuantityConfig_t));
8390    if(!measConfig->quantityConfig)
8391    {
8392       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for quantity config in  fillMeasConfig");
8393       return RFAILED;
8394    }
8395    if(fillQuantityConfig(measConfig->quantityConfig) != ROK)
8396    {
8397       DU_LOG("\nERROR  -->  F1AP: Failure in fillQuantityConfig");
8398       return RFAILED;
8399    }
8400
8401 return ROK;
8402 }
8403
8404 /*******************************************************************
8405  *
8406  * @brief Fill RRC reconfiguration non-critical extension IE
8407  *
8408  * @details
8409  *
8410  *    Function : fillRrcReconfigNonCriticalExt
8411  *
8412  *    Functionality: Fill RRC reconfiguration non-critical extension
8413  *
8414  * @params[in] RRC Reconfig Non-critical extension
8415  * @return ROK     - success
8416  *         RFAILED - failure
8417  *
8418  * ****************************************************************/
8419 uint8_t fillRrcReconfigNonCriticalExt(CuUeCb *ueCb, RRCReconfiguration_v1530_IEs_t *rrcRecfg, bool updateAllRbCfg)
8420 {
8421    CU_ALLOC(rrcRecfg->masterCellGroup, sizeof(OCTET_STRING_t));
8422    if(!rrcRecfg->masterCellGroup)
8423    {
8424       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in fillRrcReconfigNonCriticalExt");
8425       return RFAILED;
8426    }
8427
8428    rrcRecfg->masterCellGroup->size = ueCb->f1apMsgDb.duToCuContainer.size;
8429    CU_ALLOC(rrcRecfg->masterCellGroup->buf, rrcRecfg->masterCellGroup->size);
8430    if(!rrcRecfg->masterCellGroup->buf)
8431    {
8432       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in fillRrcReconfigNonCriticalExt");
8433       return RFAILED;
8434    }
8435    memcpy(rrcRecfg->masterCellGroup->buf, ueCb->f1apMsgDb.duToCuContainer.buf, rrcRecfg->masterCellGroup->size);
8436
8437 #if 0
8438    /* Use below code if masterCEllGroup is to be filled explicitly at CU rather than copying from DUToCURRCContainer
8439     * received from DU */
8440    if(fillCellGrpCfg(ueCb, rrcRecfg->masterCellGroup, updateAllRbCfg) != ROK)
8441    {
8442       DU_LOG("\nERROR  -->  F1AP : Failed to fill CellGroupCfg in fillRrcReconfigNonCriticalExt");
8443       return RFAILED;
8444    }
8445 #endif
8446
8447    return ROK;
8448 }
8449
8450 /*******************************************************************
8451  *
8452  * @brief Fill RRC reconfiguration structure
8453  *
8454  * @details
8455  *
8456  *    Function : fillRrcReconfig
8457  *
8458  *    Functionality: Fill RRC reconfiguration
8459
8460  *
8461  * @params[in] UE Cb
8462  *             RRC reconfiguration structure
8463  * @return ROK     - success
8464  *         RFAILED - failure
8465  *
8466  * ****************************************************************/
8467 uint8_t fillRrcReconfig(CuUeCb *ueCb, RRCReconfiguration_t *rrcReconfig, bool updateAllRbCfg)
8468 {
8469    memset(rrcReconfig, 0, sizeof(RRCReconfiguration_t));
8470
8471    rrcReconfig->rrc_TransactionIdentifier = 1;
8472    rrcReconfig->criticalExtensions.present = RRCReconfiguration__criticalExtensions_PR_rrcReconfiguration;
8473
8474    CU_ALLOC(rrcReconfig->criticalExtensions.choice.rrcReconfiguration, sizeof(RRCReconfiguration_IEs_t));
8475    if(!rrcReconfig->criticalExtensions.choice.rrcReconfiguration)
8476    {
8477       DU_LOG("\nERROR  -->  F1AP : Memormy allocation failed for RRC reconfiguration IE in fillRrcReconfig");
8478       return RFAILED;
8479    }
8480
8481    /* Radio Bearer Configuration */
8482    CU_ALLOC(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->radioBearerConfig, sizeof(RadioBearerConfig_t));
8483    if(!rrcReconfig->criticalExtensions.choice.rrcReconfiguration->radioBearerConfig)
8484    {
8485       DU_LOG("\nERROR  -->  F1AP : Memormy allocation failed for radio bearer config in fillRrcReconfig");
8486       return RFAILED;
8487    }
8488    if(fillRadioBearerConfig(ueCb, rrcReconfig->criticalExtensions.choice.rrcReconfiguration->radioBearerConfig, updateAllRbCfg) != ROK)
8489    {
8490       DU_LOG("\nERROR  -->  F1AP : Failed to fill radio bearer config in fillRrcReconfig");
8491       return RFAILED;
8492    }
8493
8494    /* Measurement Configuration */
8495    CU_ALLOC(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->measConfig, sizeof(MeasConfigRrc_t));
8496    if(!rrcReconfig->criticalExtensions.choice.rrcReconfiguration->measConfig)
8497    {
8498       DU_LOG("\nERROR  -->  F1AP : Memormy allocation failed for Measurement config IE in fillRrcReconfig");
8499       return RFAILED;
8500    }
8501    if(fillMeasConfig(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->measConfig) != ROK)
8502    {
8503       DU_LOG("\nERROR  -->  F1AP : Failed to fill measurement config in fillRrcReconfig");
8504       return RFAILED;
8505    }
8506
8507    /* Non Critical extension */
8508    CU_ALLOC(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->nonCriticalExtension, sizeof(struct RRCReconfiguration_v1530_IEs));
8509    if(!rrcReconfig->criticalExtensions.choice.rrcReconfiguration->nonCriticalExtension)
8510    {
8511       DU_LOG("\nERROR  -->  F1AP : Memormy allocation failed for non critical extension IE in fillRrcReconfig");
8512       return RFAILED;
8513    }
8514    if(fillRrcReconfigNonCriticalExt(ueCb, rrcReconfig->criticalExtensions.choice.rrcReconfiguration->nonCriticalExtension, updateAllRbCfg) != ROK)
8515    {
8516       DU_LOG("\nERROR  -->  F1AP : Failed to fill non critical extension in fillRrcReconfig");
8517       return RFAILED;
8518    }
8519    return ROK;
8520 }
8521
8522 /*******************************************************************
8523  *
8524  * @brief Fill RRC reconfiguration Octet string
8525  *
8526  * @details
8527  *
8528  *    Function : fillRrcReconfigBuf
8529  *
8530  *    Functionality: Fill RRC reconfiguration octet string
8531
8532  *
8533  * @params[in] OCTET_STRING_t buffer
8534  * @return ROK     - success
8535  *         RFAILED - failure
8536  *
8537  * ****************************************************************/
8538 uint8_t fillRrcReconfigBuf(CuUeCb *ueCb, OCTET_STRING_t  *rrcReconfigBuf, bool updateAllRbCfg)
8539 {
8540    uint8_t          ret = RFAILED;
8541    asn_enc_rval_t   encRetVal;
8542    RRCReconfiguration_t rrcRecfg, *rrcReconfig = NULLP;
8543    rrcReconfig = &rrcRecfg;
8544
8545    while(true)
8546    {
8547       if(fillRrcReconfig(ueCb, rrcReconfig, updateAllRbCfg) != ROK)
8548       {
8549          DU_LOG( "\nERROR  -->  F1AP : Failed to fill RRC Reconfiguration in fillRrcReconfigBuf");
8550          break;
8551       }
8552
8553       /* Encode RRC Reconfiguration */
8554       xer_fprint(stdout, &asn_DEF_RRCReconfiguration, rrcReconfig);
8555       cmMemset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
8556       encBufSize = 0;
8557       encRetVal = aper_encode(&asn_DEF_RRCReconfiguration, 0, rrcReconfig, PrepFinalEncBuf, encBuf);
8558
8559       /* Encode results */
8560       if(encRetVal.encoded == ENCODE_FAIL)
8561       {
8562          DU_LOG( "\nERROR  -->  F1AP : Could not encode RRC Reconfiguration (at %s)\n",\
8563                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
8564          break;
8565       }
8566       else
8567       {
8568          DU_LOG("\nDEBUG  -->  F1AP : Created APER encoded buffer for RRC Reconfiguration\n");
8569          for(int i=0; i< encBufSize; i++)
8570          {
8571             DU_LOG("%x",encBuf[i]);
8572          }
8573       }
8574
8575       rrcReconfigBuf->size = encBufSize;
8576       CU_ALLOC(rrcReconfigBuf->buf, rrcReconfigBuf->size);
8577       if(!rrcReconfigBuf->buf)
8578       {
8579          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in fillRrcReconfigBuf");
8580          break;
8581       }
8582       memcpy(rrcReconfigBuf->buf, encBuf, rrcReconfigBuf->size);
8583       ret = ROK;
8584       break;
8585    }
8586
8587    freeRrcReconfig(rrcReconfig);
8588    return ret;
8589 }
8590
8591 /*******************************************************************
8592  *
8593  * @brief Fill HO preparation information Octet string
8594  *
8595  * @details
8596  *
8597  *    Function : fillHOPreparationInfoBuf
8598  *
8599  *    Functionality: Fill HO preparation information Octet string
8600
8601  *
8602  * @params[in] HandoverPreparationInformation_t buffer
8603  * @return ROK     - success
8604  *         RFAILED - failure
8605  *
8606  * ****************************************************************/
8607 uint8_t fillHOPreparationInfoBuf(CuUeCb *ueCb, HandoverPreparationInformation_t *hoPrepInfoBuf)
8608 {
8609    uint8_t          ret = RFAILED;
8610    asn_enc_rval_t   encRetVal;
8611    HandoverPreparationInformationRrc_t hoPrepInfo;
8612    HandoverPreparationInformationRrc_IEs_t *hoPrepInfoIe;
8613
8614    while(true)
8615    {
8616
8617       hoPrepInfo.criticalExtensions.present = HandoverPreparationInformationRrc__criticalExtensions_PR_c1;
8618       CU_ALLOC(hoPrepInfo.criticalExtensions.choice.c1, sizeof(struct HandoverPreparationInformationRrc__criticalExtensions__c1));
8619       if(!hoPrepInfo.criticalExtensions.choice.c1)
8620       {
8621          DU_LOG( "\nERROR  -->  F1AP : Failed to allocate memory for c1 in fillHOPreparationInfo");
8622          break;
8623       }
8624       hoPrepInfo.criticalExtensions.choice.c1->present = \
8625          HandoverPreparationInformationRrc__criticalExtensions__c1_PR_handoverPreparationInformation;
8626
8627       CU_ALLOC(hoPrepInfo.criticalExtensions.choice.c1->choice.handoverPreparationInformation , \
8628          sizeof(HandoverPreparationInformationRrc_IEs_t));
8629       if(!hoPrepInfo.criticalExtensions.choice.c1->choice.handoverPreparationInformation)
8630       {
8631          DU_LOG( "\nERROR  -->  F1AP : Failed to allocate memory for handover preparation information IE in fillHOPreparationInfo");
8632          break;
8633       }
8634       hoPrepInfoIe = hoPrepInfo.criticalExtensions.choice.c1->choice.handoverPreparationInformation;
8635
8636       /* Fill UE Capability RAT container list */
8637       ret = fillUeCapRatContList(&hoPrepInfoIe->ue_CapabilityRAT_List);
8638       if(ret != ROK)
8639       {
8640          DU_LOG( "\nERROR  -->  F1AP : Failed to fill UE Capability RAT container list");
8641          break;
8642       }
8643
8644       /* Fill Source config */
8645       hoPrepInfoIe->sourceConfig = NULLP;
8646       CU_ALLOC(hoPrepInfoIe->sourceConfig, sizeof(AS_Config_t));
8647       if(!hoPrepInfoIe->sourceConfig)
8648       {
8649          DU_LOG( "\nERROR  -->  F1AP : Failed to allocate memory for source config in fillHOPreparationInfo");
8650          return RFAILED;
8651       }
8652       ret = fillRrcReconfigBuf(ueCb, &hoPrepInfoIe->sourceConfig->rrcReconfiguration, true);
8653
8654       if(ret != ROK)
8655       {
8656          DU_LOG( "\nERROR  -->  F1AP : Failed to fill Rrc reconfiguration buffer");
8657          return RFAILED;
8658       }
8659
8660       hoPrepInfoIe->rrm_Config = NULLP;
8661       hoPrepInfoIe->as_Context = NULLP;
8662       hoPrepInfoIe->nonCriticalExtension = NULLP;
8663
8664       /* encode UE Capability RAT Container List into duToCuRrcContainer */
8665       xer_fprint(stdout, &asn_DEF_HandoverPreparationInformationRrc, &hoPrepInfo);
8666       cmMemset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
8667       encBufSize = 0;
8668       encRetVal = aper_encode(&asn_DEF_HandoverPreparationInformationRrc, 0, \
8669             &hoPrepInfo, PrepFinalEncBuf, encBuf);
8670
8671       /* Encode results */
8672       if(encRetVal.encoded == ENCODE_FAIL)
8673       {
8674          DU_LOG( "\nERROR  -->  F1AP : Could not encode UE Capability RAT Container (at %s)\n",\
8675                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
8676          break;
8677       }
8678       else
8679       {
8680          DU_LOG("\nDEBUG  -->  F1AP : Created APER encodedbuffer for UE Capability RAT Container\n");
8681          for(int i=0; i< encBufSize; i++)
8682          {
8683             DU_LOG("%x",encBuf[i]);
8684          }
8685       }
8686
8687       hoPrepInfoBuf->size = encBufSize;
8688       CU_ALLOC(hoPrepInfoBuf->buf, hoPrepInfoBuf->size);
8689       if(!hoPrepInfoBuf->buf)
8690       {
8691          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in fillUeCapabilityContainer");
8692          break;
8693       }
8694       memcpy(hoPrepInfoBuf->buf, encBuf, hoPrepInfoBuf->size);
8695       ret = ROK;
8696       break;
8697    }
8698    freeHOPreparationInfo(&hoPrepInfo);
8699    return ret;
8700 }
8701
8702 /*******************************************************************
8703  *
8704  * @brief Fills CuToDuContainer
8705  *
8706  * @details
8707  *
8708  *    Function : fillCuToDuContainer
8709  *
8710  *    Functionality: Fills CuToDuContainer
8711  *
8712  * @params[in] pointer to CUtoDURRCInformation_t
8713  *
8714  * @return ROK     - success
8715  *         RFAILED - failure
8716  *
8717  ******************************************************************/
8718
8719 uint8_t fillCuToDuContainer(CuUeCb *ueCb, CUtoDURRCInformation_t *rrcMsg)
8720 {
8721    uint8_t elementCnt = 0;
8722    uint8_t ret = ROK;
8723    uint8_t idx, idx2, rrcBufLen;
8724
8725    /* UE Capabulity RAT Container List */
8726    CU_ALLOC(rrcMsg->uE_CapabilityRAT_ContainerList, sizeof(UE_CapabilityRAT_ContainerList_t));
8727    if(!rrcMsg->uE_CapabilityRAT_ContainerList)
8728    {
8729       DU_LOG("\nERROR  -->  F1AP : Memory allocation for UE capability RAT container list failed");
8730       return RFAILED;
8731    }
8732    ret = fillUeCapRatContListBuf(rrcMsg->uE_CapabilityRAT_ContainerList);
8733
8734    CU_ALLOC(rrcMsg->measConfig, sizeof(MeasConfig_t));
8735    if(!rrcMsg->measConfig)
8736    {
8737       DU_LOG("\nERROR  -->  F1AP : Memory allocation for measurement configuration failed");
8738       return RFAILED;
8739    }
8740    ret = fillMeasTimingConfigBuf(rrcMsg->measConfig);
8741
8742    if(ueCb->state == UE_HANDOVER_IN_PROGRESS)
8743    {
8744       /* IE extensions */
8745       CU_ALLOC(rrcMsg->iE_Extensions, sizeof(ProtocolExtensionContainer_4624P16_t));
8746       if(rrcMsg->iE_Extensions)
8747       {
8748          elementCnt = 1;
8749          rrcMsg->iE_Extensions->list.count = elementCnt;
8750          rrcMsg->iE_Extensions->list.size = elementCnt * sizeof(CUtoDURRCInformation_ExtIEs_t *);
8751
8752          /* Initialize the CUtoDURRCInformation_ExtIEs */
8753          CU_ALLOC(rrcMsg->iE_Extensions->list.array, rrcMsg->iE_Extensions->list.size);
8754
8755          if(rrcMsg->iE_Extensions->list.array == NULLP)
8756          {
8757             DU_LOG("\nERROR  -->  F1AP : Memory allocation for CUtoDURRCInformation_ExtIEs failed");
8758             ret = RFAILED;
8759          }
8760
8761          for(idx=0; idx<elementCnt; idx++)
8762          {
8763             CU_ALLOC(rrcMsg->iE_Extensions->list.array[idx], sizeof(CUtoDURRCInformation_ExtIEs_t));
8764             if(rrcMsg->iE_Extensions->list.array[idx] == NULLP)
8765             {
8766                DU_LOG("\nERROR  -->  F1AP : Memory allocation for array elements failed");
8767                ret = RFAILED;
8768             }
8769          }
8770
8771          idx = 0;
8772 #if 0
8773          /* Cell Group Configuration */
8774          rrcMsg->iE_Extensions->list.array[idx]->id = ProtocolIE_ID_id_CellGroupConfig;
8775          rrcMsg->iE_Extensions->list.array[idx]->criticality = Criticality_ignore;
8776          rrcMsg->iE_Extensions->list.array[idx]->extensionValue.present  =\
8777                                                                           CUtoDURRCInformation_ExtIEs__extensionValue_PR_CellGroupConfig;
8778          ret = fillCellGrpCfg(ueCb, &rrcMsg->iE_Extensions->list.array[idx]->extensionValue.choice.CellGroupConfig, true);
8779          idx++;
8780 #endif
8781          /* Handover Preparation Information */
8782          rrcMsg->iE_Extensions->list.array[idx]->id = ProtocolIE_ID_id_HandoverPreparationInformation;
8783          rrcMsg->iE_Extensions->list.array[idx]->criticality = Criticality_ignore;
8784          rrcMsg->iE_Extensions->list.array[idx]->extensionValue.present  = \
8785                                                                            CUtoDURRCInformation_ExtIEs__extensionValue_PR_HandoverPreparationInformation;
8786          ret = fillHOPreparationInfoBuf(ueCb, &rrcMsg->iE_Extensions->list.array[idx]->extensionValue.choice.HandoverPreparationInformation);
8787       }
8788    }
8789    return ret;
8790 }
8791
8792 /*******************************************************************
8793  *
8794  * @brief Free CuToDuContainer
8795  *
8796  * @details
8797  *
8798  *    Function : FreeCuToDuInfo
8799  *
8800  *    Functionality: Free CuToDuContainer
8801  *
8802  * @params[in] pointer to CUtoDURRCInformation_t
8803  *
8804  * @return ROK     - success
8805  *         RFAILED - failure
8806  *
8807  ******************************************************************/
8808
8809 void FreeCuToDuInfo(CUtoDURRCInformation_t *rrcMsg)
8810 {
8811    uint8_t idx, idx2;
8812
8813    if(rrcMsg->uE_CapabilityRAT_ContainerList)
8814    {
8815       if(rrcMsg->uE_CapabilityRAT_ContainerList->buf)
8816          CU_FREE(rrcMsg->uE_CapabilityRAT_ContainerList->buf, rrcMsg->uE_CapabilityRAT_ContainerList->size);
8817       CU_FREE(rrcMsg->uE_CapabilityRAT_ContainerList, sizeof(UE_CapabilityRAT_ContainerList_t));
8818    }
8819    if(rrcMsg->iE_Extensions)
8820    {
8821       if(rrcMsg->iE_Extensions->list.array)
8822       {
8823          for(idx= 0; idx < rrcMsg->iE_Extensions->list.count; idx++)
8824          {
8825             if(rrcMsg->iE_Extensions->list.array[idx])
8826             {
8827                switch(rrcMsg->iE_Extensions->list.array[idx]->id)
8828                {
8829                   case ProtocolIE_ID_id_CellGroupConfig:
8830                      if(rrcMsg->iE_Extensions->list.array[idx]->extensionValue.choice.CellGroupConfig.buf != NULLP)
8831                      {
8832                         CU_FREE(rrcMsg->iE_Extensions->list.array[idx]->extensionValue.choice.CellGroupConfig.buf,\
8833                               rrcMsg->iE_Extensions->list.array[idx]->extensionValue.choice.CellGroupConfig.size);
8834
8835                      }
8836                      break;
8837                   default:
8838                      DU_LOG("\nERROR  -->  F1AP : Invalid Event type %ld at FreeCuToDuInfo()", \
8839                            rrcMsg->iE_Extensions->list.array[idx]->id);
8840                      break;
8841                }
8842             }
8843             break;
8844          }
8845          for(idx2 = 0; idx2 < idx; idx2++)
8846          {
8847             CU_FREE(rrcMsg->iE_Extensions->list.array[idx2], sizeof(CUtoDURRCInformation_ExtIEs_t));
8848          }
8849          CU_FREE(rrcMsg->iE_Extensions->list.array, rrcMsg->iE_Extensions->list.size);
8850
8851       }
8852
8853       CU_FREE(rrcMsg->iE_Extensions, sizeof(ProtocolExtensionContainer_4624P16_t));
8854    }
8855 }
8856 /*******************************************************************
8857  *
8858  * @brief Builds and sends the UE Setup Request
8859  *
8860  * @details
8861  *
8862  *    Function : BuildAndSendUeContextSetupReq
8863  *
8864  *    Functionality: Constructs the UE Setup Request and sends
8865  *                   it to the CU through SCTP.
8866  *
8867  * @params[in]
8868  *
8869  * @return ROK     - success
8870  *         RFAILED - failure
8871  *
8872  * ****************************************************************/
8873 uint8_t BuildAndSendUeContextSetupReq(uint32_t duId, CuUeCb *ueCb, uint16_t rrcContLen, uint8_t *rrcContainer)
8874 {
8875    uint8_t   Nrcgiret, SplCellListret, SrbSetupret;
8876    uint8_t   ret= RFAILED, ret1;
8877    uint8_t   elementCnt;
8878    uint8_t   idx, idx1, bufLen, duIdx;
8879    uint32_t  spCellId;
8880    DuDb      *targetDuDb = NULLP;
8881    F1AP_PDU_t           *f1apMsg = NULLP;
8882    UEContextSetupRequest_t *ueSetReq = NULLP;
8883    asn_enc_rval_t encRetVal;        /* Encoder return value */
8884    memset(&encRetVal, 0, sizeof(asn_enc_rval_t));
8885
8886    while(true)
8887    {
8888       DU_LOG("\nINFO  -->  F1AP : Building UE Context Setup Request\n");
8889
8890       CU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
8891       if(f1apMsg == NULLP)
8892       {
8893          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
8894          break;
8895       }
8896
8897       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
8898       CU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
8899       if(f1apMsg->choice.initiatingMessage == NULLP)
8900       {
8901          DU_LOG("\nERROR  -->  F1AP : Memory allocation for     F1AP-PDU failed");
8902          break;
8903       }
8904
8905       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_UEContextSetup;
8906       f1apMsg->choice.initiatingMessage->criticality = Criticality_reject;
8907       f1apMsg->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_UEContextSetupRequest;
8908
8909       ueSetReq = &f1apMsg->choice.initiatingMessage->value.choice.UEContextSetupRequest;
8910
8911       if(ueCb->state == UE_HANDOVER_IN_PROGRESS)
8912          elementCnt = 7;
8913       else
8914          elementCnt = 12;
8915       ueSetReq->protocolIEs.list.count = elementCnt;
8916       ueSetReq->protocolIEs.list.size = elementCnt * sizeof(UEContextSetupRequestIEs_t *);
8917
8918       /* Initialize the UESetup members */
8919       CU_ALLOC(ueSetReq->protocolIEs.list.array,ueSetReq->protocolIEs.list.size);
8920
8921       if(ueSetReq->protocolIEs.list.array == NULLP)
8922       {
8923          DU_LOG("\nERROR  -->  F1AP : Memory allocation for UE Context SetupRequest failed");
8924          break;
8925       }
8926
8927       for(idx1=0; idx1<elementCnt; idx1++)
8928       {
8929          CU_ALLOC(ueSetReq->protocolIEs.list.array[idx1],sizeof(UEContextSetupRequestIEs_t));
8930          if(ueSetReq->protocolIEs.list.array[idx1] == NULLP)
8931          {
8932             break;
8933          }
8934       }
8935
8936       idx = 0;
8937
8938       /*GNB CU UE F1AP ID*/
8939       ueSetReq->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
8940       ueSetReq->protocolIEs.list.array[idx]->criticality        =       Criticality_reject;
8941       ueSetReq->protocolIEs.list.array[idx]->value.present = UEContextSetupRequestIEs__value_PR_GNB_CU_UE_F1AP_ID;
8942       ueSetReq->protocolIEs.list.array[idx]->value.choice.GNB_CU_UE_F1AP_ID = ueCb->gnbCuUeF1apId;
8943
8944       if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
8945       {
8946          /*GNB DU UE F1AP ID*/
8947          idx++;
8948          ueSetReq->protocolIEs.list.array[idx]->id      = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
8949          ueSetReq->protocolIEs.list.array[idx]->criticality     =       Criticality_ignore;
8950          ueSetReq->protocolIEs.list.array[idx]->value.present = UEContextSetupRequestIEs__value_PR_GNB_DU_UE_F1AP_ID;
8951          ueSetReq->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID = ueCb->gnbDuUeF1apId;
8952       }
8953
8954       /*Special Cell ID*/
8955       idx++;
8956       ueSetReq->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_SpCell_ID;
8957       ueSetReq->protocolIEs.list.array[idx]->criticality        =       Criticality_reject;
8958       ueSetReq->protocolIEs.list.array[idx]->value.present = UEContextSetupRequestIEs__value_PR_NRCGI;
8959       if(ueCb->state == UE_HANDOVER_IN_PROGRESS)
8960       {
8961          /* Spec 38.473 Sec 9.2.2.1 : For handover case, this IE shall be considered as target cell. */
8962          SEARCH_DU_DB(duIdx, ueCb->hoInfo.targetDuId, targetDuDb);
8963          /* Since we are supporting only one cell per DU, accessing 0th index to
8964           * get target cell info */
8965          spCellId = targetDuDb->cellCb[0].nrCellId;
8966       }
8967       else
8968          spCellId = ueCb->cellCb->nrCellId;
8969       Nrcgiret = BuildNrcgi(&ueSetReq->protocolIEs.list.array[idx]->value.choice.NRCGI, spCellId);
8970       if(Nrcgiret != ROK)
8971       {
8972          break;
8973       }
8974
8975       /*Served Cell Index*/
8976       idx++;
8977       ueSetReq->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_ServCellIndex;
8978       ueSetReq->protocolIEs.list.array[idx]->criticality        =       Criticality_reject;
8979       ueSetReq->protocolIEs.list.array[idx]->value.present = UEContextSetupRequestIEs__value_PR_ServCellIndex;
8980       ueSetReq->protocolIEs.list.array[idx]->value.choice.ServCellIndex = CELL_INDEX;
8981
8982       if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
8983       {
8984          /*CellULConfigured*/
8985          idx++;
8986          ueSetReq->protocolIEs.list.array[idx]->id      = ProtocolIE_ID_id_SpCellULConfigured;
8987          ueSetReq->protocolIEs.list.array[idx]->criticality     =       Criticality_ignore;
8988          ueSetReq->protocolIEs.list.array[idx]->value.present = UEContextSetupRequestIEs__value_PR_CellULConfigured;
8989          ueSetReq->protocolIEs.list.array[idx]->value.choice.CellULConfigured = CellULConfigured_none;
8990       }
8991
8992       /*CUtoDURRCContainer*/
8993       idx++;
8994       ueSetReq->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_CUtoDURRCInformation;
8995       ueSetReq->protocolIEs.list.array[idx]->criticality        =       Criticality_reject;
8996       ueSetReq->protocolIEs.list.array[idx]->value.present = UEContextSetupRequestIEs__value_PR_CUtoDURRCInformation;
8997       if(fillCuToDuContainer(ueCb, &ueSetReq->protocolIEs.list.array[idx]->value.choice.CUtoDURRCInformation))
8998       {
8999          break;
9000       }
9001
9002       if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
9003       {
9004          /*Special Cells to be SetupList*/
9005          idx++;
9006          ueSetReq->protocolIEs.list.array[idx]->id      = ProtocolIE_ID_id_SCell_ToBeSetup_List;
9007          ueSetReq->protocolIEs.list.array[idx]->criticality     =       Criticality_ignore;
9008          ueSetReq->protocolIEs.list.array[idx]->value.present = UEContextSetupRequestIEs__value_PR_SCell_ToBeSetup_List;
9009          SplCellListret = BuildSplCellList(ueCb, &ueSetReq->protocolIEs.list.array[idx]->value.choice.SCell_ToBeSetup_List);
9010          if(SplCellListret != ROK)
9011          {
9012             break;
9013          }
9014       }
9015
9016       /*SRBs To Be Setup List*/
9017       idx++;
9018       ueSetReq->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_SRBs_ToBeSetup_List;
9019       ueSetReq->protocolIEs.list.array[idx]->criticality        =       Criticality_reject;
9020       ueSetReq->protocolIEs.list.array[idx]->value.present = UEContextSetupRequestIEs__value_PR_SRBs_ToBeSetup_List;
9021       SrbSetupret = BuildSRBSetup(ueCb, &ueSetReq->protocolIEs.list.array[idx]->value.choice.SRBs_ToBeSetup_List);
9022       if(SrbSetupret != ROK)
9023       {
9024          break;
9025       }
9026
9027       /*DRBs to Be Setup List*/
9028       idx++;
9029       ueSetReq->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_DRBs_ToBeSetup_List;
9030       ueSetReq->protocolIEs.list.array[idx]->criticality        =       Criticality_reject;
9031       ueSetReq->protocolIEs.list.array[idx]->value.present = UEContextSetupRequestIEs__value_PR_DRBs_ToBeSetup_List;
9032       ret1 = BuildDRBSetup(duId, ueCb, &ueSetReq->protocolIEs.list.array[idx]->value.choice.DRBs_ToBeSetup_List);
9033       if(ret1 != ROK)
9034       {
9035          break;
9036       }
9037
9038       if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
9039       {
9040          /* RRC Container for security mode */
9041          idx++;
9042          ueSetReq->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_RRCContainer;
9043          ueSetReq->protocolIEs.list.array[idx]->criticality = Criticality_reject;
9044          ueSetReq->protocolIEs.list.array[idx]->value.present = UEContextSetupRequestIEs__value_PR_RRCContainer;
9045
9046          char secModeBuf[9]={0x00, 0x02, 0x22, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00};
9047          bufLen =9;
9048          ueSetReq->protocolIEs.list.array[idx]->value.choice.RRCContainer.size = bufLen;
9049          CU_ALLOC(ueSetReq->protocolIEs.list.array[idx]->value.choice.RRCContainer.buf,
9050                ueSetReq->protocolIEs.list.array[idx]->value.choice.RRCContainer.size);
9051          if(!ueSetReq->protocolIEs.list.array[idx]->value.choice.RRCContainer.buf)
9052          {
9053             DU_LOG("\nERROR  -->  F1AP : Memory allocation for BuildAndSendUeContextSetupReq failed");
9054             break;
9055          }
9056          memset(ueSetReq->protocolIEs.list.array[idx]->value.choice.RRCContainer.buf, 0, bufLen);
9057          memcpy(ueSetReq->protocolIEs.list.array[idx]->value.choice.RRCContainer.buf, secModeBuf, bufLen);
9058
9059          /* RRC delivery status request */
9060          idx++;
9061          ueSetReq->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_RRCDeliveryStatusRequest;
9062          ueSetReq->protocolIEs.list.array[idx]->criticality = Criticality_ignore;
9063          ueSetReq->protocolIEs.list.array[idx]->value.present = UEContextSetupRequestIEs__value_PR_RRCDeliveryStatusRequest;
9064          ueSetReq->protocolIEs.list.array[idx]->value.choice.RRCDeliveryStatusRequest = RRCDeliveryStatusRequest_true;
9065       }
9066
9067       /* GNB-DU UE Aggregate Maximum Bit Rate hardcoded as in reference logs */
9068       idx++;
9069       ueSetReq->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_GNB_DU_UE_AMBR_UL;
9070       ueSetReq->protocolIEs.list.array[idx]->criticality = Criticality_ignore;
9071       ueSetReq->protocolIEs.list.array[idx]->value.present = UEContextSetupRequestIEs__value_PR_BitRate;
9072
9073       char bitRateBuf[4]= {0x3B, 0x37, 0xF4, 0xCD};
9074       bufLen = 4;
9075       ueSetReq->protocolIEs.list.array[idx]->value.choice.BitRate.size = bufLen;
9076       CU_ALLOC(ueSetReq->protocolIEs.list.array[idx]->value.choice.BitRate.buf,\
9077             ueSetReq->protocolIEs.list.array[idx]->value.choice.BitRate.size);
9078       if(!ueSetReq->protocolIEs.list.array[idx]->value.choice.BitRate.buf)
9079       {
9080          DU_LOG("\nERROR  -->  F1AP : Failed to allocate memory for Bit Rate in BuildAndSendUeContextSetupReq()");
9081          break;
9082       }
9083       memset(ueSetReq->protocolIEs.list.array[idx]->value.choice.BitRate.buf, 0, bufLen);
9084       memcpy(ueSetReq->protocolIEs.list.array[idx]->value.choice.BitRate.buf, bitRateBuf, bufLen);
9085
9086       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
9087
9088       /* Encode the F1SetupRequest type as APER */
9089       memset(encBuf, 0, ENC_BUF_MAX_LEN);
9090       encBufSize = 0;
9091       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
9092
9093       /* Encode results */
9094       if(encRetVal.encoded == ENCODE_FAIL)
9095       {
9096          DU_LOG( "\nERROR  -->  F1AP : Could not encode UE Context Setup Request structure (at %s)\n",\
9097                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
9098          break;
9099       }
9100       else
9101       {
9102          DU_LOG("\nDEBUG  -->  F1AP : Created APER encodedbuffer for UE Context Setup Request\n");
9103          for(int i=0; i< encBufSize; i++)
9104          {
9105             DU_LOG("%x",encBuf[i]);
9106          }
9107       }
9108
9109       /* Sending  msg  */
9110       if(SendF1APMsg(CU_APP_MEM_REG, CU_POOL, duId)     !=      ROK)
9111       {
9112          DU_LOG("\nERROR  -->  F1AP : Sending UE Context Setup Request Failed");
9113          break;
9114       }
9115       ret = ROK;
9116       break;
9117    }
9118    FreeUeContextSetupReq(f1apMsg);
9119
9120    return ret;
9121 }/* End of BuildAndSendUeContextSetupReq*/
9122
9123 /**********************************************************************
9124  * @brief Function to extractTeId received in UE context setup Response
9125  *
9126  * @details
9127  *
9128  *    Function : extractTeId
9129  *
9130  *    Functionality:
9131  *         - Function to extract TeId
9132  *
9133  * @params[in]
9134  * @return ROK     - success
9135  *         RFAILED - failure
9136  *
9137  **********************************************************************/
9138 uint8_t extractTeId(DLUPTNLInformation_ToBeSetup_List_t *dlTnlInfo)
9139 {
9140    uint8_t arrIdx = 0;
9141    uint32_t teId = 0;
9142    GTPTunnel_t *gtpDl = NULLP;
9143
9144    for(arrIdx =0; arrIdx < dlTnlInfo->list.count; arrIdx++)
9145    {
9146       if(dlTnlInfo->list.array[arrIdx]->dLUPTNLInformation.present == UPTransportLayerInformation_PR_gTPTunnel)
9147       {
9148          if(dlTnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel != NULLP)
9149          {
9150             gtpDl = dlTnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel;
9151             if(gtpDl->gTP_TEID.size > 0)
9152             {
9153                teIdStringToInt(gtpDl->gTP_TEID.buf, &teId);
9154             }
9155             else
9156                DU_LOG("\nERROR  -->  EGTP: No TeId received");
9157             return(teId);
9158          }
9159       }
9160    }
9161    return teId;
9162 }
9163
9164 /****************************************************************
9165  * @brief Function to add Drb tunnels
9166  *
9167  * @details
9168  *
9169  *    Function : addDrbTunnels
9170  *
9171  *    Functionality:
9172  *         - Function to add Drb tunnels
9173  *
9174  * @params[in]
9175  * @return ROK     - success
9176  *         RFAILED - failure
9177  *
9178  * ****************************************************************/
9179 uint8_t addDrbTunnels(uint32_t duId, uint8_t teId)
9180 {
9181    uint8_t ret = ROK;
9182    EgtpTnlEvt tnlEvt;
9183
9184    if(teId > MAX_TEID || teId < MIN_TEID)
9185    {
9186       DU_LOG("\nERROR  -->  EGTP : TEID(%x) OUT Of Range",teId);
9187    }
9188    memset(&tnlEvt, 0, sizeof(EgtpTnlEvt));
9189    tnlEvt.action = EGTP_TNL_MGMT_ADD;
9190    tnlEvt.lclTeid = teId;
9191    tnlEvt.remTeid = teId;
9192    ret = cuEgtpTnlMgmtReq(duId, tnlEvt);
9193    if(ret != ROK)
9194    {
9195       DU_LOG("\nERROR  -->  EGTP : Tunnel management request failed for teId %x", teId);
9196    }
9197    return ROK;
9198 }
9199
9200 /****************************************************************
9201  * @brief Function to process Drb Setup List
9202  *
9203  * @details
9204  *
9205  *    Function : procDrbSetupList
9206  *
9207  *    Functionality:
9208  *         - Function to process DRB Setup List
9209  *
9210  * @params[in]
9211  * @return ROK     - success
9212  *         RFAILED - failure
9213  *
9214  * ****************************************************************/
9215 uint8_t procDrbSetupList(uint32_t duId, DRBs_Setup_List_t *drbSetupList)
9216 {
9217    uint8_t arrIdx = 0;
9218    uint32_t teId = 0;
9219    DRBs_Setup_ItemIEs_t *drbItemIe = NULLP;
9220
9221    if(drbSetupList != NULLP)
9222    {
9223       for(arrIdx = 0; arrIdx < drbSetupList->list.count; arrIdx++)
9224       {
9225          drbItemIe = ((DRBs_Setup_ItemIEs_t *)drbSetupList->list.array[arrIdx]);
9226          if(drbItemIe->value.present == DRBs_Setup_ItemIEs__value_PR_DRBs_Setup_Item)
9227          {
9228             /* extracting teId */
9229             teId  = extractTeId(&drbItemIe->value.choice.DRBs_Setup_Item.dLUPTNLInformation_ToBeSetup_List);
9230             if(teId > 0)
9231             {
9232               if(addDrbTunnels(duId, teId)== ROK)
9233               {
9234                 DU_LOG("\nDEBUG  --> EGTP: Tunnel Added for TeId %d", teId);
9235               }
9236             }
9237             else
9238                return RFAILED;
9239          }
9240       }
9241    }
9242    return ROK;
9243 }
9244
9245 /****************************************************************
9246  * @brief Function to process Ue Context Setup Response
9247  *
9248  * @details
9249  *
9250  *    Function : procUeContextSetupResponse
9251  *
9252  *    Functionality:
9253  *         - Function to process Ue Context Setup Response
9254  *
9255  * @params[in]
9256  * @return ROK     - success
9257  *         RFAILED - failure
9258  *
9259  * ****************************************************************/
9260 uint8_t procUeContextSetupResponse(uint32_t duId, F1AP_PDU_t *f1apMsg)
9261 {
9262    uint8_t duIdx = 0, idx = 0, ueIdx = 0;
9263    uint8_t duUeF1apId = 0, cuUeF1apId = 0;
9264    DuDb *duDb = NULLP;
9265    CuUeCb *ueCb = NULLP;
9266    UEContextSetupResponse_t *ueCtxtSetupRsp = NULLP;
9267    OCTET_STRING_t *duToCuRrcContainer;
9268
9269    SEARCH_DU_DB(duIdx, duId, duDb);
9270    ueCtxtSetupRsp = &f1apMsg->choice.successfulOutcome->value.choice.UEContextSetupResponse;
9271
9272    for(idx=0; idx < ueCtxtSetupRsp->protocolIEs.list.count; idx++)
9273    {
9274       switch(ueCtxtSetupRsp->protocolIEs.list.array[idx]->id)
9275       {
9276           case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
9277              {
9278                cuUeF1apId = ueCtxtSetupRsp->protocolIEs.list.array[idx]->value.choice.GNB_CU_UE_F1AP_ID;
9279                break;
9280              }
9281           case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
9282              {
9283                 duUeF1apId = ueCtxtSetupRsp->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID;
9284                 ueCb = &duDb->ueCb[duUeF1apId-1];
9285                 /* If ue context is not present in du db, then create UE context
9286                  * here. This flow is hit in case of UE handover where UE
9287                  * context is created before UE performs RACH on target DU */
9288                 if(ueCb->gnbDuUeF1apId == 0)
9289                 {
9290                    /* Creating UE context in target DU */
9291                    memset(ueCb, 0, sizeof(CuUeCb));
9292                    ueCb->cellCb = &duDb->cellCb[0];
9293                    ueCb->gnbDuUeF1apId = duUeF1apId;
9294                    ueCb->gnbCuUeF1apId = cuUeF1apId;
9295                    ueCb->state = UE_HANDOVER_IN_PROGRESS;
9296                    ueCb->hoInfo.targetDuId = duId;
9297                    (duDb->numUe)++;
9298
9299                    ueCb->cellCb->ueCb[ueCb->cellCb->numUe] = ueCb;
9300                    ueCb->cellCb->numUe++;
9301                 }
9302                 break;
9303              }
9304           case ProtocolIE_ID_id_C_RNTI:
9305              {
9306                 ueCb->crnti = ueCtxtSetupRsp->protocolIEs.list.array[idx]->value.choice.C_RNTI;
9307                 break;
9308              }
9309           case ProtocolIE_ID_id_DRBs_Setup_List:
9310              {
9311                 /* Adding Tunnels for successful DRB */
9312                 procDrbSetupList(duId, &ueCtxtSetupRsp->protocolIEs.list.array[idx]->value.choice.DRBs_Setup_List);
9313                 break;
9314              }
9315          case ProtocolIE_ID_id_DUtoCURRCInformation:
9316              {
9317                 DU_LOG("\nINFO  -->  Received Du to Cu RRC Information ");
9318                 duToCuRrcContainer = &ueCtxtSetupRsp->protocolIEs.list.array[idx]->value.choice.\
9319                    DUtoCURRCInformation.cellGroupConfig;
9320                 if((extractDuToCuRrcCont(ueCb, ueCtxtSetupRsp->protocolIEs.list.array[idx]->value.choice.\
9321                    DUtoCURRCInformation.cellGroupConfig)) != ROK)
9322                 {
9323                    DU_LOG("\nERROR  -->  F1AP: Failed to extract Du to Cu RRC Information ");
9324                    return RFAILED;
9325                 }
9326                 break;
9327              }
9328       }
9329    }
9330
9331    ueCb->f1apMsgDb.dlRrcMsgCount++; /* keeping DL RRC Msg Count */
9332
9333    /* If the UE is in handover, UE context modification request is to be sent to
9334     * source DU once UE context setup response is received from target DU */
9335    if(ueCb->state == UE_HANDOVER_IN_PROGRESS)
9336    {
9337       DuDb *srcDuDb = NULLP;
9338       CuUeCb *ueCbInSrcDu = NULLP;
9339
9340       /* Since Source DU Id and DU UE F1AP ID assigned to UE by source DU is not known here, we
9341        * need to find Source DU and UE CB in source DU using CU UE F1AP ID */
9342       for(duIdx=0; duIdx < cuCb.numDu; duIdx++)
9343       {
9344          /* UE context setup response is received from target DU. Search all
9345           * DUs to find source DU except this target DU Id.*/
9346          if(cuCb.duInfo[duIdx].duId != duId)
9347          {
9348             for(ueIdx = 0; ueIdx < MAX_NUM_UE; ueIdx++)
9349             {
9350                /* Check following:
9351                 * 1. CU UE F1AP ID in srcDU->ueCb should be same as cuUeF1apId
9352                 * received in UE context setup response since CU UE F1AP ID does not
9353                 * change for UE in handover.
9354                 * 2. srcDU->UeCb->uestate should be UE_HANDOVER_IN_PROGRESS
9355                 */
9356                if((cuCb.duInfo[duIdx].ueCb[ueIdx].gnbCuUeF1apId == cuUeF1apId) &&
9357                      (cuCb.duInfo[duIdx].ueCb[ueIdx].state == UE_HANDOVER_IN_PROGRESS))
9358                {
9359                   srcDuDb = &cuCb.duInfo[duIdx];
9360                   ueCbInSrcDu = &cuCb.duInfo[duIdx].ueCb[ueIdx];
9361
9362                   /* Store source DU info in the new UE context created in
9363                    * tareget DU */
9364                   ueCb->hoInfo.sourceDuId = srcDuDb->duId;
9365
9366                   /* Copy the received container to UeCb */
9367                   memcpy(&ueCbInSrcDu->f1apMsgDb.duToCuContainer, duToCuRrcContainer, sizeof(OCTET_STRING_t));
9368
9369                   if(BuildAndSendUeContextModificationReq(srcDuDb->duId, ueCbInSrcDu, STOP_DATA_TX) != ROK)
9370                   {
9371                      DU_LOG("\nERROR  ->  F1AP : Failed at BuildAndSendUeContextModificationReq()");
9372                      return RFAILED;
9373                   }
9374                   break;
9375                }
9376             }
9377          }
9378          if(srcDuDb && ueCbInSrcDu)
9379             break;
9380       }
9381    }
9382    return ROK;
9383 }
9384
9385 /****************************************************************
9386  * @brief Function to process Ul Rrc Msg received from DU
9387  *
9388  * @details
9389  *
9390  *    Function : procUlRrcMsg
9391  *
9392  *    Functionality:
9393  *         - Function to process Ul Rrc Msg received from DU
9394  *
9395  * @params[in]
9396  * @return ROK     - success
9397  *         RFAILED - failure
9398  *
9399  * ****************************************************************/
9400
9401 uint8_t procUlRrcMsg(uint32_t duId, F1AP_PDU_t *f1apMsg)
9402 {
9403    uint8_t idx, ret, srbId, rrcMsgType, duIdx=0;
9404    uint8_t cuUeF1apId, duUeF1apId;
9405    uint8_t *rrcContainer = NULLP;
9406    uint16_t rrcContLen;
9407    DuDb     *duDb;
9408    CuUeCb   *ueCb;
9409    ULRRCMessageTransfer_t *ulRrcMsg = NULLP;
9410
9411    ret = ROK;
9412    SEARCH_DU_DB(duIdx, duId, duDb);
9413    ulRrcMsg = &f1apMsg->choice.initiatingMessage->value.choice.ULRRCMessageTransfer;
9414
9415    for(idx=0; idx < ulRrcMsg->protocolIEs.list.count; idx++)
9416    {
9417       switch(ulRrcMsg->protocolIEs.list.array[idx]->id)
9418       {
9419          case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
9420             {
9421                cuUeF1apId = ulRrcMsg->protocolIEs.list.array[idx]->value.choice.GNB_CU_UE_F1AP_ID;
9422                break;
9423             }
9424          case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
9425             {
9426                duUeF1apId = ulRrcMsg->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID;
9427                break;
9428             }
9429          case ProtocolIE_ID_id_SRBID:
9430             srbId = ulRrcMsg->protocolIEs.list.array[idx]->value.choice.SRBID;
9431             break;
9432
9433          case ProtocolIE_ID_id_RRCContainer:
9434             {
9435                rrcContLen = ulRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.size;
9436                CU_ALLOC(rrcContainer, rrcContLen);
9437                if(!rrcContainer)
9438                {
9439                   DU_LOG("\nERROR  -->  F1AP : Failed to allocated memory in procUlRrcMsg");
9440                   return RFAILED;
9441                }
9442                memcpy(rrcContainer, ulRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.buf, rrcContLen);
9443
9444                if(duDb->ueCb[duUeF1apId-1].state == UE_HANDOVER_IN_PROGRESS)
9445                   return;
9446
9447                break;
9448             }
9449
9450          default:
9451             DU_LOG("\nERROR  -->  F1AP : Invalid Event %ld", ulRrcMsg->protocolIEs.list.array[idx]->id);
9452             break;
9453       }
9454    }
9455
9456    if(srbId == 1)
9457    {
9458       ueCb = &duDb->ueCb[duUeF1apId-1];
9459       ueCb->f1apMsgDb.dlRrcMsgCount++;
9460       rrcMsgType = setDlRRCMsgType(ueCb);
9461       if(rrcMsgType == REGISTRATION_ACCEPT)
9462       {
9463          DU_LOG("\nINFO  -->  F1AP: Sending DL RRC MSG for RRC Registration Accept");
9464          ret = BuildAndSendDLRRCMessageTransfer(duId, ueCb, srbId, rrcMsgType);
9465       }
9466       if(rrcMsgType == UE_CONTEXT_SETUP_REQ)
9467       {
9468          DU_LOG("\nINFO  -->  F1AP: Sending Ue Context Setup Req");
9469          ret = BuildAndSendUeContextSetupReq(duId, ueCb, rrcContLen, rrcContainer);
9470       }
9471       if(rrcMsgType == SECURITY_MODE_COMPLETE)
9472       {
9473          /* To trigger the DL RRC Msg for RRC Reconfig */
9474          ueCb->f1apMsgDb.dlRrcMsgCount++;
9475          rrcMsgType = setDlRRCMsgType(ueCb);
9476          if(rrcMsgType == RRC_RECONFIG)
9477          {
9478             DU_LOG("\nINFO  -->  F1AP: Sending DL RRC MSG for RRC Reconfig");
9479             BuildAndSendDLRRCMessageTransfer(duId, ueCb, srbId, rrcMsgType);
9480          }
9481       }
9482       if(rrcMsgType == RRC_RECONFIG_COMPLETE)
9483       {
9484          ueCb->state = UE_ACTIVE;
9485          ueCb->f1apMsgDb.dlRrcMsgCount++;
9486          rrcMsgType = setDlRRCMsgType(ueCb);
9487          if(rrcMsgType == UE_CONTEXT_MOD_REQ)
9488          {
9489             DU_LOG("\nINFO  -->  F1AP: Sending UE Context Modification Request");
9490             BuildAndSendUeContextModificationReq(duId, ueCb, RRC_RECONFIG_COMPLETE_IND);
9491          }
9492       }
9493    }
9494    return ret;
9495 }
9496
9497 /****************************************************************
9498  * @brief Build And Send F1ResetAck
9499  *
9500  * @details
9501  *
9502  *    Function : FreeF1ResetAck
9503  *
9504  *    Functionality:
9505  *         - Build And Send  F1ResetRSP
9506  *
9507  *  @params[in]
9508  * @return ROK     - success
9509  *         RFAILED - failure
9510  *
9511  * ****************************************************************/
9512 void FreeF1ResetAck(F1AP_PDU_t *f1apMsg)
9513 {
9514    uint8_t idx;
9515    ResetAcknowledge_t *f1ResetAck;
9516
9517    if(f1apMsg)
9518    {
9519       if(f1apMsg->choice.successfulOutcome)
9520       {
9521          f1ResetAck= &f1apMsg->choice.successfulOutcome->value.choice.ResetAcknowledge;
9522
9523          if(f1ResetAck->protocolIEs.list.array)
9524          {
9525             for(idx=0; idx<f1ResetAck->protocolIEs.list.count ; idx++)
9526             {
9527                if(f1ResetAck->protocolIEs.list.array[idx])
9528                {
9529                   CU_FREE(f1ResetAck->protocolIEs.list.array[idx], sizeof(ResetAcknowledgeIEs_t));
9530                }
9531             }
9532             CU_FREE(f1ResetAck->protocolIEs.list.array, f1ResetAck->protocolIEs.list.size );
9533          }
9534          CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
9535       }
9536       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
9537    }
9538 }
9539
9540 /****************************************************************
9541  * @brief Build And Send F1ResetAck
9542  *
9543  * @details
9544  *
9545  *    Function : BuildAndSendF1ResetAck
9546  *
9547  *    Functionality:
9548  *         - Build And Send  F1ResetRSP
9549  *
9550  *  @params[in]
9551  * @return ROK     - success
9552  *         RFAILED - failure
9553  *
9554  * ****************************************************************/
9555
9556 uint8_t BuildAndSendF1ResetAck()
9557 {
9558    uint8_t                idx = 0;
9559    uint8_t                elementCnt = 0;
9560    uint8_t                ret = RFAILED;
9561    F1AP_PDU_t             *f1apMsg = NULL;
9562    ResetAcknowledge_t     *f1ResetAck = NULLP;
9563    asn_enc_rval_t         encRetVal;
9564    DU_LOG("\nINFO  -->  F1AP : Building F1 Reset Acknowledgment \n");
9565
9566    do{
9567       /* Allocate the memory for F1ResetRequest_t */
9568       CU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
9569       if(f1apMsg == NULLP)
9570       {
9571          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
9572          break;
9573       }
9574
9575       f1apMsg->present =  F1AP_PDU_PR_successfulOutcome;
9576
9577       CU_ALLOC(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
9578       if(f1apMsg->choice.successfulOutcome == NULLP)
9579       {
9580          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
9581          break;
9582       }
9583
9584       f1apMsg->choice.successfulOutcome->procedureCode = ProcedureCode_id_Reset;
9585       f1apMsg->choice.successfulOutcome->criticality   = Criticality_reject;
9586       f1apMsg->choice.successfulOutcome->value.present = SuccessfulOutcome__value_PR_ResetAcknowledge;
9587       f1ResetAck = &f1apMsg->choice.successfulOutcome->value.choice.ResetAcknowledge;
9588
9589       elementCnt = 1;
9590
9591       f1ResetAck->protocolIEs.list.count = elementCnt;
9592       f1ResetAck->protocolIEs.list.size = elementCnt*sizeof(ResetAcknowledgeIEs_t *);
9593
9594       CU_ALLOC(f1ResetAck->protocolIEs.list.array, f1ResetAck->protocolIEs.list.size );
9595       if(f1ResetAck->protocolIEs.list.array == NULLP)
9596       {
9597          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1ResetAckIEs failed");
9598          break;
9599       }
9600
9601       for(idx=0; idx<elementCnt; idx++)
9602       {
9603          CU_ALLOC(f1ResetAck->protocolIEs.list.array[idx], sizeof(ResetAcknowledgeIEs_t));
9604          if(f1ResetAck->protocolIEs.list.array[idx] == NULLP)
9605          {
9606             break;
9607          }
9608       }
9609       /*TransactionID*/
9610       idx = 0;
9611       f1ResetAck->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_TransactionID;
9612       f1ResetAck->protocolIEs.list.array[idx]->criticality = Criticality_reject;
9613       f1ResetAck->protocolIEs.list.array[idx]->value.present = ResetAcknowledgeIEs__value_PR_TransactionID;
9614       f1ResetAck->protocolIEs.list.array[idx]->value.choice.TransactionID = TRANS_ID;
9615
9616       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
9617
9618       /* Encode the F1SetupRequest type as UPER */
9619       memset(encBuf, 0, ENC_BUF_MAX_LEN);
9620       encBufSize = 0;
9621       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
9622
9623       /* Check encode results */
9624       if(encRetVal.encoded == ENCODE_FAIL)
9625       {
9626          DU_LOG("\nERROR  -->  F1AP : Could not encode F1ResetAck structure (at %s)\n",\
9627                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
9628          break;
9629       }
9630       else
9631       {
9632          DU_LOG("\nDEBUG  -->  F1AP : Created APER encodedbuffer for F1ResetAck \n");
9633          for(int i=0; i< encBufSize; i++)
9634          {
9635             DU_LOG("%x",encBuf[i]);
9636          }
9637       }
9638
9639       /* Sending msg */
9640       /* TODO : Hardcoding DU ID to 1 for messages other than F1 Setup Response. This will be made generic in future gerrit */
9641       if(SendF1APMsg(CU_APP_MEM_REG, CU_POOL, DU_ID) != ROK)
9642       {
9643          DU_LOG("\nERROR  -->  F1AP : Sending F1 Reset Response failed");
9644          break;
9645       }
9646
9647       ret = ROK;
9648       break;
9649    }while(true);
9650
9651    FreeF1ResetAck(f1apMsg);
9652    return ret;
9653 }
9654
9655 void FreeUlTnlInfoforDrb2(ULUPTNLInformation_ToBeSetup_List_t *ulInfo)
9656 {
9657    uint8_t arrIdx =0;
9658
9659    if(ulInfo->list.array)
9660    {
9661       for(arrIdx=0; arrIdx<ulInfo->list.count ; arrIdx++)
9662       {
9663          if(ulInfo->list.array[arrIdx])
9664          {
9665             if(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel )
9666             {
9667                if(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf)
9668                {
9669                   if(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf)
9670                   {
9671                      CU_FREE(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
9672                      gTP_TEID.buf,ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.\
9673                      gTPTunnel->gTP_TEID.size);
9674                   }
9675                   CU_FREE(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
9676                   transportLayerAddress.buf,ulInfo->list.array[arrIdx]->\
9677                   uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.size);
9678                }
9679                CU_FREE(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel,\
9680                sizeof(GTPTunnel_t));
9681             }
9682             CU_FREE(ulInfo->list.array[arrIdx],sizeof(ULUPTNLInformation_ToBeSetup_Item_t));
9683          }
9684       }
9685       CU_FREE(ulInfo->list.array,ulInfo->list.size);
9686    }
9687 }
9688
9689 /*******************************************************************
9690 *
9691 * @brief Deletes the EGTP tunnel
9692 *
9693 * @details
9694 *
9695 *    Function : deleteEgtpTunnel
9696 *
9697 *    Functionality: Deletes the EGTP tunnel
9698 *
9699 * @params[in] uint8_t *buf
9700 *
9701 * @return ROK     - success
9702 *         RFAILED - failure
9703 *
9704 * ****************************************************************/
9705 uint8_t deleteEgtpTunnel(uint32_t duId, uint8_t *buf)
9706 {
9707    uint32_t teId = 0;
9708    EgtpTnlEvt tnlEvt;
9709
9710    teIdStringToInt(buf, &teId);
9711    if(teId > MAX_TEID || teId < MIN_TEID)
9712    {
9713       DU_LOG("\nERROR  -->  EGTP : TEID(%d) OUT Of Range", teId);
9714       return RFAILED;
9715    }
9716    memset(&tnlEvt, 0, sizeof(EgtpTnlEvt));
9717    tnlEvt.action = EGTP_TNL_MGMT_DEL;
9718    tnlEvt.lclTeid = teId;
9719    tnlEvt.remTeid = teId;
9720    if((cuEgtpTnlMgmtReq(duId, tnlEvt)) != ROK)
9721    {
9722       DU_LOG("\nERROR  -->  EGTP : Failed to delete tunnel Id %d", teId);
9723    }
9724    return ROK;
9725 }
9726
9727 /*******************************************************************
9728 *
9729 * @brief Builds the Uplink Tunnel Info
9730 *
9731 * @details
9732 *
9733 *    Function : BuildUlTnlInfoforSetupMod
9734 *
9735 *    Functionality: Constructs the UL TnlInfo For DRB list
9736 *
9737 * @params[in] ULUPTNLInformation_ToBeSetup_List_t *ulInfo
9738 *
9739 * @return ROK     - success
9740 *         RFAILED - failure
9741 *
9742 * ****************************************************************/
9743 uint8_t BuildUlTnlInfoforSetupMod(uint32_t duId, uint8_t ueId, uint8_t drbId, TnlInfo *ulTnlInfo, ULUPTNLInformation_ToBeSetup_List_t *ulInfo, uint8_t actionType)
9744 {
9745    uint8_t arrIdx;
9746    uint8_t ulCnt;
9747
9748    ulCnt = 1;
9749    ulInfo->list.count = ulCnt;
9750    ulInfo->list.size = ulCnt * sizeof(ULUPTNLInformation_ToBeSetup_Item_t *);
9751    CU_ALLOC(ulInfo->list.array,ulInfo->list.size);
9752    if(ulInfo->list.array == NULLP)
9753    {
9754       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildUlTnlInfoforSetupMod");
9755       return RFAILED;
9756    }
9757    for(arrIdx=0; arrIdx<ulCnt; arrIdx++)
9758    {
9759       CU_ALLOC(ulInfo->list.array[arrIdx],sizeof(ULUPTNLInformation_ToBeSetup_Item_t));
9760       if(ulInfo->list.array[arrIdx] == NULLP)
9761       {
9762          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildUlTnlInfoforSetupMod");
9763          return RFAILED;
9764       }
9765    }
9766
9767    arrIdx = 0;
9768    ulInfo->list.array[arrIdx]->uLUPTNLInformation.present = \
9769    UPTransportLayerInformation_PR_gTPTunnel;
9770
9771    /*GTP TUNNEL*/
9772    CU_ALLOC(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel,\
9773          sizeof(GTPTunnel_t));
9774    if(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel == NULLP)
9775    {
9776       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildUlTnlInfoforSetupMod");
9777       return RFAILED;
9778    }
9779    ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
9780       transportLayerAddress.size        = 4*sizeof(uint8_t);
9781    CU_ALLOC(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
9782          transportLayerAddress.buf,ulInfo->list.array[arrIdx]->\
9783          uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.size);
9784    if(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
9785          transportLayerAddress.buf == NULLP)
9786    {
9787       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildUlTnlInfoforSetupMod");
9788       return RFAILED;
9789    }
9790
9791    ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
9792       transportLayerAddress.buf[0] = 192;
9793    ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
9794       transportLayerAddress.buf[1] = 168;
9795    ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
9796       transportLayerAddress.buf[2] = 130;
9797    ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
9798       transportLayerAddress.buf[3] = 82;
9799    ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
9800       transportLayerAddress.bits_unused = 0;
9801
9802    ulTnlInfo->address[0] = ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[0];
9803    ulTnlInfo->address[1] = ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[1];
9804    ulTnlInfo->address[2] = ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[2];
9805    ulTnlInfo->address[3] = ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[3];
9806
9807    /*GTP TEID*/
9808    ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.size\
9809       = 4 * sizeof(uint8_t);
9810    CU_ALLOC(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
9811          gTP_TEID.buf,ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.\
9812          gTPTunnel->gTP_TEID.size);
9813    if(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf\
9814          == NULLP)
9815    {
9816       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildUlTnlInfoforSetupMod");
9817       return RFAILED;
9818    }
9819    ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
9820       gTP_TEID.buf[0] = 0;
9821    ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
9822       gTP_TEID.buf[1] = 0;
9823    ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
9824       gTP_TEID.buf[2] = 0;
9825    if(actionType == ProtocolIE_ID_id_DRBs_ToBeModified_Item)
9826    {
9827      /*TODO: DRB context to be stored in CU STUB so that tunnel Id can be easily
9828       * fetched based on the Drb Id */
9829
9830      /*For For UE Id=1, DRB=2 is modified. For UE Id = 2, DRB=5 is modified and so on.*/
9831       ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[3]=\
9832                                                         (MAX_NUM_DRB_ADDED_PER_UE *(ueId  - 1)) + drbId;
9833    }
9834    else
9835    {
9836       ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
9837         gTP_TEID.buf[3] = cuCb.cuCfgParams.egtpParams.currTunnelId++;
9838    }
9839
9840    ulTnlInfo->teId[0] = ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[0];
9841    ulTnlInfo->teId[1] = ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[1];
9842    ulTnlInfo->teId[2] = ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[2];
9843    ulTnlInfo->teId[3] = ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[3];
9844    return ROK;
9845 }/*End of BuildULTnlInfo*/
9846
9847 /*******************************************************************
9848 *
9849 * @brief freeing the DRB item
9850 *
9851 * @details
9852 *
9853 *    Function : FreeDrbItem
9854 *
9855 *    Functionality: freeing the DRB item
9856 *
9857 * @params[in] DRBs_ToBeSetupMod_Item_t *drbItem
9858 *
9859 * @return ROK     - success
9860 *         RFAILED - failure
9861 *
9862 * ****************************************************************/
9863
9864 void FreeDrbItem(DRBs_ToBeSetupMod_Item_t *drbItem)
9865 {
9866    uint8_t arrIdx =0;
9867    SNSSAI_t *snssai =NULLP;
9868    Flows_Mapped_To_DRB_List_t *flowMap = NULLP;
9869
9870    drbItem->qoSInformation.present = QoSInformation_PR_choice_extension;
9871    switch(drbItem->qoSInformation.present)
9872    {
9873       case QoSInformation_PR_NOTHING:
9874          break;
9875       case QoSInformation_PR_eUTRANQoS:
9876          {
9877             if(drbItem->qoSInformation.choice.eUTRANQoS)
9878             {
9879                CU_FREE(drbItem->qoSInformation.choice.eUTRANQoS, sizeof(EUTRANQoS_t));
9880             }
9881             break;
9882          }
9883       case QoSInformation_PR_choice_extension:
9884          {
9885             if(drbItem->qoSInformation.choice.choice_extension)
9886             {
9887                FreeQOSInfo(&drbItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS);
9888
9889                snssai = &drbItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI;
9890                if(snssai->sST.buf)
9891                {
9892                   CU_FREE(snssai->sST.buf,snssai->sST.size);
9893                }
9894                if(snssai->sD)
9895                {
9896                   if(snssai->sD->buf)
9897                   {
9898                      CU_FREE(snssai->sD->buf,snssai->sD->size);
9899                   }
9900                   CU_FREE(snssai->sD,sizeof(OCTET_STRING_t));
9901                }
9902
9903                flowMap = &drbItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.flows_Mapped_To_DRB_List;
9904                if(flowMap->list.array)
9905                {
9906                   for(arrIdx=0; arrIdx<flowMap->list.count; arrIdx++)
9907                   {
9908                      if(flowMap->list.array[arrIdx] )
9909                      {
9910                         FreeQOSInfo(&flowMap->list.array[arrIdx]->qoSFlowLevelQoSParameters);
9911                         CU_FREE(flowMap->list.array[arrIdx],sizeof(Flows_Mapped_To_DRB_Item_t));
9912                      }
9913                   }
9914                   CU_FREE(flowMap->list.array,flowMap->list.size);
9915                }
9916
9917                CU_FREE(drbItem->qoSInformation.choice.choice_extension,sizeof(QoSInformation_ExtIEs_t));
9918             }
9919             break;
9920          }
9921
9922    }
9923    FreeUlTnlInfoforDrb2(&drbItem->uLUPTNLInformation_ToBeSetup_List);
9924    if(drbItem->uLConfiguration)
9925    {
9926       CU_FREE(drbItem->uLConfiguration,sizeof(ULConfiguration_t));
9927    }
9928 }
9929
9930 /*******************************************************************
9931 *
9932 * @brief filling the DRB setup Mod item
9933 *
9934 * @details
9935 *
9936 *    Function : FillDrbItemToSetupMod
9937 *
9938 *    Functionality: filling the DRB setup Mod item
9939 *
9940 *
9941 * @params[in] DRBs_ToBeSetupMod_Item_t *drbItem
9942 *
9943 * @return ROK     - success
9944 *         RFAILED - failure
9945 *
9946 * ****************************************************************/
9947
9948 uint8_t FillDrbItemToSetupMod(uint32_t duId, CuUeCb *ueCb, uint8_t arrIdx, DRBs_ToBeSetupMod_Item_t *drbItem)
9949 {
9950    uint8_t ret = ROK;
9951
9952    /*Drb Id */
9953    drbItem->dRBID = arrIdx + DRB_ID_TO_ADD_MOD;
9954    ueCb->drbList[ueCb->numDrb].drbId = drbItem->dRBID;
9955
9956    /*qoSInformation*/
9957    drbItem->qoSInformation.present = QoSInformation_PR_choice_extension;
9958
9959    switch(drbItem->qoSInformation.present)
9960    {
9961       case QoSInformation_PR_NOTHING:
9962       {
9963          break;
9964       }
9965       case QoSInformation_PR_eUTRANQoS:
9966       {
9967
9968          CU_ALLOC(drbItem->qoSInformation.choice.eUTRANQoS, sizeof(EUTRANQoS_t));
9969          if(drbItem->qoSInformation.choice.eUTRANQoS)
9970          {
9971             DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in FillDrbItemToSetupMod");
9972             return RFAILED;
9973          }
9974          drbItem->qoSInformation.choice.eUTRANQoS->qCI = QCI;
9975          drbItem->qoSInformation.choice.eUTRANQoS->allocationAndRetentionPriority.priorityLevel =
9976             PriorityLevel_no_priority;
9977
9978          drbItem->qoSInformation.choice.eUTRANQoS->allocationAndRetentionPriority.pre_emptionCapability =
9979             Pre_emptionCapability_may_trigger_pre_emption;
9980
9981          drbItem->qoSInformation.choice.eUTRANQoS->allocationAndRetentionPriority.pre_emptionVulnerability =
9982             Pre_emptionVulnerability_pre_emptable;
9983
9984          break;
9985       }
9986       case QoSInformation_PR_choice_extension:
9987       {
9988          CU_ALLOC(drbItem->qoSInformation.choice.choice_extension,sizeof(QoSInformation_ExtIEs_t));
9989          if(drbItem->qoSInformation.choice.choice_extension == NULLP)
9990          {
9991             DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in FillDrbItemToSetupMod");
9992             return RFAILED;
9993          }
9994
9995          drbItem->qoSInformation.choice.choice_extension->id = ProtocolIE_ID_id_DRB_Information;
9996          drbItem->qoSInformation.choice.choice_extension->criticality = Criticality_ignore;
9997          drbItem->qoSInformation.choice.choice_extension->value.present = QoSInformation_ExtIEs__value_PR_DRB_Information;
9998          ret =  BuildQOSInfo(&ueCb->drbList[ueCb->numDrb].qos, &drbItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS,\
9999            ProtocolIE_ID_id_DRBs_ToBeSetupMod_Item, PDU_SESSION_ID_2, FALSE);
10000          if(ret != ROK)
10001          {
10002             DU_LOG("\nERROR  -->  F1AP : BuildQOSInfo failed");
10003             return RFAILED;
10004          }
10005
10006          /*SNSSAI*/
10007          ret = BuildSNSSAI(&ueCb->drbList[ueCb->numDrb], &drbItem->qoSInformation.choice.\
10008                choice_extension->value.choice.DRB_Information.sNSSAI, cuCb.snssaiList[1], FALSE);
10009          if(ret != ROK)
10010          {
10011             DU_LOG("\nERROR  -->  F1AP : BuildSNSSAI failed");
10012             return RFAILED;
10013          }
10014
10015          /*Flows mapped to DRB List*/
10016          ret = BuildFlowsMap(&ueCb->drbList[ueCb->numDrb], &drbItem->qoSInformation.choice.\
10017                choice_extension->value.choice.DRB_Information.flows_Mapped_To_DRB_List,\
10018           ProtocolIE_ID_id_DRBs_ToBeSetupMod_Item, FALSE);
10019          if(ret != ROK)
10020          {
10021             DU_LOG("\nERROR  -->  F1AP : BuildFlowsMap failed");
10022             return RFAILED;
10023          }
10024       }
10025    }
10026
10027    /*ULUPTNLInformation To Be Setup List*/
10028    ret = BuildUlTnlInfoforSetupMod(duId, ueCb->gnbCuUeF1apId, drbItem->dRBID, &ueCb->drbList[ueCb->numDrb].ulUpTnlInfo, \
10029       &drbItem->uLUPTNLInformation_ToBeSetup_List, ProtocolIE_ID_id_DRBs_ToBeSetupMod_Item);
10030    if(ret != ROK)
10031    {
10032       DU_LOG("\nERROR  -->  F1AP : BuildUlTnlInfoforSetupMod failed");
10033       return RFAILED;
10034    }
10035
10036    /*RLCMode*/
10037    drbItem->rLCMode = RLCMode_rlc_um_bidirectional;
10038    ueCb->drbList[ueCb->numDrb].rlcMode = drbItem->rLCMode;
10039
10040    ueCb->numDrb++;
10041    return ROK;
10042 }
10043
10044 /*******************************************************************
10045 *
10046 * @brief Builds the DRB to be Setup Mod ItemIes
10047 *
10048 * @details
10049 *
10050 *    Function : FillDrbItemList
10051 *
10052 *    Functionality: Constructs the DRB to be Setup Mod Item Ies
10053 *
10054 * @params[in] struct DRBs_ToBeSetupMod_ItemIEs *drbItemIe
10055 *
10056 * @return ROK     - success
10057 *         RFAILED - failure
10058 *
10059 * ****************************************************************/
10060
10061 uint8_t FillDrbItemList(uint32_t duId, CuUeCb *ueCb, uint8_t arrIdx, struct DRBs_ToBeSetupMod_ItemIEs *drbItemIe)
10062 {
10063    drbItemIe->id = ProtocolIE_ID_id_DRBs_ToBeSetupMod_Item;
10064    drbItemIe->criticality = Criticality_reject;
10065    drbItemIe->value.present = DRBs_ToBeSetupMod_ItemIEs__value_PR_DRBs_ToBeSetupMod_Item;
10066
10067    if(FillDrbItemToSetupMod(duId, ueCb, arrIdx, (&(drbItemIe->value.choice.DRBs_ToBeSetupMod_Item))) != ROK)
10068    {
10069       DU_LOG("\nERROR  -->  F1AP : FillDrbItemToSetupMod failed");
10070       return RFAILED;
10071    }
10072    return ROK;
10073 }
10074 /*******************************************************************
10075 *
10076 * @brief free the DRB to be Setup Mod list
10077 *
10078 * @details
10079 *
10080 *    Function : FreeDrbToBeSetupModList
10081 *
10082 *    Functionality: free the DRB to be Setup Mod list
10083 *
10084 * @params[in] DRBs_ToBeSetupMod_List_t *drbSet
10085 *
10086 * @return ROK     - success
10087 *         RFAILED - failure
10088 *
10089 * ****************************************************************/
10090 void FreeDrbToBeSetupModList(DRBs_ToBeSetupMod_List_t *drbSet)
10091 {
10092    uint8_t arrIdx =0;
10093    struct DRBs_ToBeSetupMod_ItemIEs *drbItemIe;
10094
10095    if(drbSet->list.array)
10096    {
10097       for(arrIdx=0; arrIdx<drbSet->list.count ; arrIdx++)
10098       {
10099          if(drbSet->list.array[arrIdx] != NULLP)
10100          {
10101             if(arrIdx == 0)
10102             {
10103                drbItemIe = (DRBs_ToBeSetupMod_ItemIEs_t *)drbSet->list.array[arrIdx];
10104                FreeDrbItem(&(drbItemIe->value.choice.DRBs_ToBeSetupMod_Item));
10105             }
10106             CU_FREE(drbSet->list.array[arrIdx], sizeof(DRBs_ToBeSetupMod_ItemIEs_t));
10107          }
10108       }
10109       CU_FREE(drbSet->list.array, drbSet->list.size);
10110    }
10111
10112 }
10113
10114 /*******************************************************************
10115 *
10116 * @brief Builds the DRB to be Setup Mod list
10117 *
10118 * @details
10119 *
10120 *    Function : BuildDrbToBeSetupList
10121 *
10122 *    Functionality: Constructs the DRB to be Setup Mod list
10123 *
10124 * @params[in] DRBs_ToBeSetupMod_List_t *drbSet
10125 *
10126 * @return ROK     - success
10127 *         RFAILED - failure
10128 *
10129 * ****************************************************************/
10130
10131 uint8_t BuildDrbToBeSetupList(uint32_t duId, CuUeCb *ueCb, DRBs_ToBeSetupMod_List_t *drbSet)
10132 {
10133    uint8_t ret = ROK;
10134    uint8_t arrIdx =0;
10135    uint8_t drbCnt =0;
10136
10137    drbCnt = MAX_DRB_SET_UE_CONTEXT_MOD_REQ;
10138    drbSet->list.count = drbCnt;
10139    drbSet->list.size = drbCnt * sizeof(DRBs_ToBeSetupMod_ItemIEs_t *);
10140    CU_ALLOC(drbSet->list.array, drbSet->list.size);
10141    if(drbSet->list.array == NULLP)
10142    {
10143       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDrbToBeSetupList");
10144       return  RFAILED;
10145    }
10146
10147    for(arrIdx=0; arrIdx<drbCnt; arrIdx++)
10148    {
10149       CU_ALLOC(drbSet->list.array[arrIdx], sizeof(DRBs_ToBeSetupMod_ItemIEs_t));
10150       if(drbSet->list.array[arrIdx] == NULLP)
10151       {
10152          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDrbToBeSetupList for array idx [%d]", arrIdx);
10153          return  RFAILED;
10154       }
10155
10156       ret = FillDrbItemList(duId, ueCb, arrIdx, (DRBs_ToBeSetupMod_ItemIEs_t *)drbSet->list.array[arrIdx]);
10157       if(ret != ROK)
10158       {
10159          DU_LOG("\nERROR  -->  F1AP : FillDrbItemList failed");
10160       }
10161    }
10162
10163    return ret;
10164 }
10165
10166 /*******************************************************************
10167 *
10168 * @brief Filling the DRB to be modified item
10169 *
10170 * @details
10171 *
10172 *    Function : FillDrbToBeModItem
10173 *
10174 *    Functionality: filling the DRB to be modified item
10175 *
10176 * @params[in] DRBs_ToBeModified_Item_t *drbItem
10177 *
10178 * @return ROK     - success
10179 *         RFAILED - failure
10180 *
10181 * ****************************************************************/
10182
10183 uint8_t FillDrbToBeModItem(uint32_t duId, CuUeCb *ueCb, uint8_t arrIdx, DRBs_ToBeModified_Item_t *drbItem)
10184 {
10185    uint8_t ret = ROK;
10186    uint drbIdx=0;
10187    DrbInfo *drbToBeMod;
10188
10189    /*Drb Id */
10190    drbItem->dRBID = DRB2 + arrIdx;
10191
10192    /* Search for DRB ID in CU databse */
10193    for(drbIdx = 0; drbIdx < ueCb->numDrb; drbIdx++)
10194    {
10195       if(ueCb->drbList[drbIdx].drbId == drbItem->dRBID)
10196       {
10197          drbToBeMod = &ueCb->drbList[drbIdx];
10198          break;
10199       }
10200    }
10201
10202    /*qoSInformation*/
10203    drbItem->qoSInformation = NULLP;
10204    CU_ALLOC(drbItem->qoSInformation, sizeof(QoSInformation_t));
10205    if(drbItem->qoSInformation != NULLP)
10206    {
10207       drbItem->qoSInformation->present = QoSInformation_PR_choice_extension;
10208
10209       switch(drbItem->qoSInformation->present)
10210       {
10211          case QoSInformation_PR_NOTHING:
10212             {
10213                break;
10214             }
10215          case QoSInformation_PR_eUTRANQoS:
10216             {
10217
10218                CU_ALLOC(drbItem->qoSInformation->choice.eUTRANQoS, sizeof(EUTRANQoS_t));
10219                if(drbItem->qoSInformation->choice.eUTRANQoS)
10220                {
10221                   DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in FillDrbToBeModItem");
10222                   return RFAILED;
10223                }
10224                drbItem->qoSInformation->choice.eUTRANQoS->qCI = QCI;
10225                drbItem->qoSInformation->choice.eUTRANQoS->allocationAndRetentionPriority.priorityLevel =
10226                   PriorityLevel_no_priority;
10227
10228                drbItem->qoSInformation->choice.eUTRANQoS->allocationAndRetentionPriority.pre_emptionCapability =
10229                   Pre_emptionCapability_may_trigger_pre_emption;
10230
10231                drbItem->qoSInformation->choice.eUTRANQoS->allocationAndRetentionPriority.pre_emptionVulnerability =
10232                   Pre_emptionVulnerability_pre_emptable;
10233
10234                break;
10235             }
10236          case QoSInformation_PR_choice_extension:
10237             {
10238                CU_ALLOC(drbItem->qoSInformation->choice.choice_extension,sizeof(QoSInformation_ExtIEs_t));
10239                if(drbItem->qoSInformation->choice.choice_extension == NULLP)
10240                {
10241                   DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in FillDrbItemToSetupMod");
10242                   return RFAILED;
10243                }
10244
10245                drbItem->qoSInformation->choice.choice_extension->id = ProtocolIE_ID_id_DRB_Information;
10246                drbItem->qoSInformation->choice.choice_extension->criticality = Criticality_ignore;
10247                drbItem->qoSInformation->choice.choice_extension->value.present = QoSInformation_ExtIEs__value_PR_DRB_Information;
10248                ret =  BuildQOSInfo(&drbToBeMod->qos, &drbItem->qoSInformation->choice.choice_extension->value.choice.DRB_Information.dRB_QoS,\
10249                      ProtocolIE_ID_id_DRBs_ToBeModified_Item, INVALID_PDU_SESSION_ID, FALSE);
10250                if(ret != ROK)
10251                {
10252                   DU_LOG("\nERROR  -->  F1AP : BuildQOSInfo failed");
10253                   return RFAILED;
10254                }
10255
10256                /*SNSSAI*/
10257                ret = BuildSNSSAI(drbToBeMod, &drbItem->qoSInformation->choice.\
10258                      choice_extension->value.choice.DRB_Information.sNSSAI, cuCb.snssaiList[0], FALSE);
10259                if(ret != ROK)
10260                {
10261                   DU_LOG("\nERROR  -->  F1AP : BuildSNSSAI failed");
10262                   return RFAILED;
10263                }
10264
10265                /*Flows mapped to DRB List*/
10266                ret = BuildFlowsMap(drbToBeMod, &drbItem->qoSInformation->choice.\
10267                      choice_extension->value.choice.DRB_Information.flows_Mapped_To_DRB_List,\
10268                      ProtocolIE_ID_id_DRBs_ToBeModified_Item, FALSE);
10269                if(ret != ROK)
10270                {
10271                   DU_LOG("\nERROR  -->  F1AP : BuildFlowsMap failed");
10272                   return RFAILED;
10273                }
10274             }
10275       }
10276    }/* End of QoS */
10277
10278    /*ULUPTNLInformation To Be Setup List*/
10279    ret = BuildUlTnlInfoforSetupMod(duId, ueCb->gnbCuUeF1apId, drbItem->dRBID, &drbToBeMod->ulUpTnlInfo, &drbItem->uLUPTNLInformation_ToBeSetup_List,\
10280             ProtocolIE_ID_id_DRBs_ToBeModified_Item);
10281    if(ret != ROK)
10282    {
10283       DU_LOG("\nERROR  -->  F1AP : BuildUlTnlInfoforSetupMod failed");
10284       return RFAILED;
10285    }
10286    return ROK;
10287 }
10288
10289 /*******************************************************************
10290 *
10291 * @brief Builds the DRB to be modified Item IE
10292 *
10293 * @details
10294 *
10295 *    Function : FillDrbToBeModItemList
10296 *
10297 *    Functionality: Constructs the DRB to be modified Mod Item Ies
10298 *
10299 * @params[in] struct DRBs_ToBeModified_ItemIEs *drbItemIe
10300 *
10301 * @return ROK     - success
10302 *         RFAILED - failure
10303 *
10304 * ****************************************************************/
10305
10306 uint8_t FillDrbToBeModItemList(uint32_t duId, CuUeCb *ueCb, uint8_t arrIdx, struct DRBs_ToBeModified_ItemIEs *drbItemIe)
10307 {
10308    drbItemIe->id = ProtocolIE_ID_id_DRBs_ToBeModified_Item;
10309    drbItemIe->criticality = Criticality_reject;
10310    drbItemIe->value.present = DRBs_ToBeModified_ItemIEs__value_PR_DRBs_ToBeModified_Item;
10311    if(FillDrbToBeModItem(duId, ueCb, arrIdx, &(drbItemIe->value.choice.DRBs_ToBeModified_Item)) != ROK)
10312    {
10313       DU_LOG("\nERROR  -->  F1AP : FillDrbToBeModItem failed");
10314       return RFAILED;
10315    }
10316
10317    return ROK;
10318 }
10319
10320 /*******************************************************************
10321 *
10322 * @brief Builds the DRB to be modified list
10323 *
10324 * @details
10325 *
10326 *    Function : BuildDrbToBeModList
10327 *
10328 *    Functionality: Constructs the DRB to be modified list
10329 *
10330 * @params[in] DRBs_ToBeModified_List_t *drbSet
10331 *
10332 * @return ROK     - success
10333 *         RFAILED - failure
10334 *
10335 * ****************************************************************/
10336
10337 uint8_t BuildDrbToBeModifiedList(uint32_t duId, CuUeCb *ueCb, DRBs_ToBeModified_List_t *drbSet)
10338 {
10339    uint8_t ret = ROK;
10340    uint8_t arrIdx =0;
10341    uint8_t drbCnt =0;
10342
10343    drbCnt = MAX_DRB_MODIFIED_UE_MOD_REQ;
10344    drbSet->list.count = drbCnt;
10345    drbSet->list.size = drbCnt * sizeof(DRBs_ToBeModified_ItemIEs_t *);
10346    CU_ALLOC(drbSet->list.array, drbSet->list.size);
10347    if(drbSet->list.array == NULLP)
10348    {
10349       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDrbToBeModifiedList");
10350       return  RFAILED;
10351    }
10352    for(arrIdx=0; arrIdx<drbCnt; arrIdx++)
10353    {
10354       CU_ALLOC(drbSet->list.array[arrIdx], sizeof(DRBs_ToBeModified_ItemIEs_t));
10355       if(drbSet->list.array[arrIdx] == NULLP)
10356       {
10357          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDrbToBeSetupList");
10358          return  RFAILED;
10359       }
10360
10361       ret = FillDrbToBeModItemList(duId, ueCb, arrIdx, (DRBs_ToBeModified_ItemIEs_t *)drbSet->list.array[arrIdx]);
10362       if(ret != ROK)
10363       {
10364          DU_LOG("\nERROR  -->  F1AP : FillDrbToBeModItemList failed");
10365       }
10366    }
10367
10368    return ret;
10369 }
10370
10371 /*******************************************************************
10372 *
10373 * @brief freeing the DRB  item
10374 *
10375 * @details
10376 *
10377 *    Function : FreeModifiedDrbItem
10378 *
10379 *    Functionality: freeing the DRB 2 item
10380 *
10381 * @params[in] DRBs_ToBeSetupMod_Item_t *drbItem
10382 *
10383 * @return ROK     - success
10384 *         RFAILED - failure
10385 *
10386 * ****************************************************************/
10387
10388 void FreeModifiedDrbItem(DRBs_ToBeModified_Item_t *drbItem)
10389 {
10390    uint8_t arrIdx =0;
10391    SNSSAI_t *snssai =NULLP;
10392    Flows_Mapped_To_DRB_List_t *flowMap = NULLP;
10393
10394    if(drbItem->qoSInformation != NULLP)
10395    {
10396       switch(drbItem->qoSInformation->present)
10397       {
10398          case QoSInformation_PR_NOTHING:
10399             break;
10400          case QoSInformation_PR_eUTRANQoS:
10401             {
10402                if(drbItem->qoSInformation->choice.eUTRANQoS)
10403                {
10404                   CU_FREE(drbItem->qoSInformation->choice.eUTRANQoS, sizeof(EUTRANQoS_t));
10405                }
10406                break;
10407             }
10408          case QoSInformation_PR_choice_extension:
10409             {
10410                if(drbItem->qoSInformation->choice.choice_extension)
10411                {
10412                   FreeQOSInfo(&drbItem->qoSInformation->choice.choice_extension->value.choice.DRB_Information.dRB_QoS);
10413
10414                   snssai = &drbItem->qoSInformation->choice.choice_extension->value.choice.DRB_Information.sNSSAI;
10415                   if(snssai->sST.buf)
10416                   {
10417                      CU_FREE(snssai->sST.buf,snssai->sST.size);
10418                   }
10419                   if(snssai->sD)
10420                   {
10421                      if(snssai->sD->buf)
10422                      {
10423                         CU_FREE(snssai->sD->buf,snssai->sD->size);
10424                      }
10425                      CU_FREE(snssai->sD,sizeof(OCTET_STRING_t));
10426                   }
10427
10428                   flowMap = &drbItem->qoSInformation->choice.choice_extension->value.choice.DRB_Information.flows_Mapped_To_DRB_List;
10429                   if(flowMap->list.array)
10430                   {
10431                      for(arrIdx=0; arrIdx<flowMap->list.count; arrIdx++)
10432                      {
10433                         if(flowMap->list.array[arrIdx] )
10434                         {
10435                            FreeQOSInfo(&flowMap->list.array[arrIdx]->qoSFlowLevelQoSParameters);
10436                            CU_FREE(flowMap->list.array[arrIdx],sizeof(Flows_Mapped_To_DRB_Item_t));
10437                         }
10438                      }
10439                      CU_FREE(flowMap->list.array,flowMap->list.size);
10440                   }
10441
10442                   CU_FREE(drbItem->qoSInformation->choice.choice_extension,sizeof(QoSInformation_ExtIEs_t));
10443                }
10444                break;
10445             }
10446       }
10447    }
10448    FreeUlTnlInfoforDrb2(&drbItem->uLUPTNLInformation_ToBeSetup_List);
10449    if(drbItem->uLConfiguration)
10450    {
10451       CU_FREE(drbItem->uLConfiguration,sizeof(ULConfiguration_t));
10452    }
10453 }
10454
10455 /*******************************************************************
10456 *
10457 * @brief free the DRB to be modfified list
10458 *
10459 * @details
10460 *
10461 *    Function : FreeDrbToBeModifiedList
10462 *
10463 *    Functionality: free the DRB to be Setup Mod list
10464 *
10465 * @params[in] FreeDrbToBeModifiedList_t *drbSet
10466 *
10467 * @return ROK     - success
10468 *         RFAILED - failure
10469 *
10470 * ****************************************************************/
10471 void FreeDrbToBeModifiedList(DRBs_ToBeModified_List_t *drbSet)
10472 {
10473    uint8_t arrIdx =0;
10474    struct DRBs_ToBeModified_ItemIEs *drbItemIe;
10475
10476    if(drbSet->list.array)
10477    {
10478       for(arrIdx=0; arrIdx<drbSet->list.count ; arrIdx++)
10479       {
10480          if(drbSet->list.array[arrIdx] != NULLP)
10481          {
10482             drbItemIe = (struct DRBs_ToBeModified_ItemIEs *)drbSet->list.array[arrIdx];
10483             FreeModifiedDrbItem(&(drbItemIe->value.choice.DRBs_ToBeModified_Item));
10484             CU_FREE(drbSet->list.array[arrIdx], sizeof(DRBs_ToBeModified_ItemIEs_t));
10485          }
10486       }
10487       CU_FREE(drbSet->list.array, drbSet->list.size);
10488    }
10489
10490 }
10491
10492 /*******************************************************************
10493  *
10494  * @brief  free the UeContextModification Request
10495  *
10496  * @details
10497  *
10498  *    Function : FreeUeContextModicationRequest
10499  *
10500  *    Functionality : deallocation of memory allocated in UeContextModiification
10501  request
10502  *
10503  * @params[in] F1AP_PDU_t *f1apMsg
10504  *
10505  * @return void
10506 *
10507 * ****************************************************************/
10508 void FreeUeContextModicationRequest(F1AP_PDU_t *f1apMsg)
10509 {
10510    uint8_t arrIdx =0 , ieId=0;
10511    UEContextModificationRequest_t *ueContextModifyReq = NULLP;
10512
10513    if(f1apMsg)
10514    {
10515       if(f1apMsg->choice.initiatingMessage)
10516       {
10517          ueContextModifyReq =&f1apMsg->choice.initiatingMessage->value.choice.UEContextModificationRequest;
10518          if(ueContextModifyReq->protocolIEs.list.array)
10519          {
10520             for( arrIdx = 0 ; arrIdx<ueContextModifyReq->protocolIEs.list.count ; arrIdx++)
10521             {
10522                if(ueContextModifyReq->protocolIEs.list.array[arrIdx])
10523                {
10524                   ieId = ueContextModifyReq->protocolIEs.list.array[arrIdx]->id;
10525                   switch(ieId)
10526                   {
10527                      case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
10528                         break;
10529                      case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
10530                         break;
10531                      case ProtocolIE_ID_id_DRBs_ToBeSetupMod_List:
10532                         {
10533                            FreeDrbToBeSetupModList(&ueContextModifyReq->protocolIEs.list.array[arrIdx]->value.\
10534                                  choice.DRBs_ToBeSetupMod_List);
10535                            break;
10536                         }
10537                      case ProtocolIE_ID_id_DRBs_ToBeModified_List:
10538                         {
10539                            FreeDrbToBeModifiedList(&ueContextModifyReq->protocolIEs.list.array[arrIdx]->value.\
10540                                  choice.DRBs_ToBeModified_List);
10541                            break;
10542                         }
10543                     case ProtocolIE_ID_id_TransmissionActionIndicator:
10544                         break;
10545                     case ProtocolIE_ID_id_RRCContainer:
10546                     {
10547                         CU_FREE(ueContextModifyReq->protocolIEs.list.array[arrIdx]->value.choice.RRCContainer.buf,\
10548                         ueContextModifyReq->protocolIEs.list.array[arrIdx]->value.choice.RRCContainer.size);
10549                     }
10550
10551                   }
10552                   CU_FREE(ueContextModifyReq->protocolIEs.list.array[arrIdx], sizeof(UEContextModificationRequest_t));
10553                }
10554             }
10555             CU_FREE(ueContextModifyReq->protocolIEs.list.array, ueContextModifyReq->protocolIEs.list.size);
10556          }
10557          CU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
10558       }
10559       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
10560    }
10561 }
10562
10563 /*******************************************************************
10564  *
10565  * @brief Builds the Ue Context Modification Req
10566  *
10567  * @details
10568  *
10569  *    Function : BuildAndSendUeContextModificationReq
10570  *
10571  *    Functionality: Constructs the Ue Context Modification Req
10572  *
10573  * @params[in]
10574  *
10575  * @return ROK     - success
10576  *         RFAILED - failure
10577  *
10578  * ****************************************************************/
10579 uint8_t BuildAndSendUeContextModificationReq(uint32_t duId, void *cuUeCb, UeCtxtModAction action)
10580 {
10581    uint8_t    ieIdx = 0;
10582    uint8_t    elementCnt = 0;
10583    uint8_t    ret = RFAILED;
10584    CuUeCb     *ueCb = (CuUeCb *)cuUeCb;
10585    F1AP_PDU_t *f1apMsg = NULLP;
10586    UEContextModificationRequest_t *ueContextModifyReq = NULLP;
10587    asn_enc_rval_t         encRetVal;
10588    DU_LOG("\nINFO  -->  F1AP : Building Ue context modification request\n");
10589    while(1)
10590    {
10591       CU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
10592       if(f1apMsg == NULLP)
10593       {
10594          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed Ue context modification");
10595          break;
10596       }
10597
10598       f1apMsg->present =  F1AP_PDU_PR_initiatingMessage;
10599
10600       CU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
10601       if(f1apMsg->choice.initiatingMessage == NULLP)
10602       {
10603          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed Ue context modification");
10604          break;
10605       }
10606       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_UEContextModification;
10607       f1apMsg->choice.initiatingMessage->criticality = Criticality_reject;
10608       f1apMsg->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_UEContextModificationRequest;
10609
10610       ueContextModifyReq =&f1apMsg->choice.initiatingMessage->value.choice.UEContextModificationRequest;
10611
10612       if(action == MODIFY_UE)
10613          elementCnt = 4;
10614       else if(action == QUERY_CONFIG)
10615          elementCnt = 3;
10616       else if(action == RRC_RECONFIG_COMPLETE_IND)
10617          elementCnt = 3;
10618       else if((action == STOP_DATA_TX) || (action == RESTART_DATA_TX))
10619          elementCnt = 5;
10620
10621       ueContextModifyReq->protocolIEs.list.count = elementCnt;
10622       ueContextModifyReq->protocolIEs.list.size = elementCnt*sizeof(UEContextModificationRequest_t *);
10623
10624       /* Initialize the UE context modification members */
10625       CU_ALLOC(ueContextModifyReq->protocolIEs.list.array, ueContextModifyReq->protocolIEs.list.size);
10626       if(ueContextModifyReq->protocolIEs.list.array == NULLP)
10627       {
10628          DU_LOG("\nERROR  -->  F1AP : Memory allocation for UE context modifcation Request failed");
10629          break;
10630       }
10631
10632       for(ieIdx=0 ; ieIdx<elementCnt; ieIdx++)
10633       {
10634          CU_ALLOC(ueContextModifyReq->protocolIEs.list.array[ieIdx], sizeof(UEContextModificationRequest_t));
10635          if(ueContextModifyReq->protocolIEs.list.array[ieIdx] == NULLP)
10636          {
10637             DU_LOG("\nERROR  -->  F1AP : Memory allocation for UE context modifcation Request failed");
10638             break;
10639          }
10640       }
10641
10642       ieIdx=0;
10643       ueContextModifyReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
10644       ueContextModifyReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
10645       ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present = \
10646                                                                          UEContextModificationRequestIEs__value_PR_GNB_CU_UE_F1AP_ID;
10647       ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID = ueCb->gnbCuUeF1apId;
10648
10649       ieIdx++;
10650       ueContextModifyReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
10651       ueContextModifyReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
10652       ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present=\
10653                                                                        UEContextModificationRequestIEs__value_PR_GNB_DU_UE_F1AP_ID;
10654       ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID = ueCb->gnbDuUeF1apId;
10655
10656       if(action == MODIFY_UE)
10657       {
10658          /* DRB to be setup list */
10659          ieIdx++;
10660          ueContextModifyReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_DRBs_ToBeSetupMod_List;
10661          ueContextModifyReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
10662          ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present =\
10663                                                                            UEContextModificationRequestIEs__value_PR_DRBs_ToBeSetupMod_List;
10664          ret = BuildDrbToBeSetupList(duId, ueCb, &(ueContextModifyReq->protocolIEs.list.array[ieIdx]->\
10665                   value.choice.DRBs_ToBeSetupMod_List));
10666
10667          /* DRB to be modified list */
10668          ieIdx++;
10669          ueContextModifyReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_DRBs_ToBeModified_List;
10670          ueContextModifyReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
10671          ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present =\
10672                                                                            UEContextModificationRequestIEs__value_PR_DRBs_ToBeModified_List;
10673          ret = BuildDrbToBeModifiedList(duId, ueCb, &(ueContextModifyReq->protocolIEs.list.array[ieIdx]->\
10674                   value.choice.DRBs_ToBeModified_List));
10675
10676          /* TODO: DRB to be release list */
10677
10678          if(ret != ROK)
10679          {
10680             DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextModificationReq(): Failed to build drb to be modified list");
10681             break;
10682          }
10683
10684          /* TODO: fill the RRC reconfiguration information in RRC Contaiiner ie in case of MODIFY_UE  */
10685       }
10686       else if(action == QUERY_CONFIG)
10687       {
10688          ieIdx++;
10689          ueContextModifyReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_GNB_DUConfigurationQuery;
10690          ueContextModifyReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
10691          ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present = \
10692             UEContextModificationRequestIEs__value_PR_GNB_DUConfigurationQuery;
10693          ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DUConfigurationQuery = GNB_DUConfigurationQuery_true;
10694       }
10695       else if(action == RRC_RECONFIG_COMPLETE_IND)
10696       {
10697          ieIdx++;
10698          ueContextModifyReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_RRCReconfigurationCompleteIndicator;
10699          ueContextModifyReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
10700          ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present = \
10701             UEContextModificationRequestIEs__value_PR_RRCReconfigurationCompleteIndicator;
10702          ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.RRCReconfigurationCompleteIndicator = \
10703             RRCReconfigurationCompleteIndicator_true;
10704       }
10705       else if((action == STOP_DATA_TX) || (action == RESTART_DATA_TX))
10706       {
10707          ieIdx++;
10708          if(action == STOP_DATA_TX)
10709          {
10710             ueContextModifyReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_TransmissionActionIndicator;
10711             ueContextModifyReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
10712             ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present = \
10713             UEContextModificationRequestIEs__value_PR_TransmissionActionIndicator;
10714             ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.TransmissionActionIndicator = \
10715             TransmissionActionIndicator_stop;
10716          }
10717          else if (action == RESTART_DATA_TX)
10718          {
10719             ueContextModifyReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_TransmissionActionIndicator;
10720             ueContextModifyReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
10721             ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present = \
10722             UEContextModificationRequestIEs__value_PR_TransmissionActionIndicator;
10723             ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.TransmissionActionIndicator = \
10724             TransmissionActionIndicator_restart;
10725          }
10726
10727          ieIdx++;
10728          ueContextModifyReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_RRCContainer;
10729          ueContextModifyReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
10730          ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present = \
10731          UEContextModificationRequestIEs__value_PR_RRCContainer;
10732          if(fillRrcReconfigBuf(ueCb, &ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer, true) != ROK)
10733          {
10734             DU_LOG( "\nERROR  -->  F1AP : Failed to fill Rrc reconfiguration buffer");
10735             return RFAILED;
10736          }
10737
10738          /* RRC delivery status request */
10739          ieIdx++;
10740          ueContextModifyReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_RRCDeliveryStatusRequest;
10741          ueContextModifyReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_ignore;
10742          ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present = UEContextModificationRequestIEs__value_PR_RRCDeliveryStatusRequest;
10743          ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.RRCDeliveryStatusRequest = RRCDeliveryStatusRequest_true;
10744       }
10745
10746       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
10747
10748       /* Encode the F1SetupRequest type as APER */
10749       memset(encBuf, 0, ENC_BUF_MAX_LEN);
10750       encBufSize = 0;
10751       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
10752
10753       /* Encode results */
10754       if(encRetVal.encoded == ENCODE_FAIL)
10755       {
10756          DU_LOG("\nERROR  -->  F1AP : Could not encode ueContextModifyReq structure (at %s)\n",\
10757                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
10758          break;
10759       }
10760       else
10761       {
10762          DU_LOG("\nDEBUG  -->  F1AP : Created APER encodedbuffer for ueContextModifyReq\n");
10763 #if 0
10764          /* This for loop was going into an infinite loop even though encBufSize
10765           * has a small value. Hence commented this
10766           */
10767          for(ieIdx=0; ieIdx< encBufSize; ieIdx++)
10768          {
10769             DU_LOG("%x",encBuf[ieIdx]);
10770          }
10771 #endif
10772       }
10773
10774       /* TODO : Hardcoding DU ID to 1 for messages other than F1 Setup Response. This will be made generic in future gerrit */
10775       if(SendF1APMsg(CU_APP_MEM_REG, CU_POOL, duId) != ROK)
10776       {
10777          DU_LOG("\nERROR  -->  F1AP : Sending Ue context modification request  failed");
10778          break;
10779       }
10780
10781       ret = ROK;
10782       break;
10783
10784    }
10785    FreeUeContextModicationRequest(f1apMsg);
10786    return ret;
10787 }
10788
10789 /*****************************************************************i
10790  *
10791 * @brief Free memory allocated for UE Context Release Command
10792 *
10793 * @details
10794 *
10795 *    Function : FreeUeContextReleaseCommand
10796 *
10797 *    Functionality:
10798 *         - Free memory allocated for UE Context Release Command
10799 *
10800 * @params[in] F1AP_PDU_t *f1apMsg
10801 * @return void
10802 *
10803 * *************************************************************/
10804 void FreeUeContextReleaseCommand(F1AP_PDU_t *f1apMsg)
10805 {
10806    uint8_t ieIdx;
10807    UEContextReleaseCommand_t *ueReleaseCommand = NULLP;
10808
10809    if(f1apMsg)
10810    {
10811       if(f1apMsg->choice.initiatingMessage)
10812       {
10813          ueReleaseCommand =&f1apMsg->choice.initiatingMessage->value.choice.UEContextReleaseCommand;
10814          if(ueReleaseCommand->protocolIEs.list.array)
10815          {
10816             for(ieIdx=0 ; ieIdx<ueReleaseCommand->protocolIEs.list.count; ieIdx++)
10817             {
10818                CU_FREE(ueReleaseCommand->protocolIEs.list.array[ieIdx], sizeof(UEContextReleaseCommand_t));
10819             }
10820             CU_FREE(ueReleaseCommand->protocolIEs.list.array, ueReleaseCommand->protocolIEs.list.size);
10821          }
10822          CU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
10823       }
10824       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
10825    }
10826 }
10827 /*******************************************************************
10828  *
10829  * @brief Builds the Ue Context Release Command
10830  *
10831  * @details
10832 *
10833 *    Function : BuildAndSendUeContextReleaseCommand
10834 *
10835 *    Functionality: Constructs the Ue Context Release Command
10836 *
10837 * @params[in]
10838 *
10839 * @return ROK     - success
10840 *         RFAILED - failure
10841 *
10842 * ****************************************************************/
10843 uint8_t BuildAndSendUeContextReleaseCommand(uint32_t duId, uint8_t cuUeF1apId, uint8_t duUeF1apId)
10844 {
10845    bool       memAllocFailed = false;
10846    uint8_t  duIdx = 0, ieIdx = 0,elementCnt = 0, ret = RFAILED, bufLen=0;
10847    DuDb *duDb;
10848    CuUeCb *ueCb;
10849    F1AP_PDU_t *f1apMsg = NULLP;
10850    UEContextReleaseCommand_t *ueContextReleaseCommand = NULLP;
10851
10852    asn_enc_rval_t         encRetVal;
10853    DU_LOG("\nINFO  -->  F1AP : Building Ue context release command\n");
10854
10855    while(true)
10856    {
10857       CU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
10858       if(f1apMsg == NULLP)
10859       {
10860          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseCommand(): Memory allocation for F1AP-PDU");
10861          break;
10862       }
10863
10864       f1apMsg->present =  F1AP_PDU_PR_initiatingMessage;
10865
10866       CU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
10867       if(f1apMsg->choice.initiatingMessage == NULLP)
10868       {
10869          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseCommand(): Memory allocation for F1AP-PDU failed ");
10870          break;
10871       }
10872       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_UEContextRelease;
10873       f1apMsg->choice.initiatingMessage->criticality = Criticality_reject;
10874       f1apMsg->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_UEContextReleaseCommand;
10875
10876       ueContextReleaseCommand =&f1apMsg->choice.initiatingMessage->value.choice.UEContextReleaseCommand;
10877
10878       SEARCH_DU_DB(duIdx, duId, duDb);
10879       ueCb = &duDb->ueCb[duUeF1apId-1];
10880       if(ueCb->state == UE_HANDOVER_IN_PROGRESS)
10881          elementCnt = 3;
10882       else
10883          elementCnt = 4;
10884
10885       ueContextReleaseCommand->protocolIEs.list.count = elementCnt;
10886       ueContextReleaseCommand->protocolIEs.list.size = elementCnt*sizeof(UEContextReleaseCommand_t*);
10887
10888       /* Initialize the UE context modification members */
10889       CU_ALLOC(ueContextReleaseCommand->protocolIEs.list.array, ueContextReleaseCommand->protocolIEs.list.size);
10890       if(ueContextReleaseCommand->protocolIEs.list.array == NULLP)
10891       {
10892          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseCommand():Memory allocation failed");
10893          break;
10894       }
10895
10896       for(ieIdx=0 ; ieIdx<elementCnt; ieIdx++)
10897       {
10898          CU_ALLOC(ueContextReleaseCommand->protocolIEs.list.array[ieIdx], sizeof(UEContextReleaseCommand_t));
10899          if(ueContextReleaseCommand->protocolIEs.list.array[ieIdx] == NULLP)
10900          {
10901             DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseCommand(): Memory allocation failed ");
10902             memAllocFailed = true;
10903             break;
10904          }
10905       }
10906
10907       if(memAllocFailed == true)
10908       {
10909          break;
10910       }
10911
10912       ieIdx=0;
10913       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
10914       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
10915       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.present = \
10916       UEContextReleaseCommandIEs__value_PR_GNB_CU_UE_F1AP_ID;
10917       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID =cuUeF1apId;
10918
10919       ieIdx++;
10920       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
10921       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
10922       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.present=\
10923       UEContextReleaseCommandIEs__value_PR_GNB_DU_UE_F1AP_ID;
10924       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID =duUeF1apId;
10925
10926       /* Cause of UE context release */
10927       ieIdx++;
10928       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_Cause;
10929       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->criticality = Criticality_ignore;
10930       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.present=\
10931                                                                             UEContextReleaseCommandIEs__value_PR_Cause;
10932       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.Cause.present = Cause_PR_radioNetwork;
10933       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.Cause.choice.radioNetwork=\
10934                                                                                                      CauseRadioNetwork_normal_release;
10935       if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
10936       {
10937          /* RRC Container for RRC release */
10938          ieIdx++;
10939          ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_RRCContainer;
10940          ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->criticality = Criticality_ignore;
10941          ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.present = \
10942                                                                                  UEContextReleaseCommandIEs__value_PR_RRCContainer;
10943          char secModeBuf[7]={ 0x00, 0x05, 0x13, 0x00, 0x00, 0x00, 0x00};
10944          bufLen =7;
10945          ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.size = bufLen;
10946          CU_ALLOC(ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf,
10947                ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.size);
10948          if(!ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf)
10949          {
10950             DU_LOG("\nERROR  -->  F1AP : Memory allocation for BuildAndSendUeContextReleaseCommand failed");
10951             break;
10952          }
10953          memset(ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf, 0, bufLen);
10954          memcpy(ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf, secModeBuf, bufLen);
10955       }
10956       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
10957
10958       /* Encode the UE Context Release Command type as APER */
10959       memset(encBuf, 0, ENC_BUF_MAX_LEN);
10960       encBufSize = 0;
10961       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
10962             encBuf);
10963
10964       /* Encode results */
10965       if(encRetVal.encoded == ENCODE_FAIL)
10966       {
10967          DU_LOG("\nERROR  -->  F1AP : Could not encode Release Command structure (at %s)\n",\
10968                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
10969          break;
10970       }
10971       else
10972       {
10973          DU_LOG("\nDEBUG  -->  F1AP : Created APER encoded buffer for Ue Context Release Command\n");
10974          for(ieIdx=0; ieIdx< encBufSize; ieIdx++)
10975          {
10976             DU_LOG("%x",encBuf[ieIdx]);
10977          }
10978       }
10979
10980       /* TODO : Hardcoding DU ID to 1 for messages other than F1 Setup Response. This will be made generic in future gerrit */
10981       if(SendF1APMsg(CU_APP_MEM_REG, CU_POOL, duId) != ROK)
10982       {
10983          DU_LOG("\nERROR  -->  F1AP : Sending Ue context Release Command failed");
10984          break;
10985       }
10986
10987       ret = ROK;
10988       break;
10989
10990    }
10991    FreeUeContextReleaseCommand(f1apMsg);
10992    return ret;
10993 }
10994 /*******************************************************************
10995 *
10996 * @brief process Ue context release request
10997 *
10998 * @details
10999 *
11000 *    Function : procUeContextReleaseReq
11001 *
11002 *    Functionality:
11003 *         - process Ue context release request
11004 *
11005 * @params[in] F1AP_PDU_t *f1apMsg
11006 * @return ROK     - success
11007 *         RFAILED - failure
11008 *
11009 * ****************************************************************/
11010 uint8_t procUeContextReleaseReq(uint32_t duId, F1AP_PDU_t *f1apMsg)
11011 {
11012    uint8_t ieIdx=0, duUeF1apId=0,cuUeF1apId=0;
11013
11014    UEContextReleaseRequest_t *ueReleaseReq = NULLP;
11015    ueReleaseReq = &f1apMsg->choice.initiatingMessage->value.choice.UEContextReleaseRequest;
11016
11017    for(ieIdx=0; ieIdx < ueReleaseReq->protocolIEs.list.count; ieIdx++)
11018    {
11019       switch(ueReleaseReq->protocolIEs.list.array[ieIdx]->id)
11020       {
11021          case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
11022             {
11023                cuUeF1apId = ueReleaseReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID;
11024                break;
11025             }
11026          case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
11027             {
11028                duUeF1apId = ueReleaseReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID;
11029                break;
11030             }
11031          default:
11032               break;
11033       }
11034    }
11035
11036    if(BuildAndSendUeContextReleaseCommand(duId, cuUeF1apId, duUeF1apId) != ROK)
11037    {
11038       DU_LOG("\nERROR  -->  F1AP : procUeContextReleaseReq(): Failed to build Ue Context Release Command ");
11039       return RFAILED;
11040    }
11041    return ROK;
11042 }
11043 /*******************************************************************
11044 *
11045 * @brief processing of Gnb-DU config update
11046 *
11047 * @details
11048 *
11049 *    Function : procGnbDuUpdate
11050 *
11051 *    Functionality:
11052 *         - processing of Gnb-DU config update
11053 *
11054 * @params[in] F1AP_PDU_t *f1apMsg
11055 * @return ROK     - success
11056 *         RFAILED - failure
11057 *
11058 * ****************************************************************/
11059 uint8_t procGnbDuUpdate(uint32_t duId, F1AP_PDU_t *f1apMsg)
11060 {
11061    bool cellToBeDelete = false;
11062    uint8_t ieIdx = 0, ueIdx = 0, duIdx = 0, cellIdx=0;
11063    uint16_t nrCellId;
11064    DuDb *duDb;
11065    CuCellCb *cellCb;
11066    GNBDUConfigurationUpdate_t *duCfgUpdate = NULLP;
11067
11068    duCfgUpdate = &f1apMsg->choice.initiatingMessage->value.choice.GNBDUConfigurationUpdate;
11069    for(ieIdx=0; ieIdx < duCfgUpdate->protocolIEs.list.count; ieIdx++)
11070    {
11071       switch(duCfgUpdate->protocolIEs.list.array[ieIdx]->id)
11072       {
11073          case ProtocolIE_ID_id_TransactionID:
11074             break;
11075          case ProtocolIE_ID_id_Served_Cells_To_Modify_List:
11076             break;
11077          case ProtocolIE_ID_id_Served_Cells_To_Delete_List:
11078             {
11079                struct Served_Cells_To_Delete_ItemIEs *deleteItemIe = \
11080                   (struct Served_Cells_To_Delete_ItemIEs *)duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.\
11081                   Served_Cells_To_Delete_List.list.array[0];
11082                bitStringToInt(&deleteItemIe->value.choice.Served_Cells_To_Delete_Item.oldNRCGI.nRCellIdentity, &nrCellId);
11083                cellToBeDelete = true;
11084                break;
11085             }
11086          case ProtocolIE_ID_id_gNB_DU_ID:
11087             break;
11088       }
11089    }
11090    if(BuildAndSendDUUpdateAck(duId) != ROK)
11091    {
11092       DU_LOG("ERROR  -->  F1AP : Failed to build and send DUUpdateAck");
11093       return RFAILED;
11094    }
11095 #if 0
11096    /* We don't require F1 Reset message in Cell Up and Broadcast Procedure flow, So that's why
11097     * commented this trigger for now */
11098
11099    if(cellToBeDelete == false)
11100    {
11101       DU_LOG("\nINFO  -->  F1AP : Sending F1 reset request");
11102       if(BuildAndSendF1ResetReq() != ROK)
11103       {
11104          DU_LOG("ERROR  -->  F1AP : Failed to build and send F1 reset request");
11105          return RFAILED;
11106       }
11107    }
11108 #endif
11109    if(cellToBeDelete == true)
11110    {
11111       SEARCH_DU_DB(duIdx, duId, duDb);
11112       SEARCH_CELL_DB(cellIdx, duDb, nrCellId, cellCb);
11113       if(cellCb->numUe == 0)
11114       {
11115          memset(cellCb, 0, sizeof(CuCellCb));
11116          duDb->numCells--;
11117       }
11118       else
11119          cellCb->cellStatus = CELL_DELETION_IN_PROGRESS;
11120    }
11121    return ROK;
11122 }
11123
11124 /*******************************************************************
11125 *
11126 * @brief storing slice list in CU database
11127 *
11128 * @details
11129 *
11130 *    Function : buildSliceList
11131 *
11132 *    Functionality:
11133 *         - storing slice list in CU database
11134 *
11135 * @params[in] SliceSupportList_t *sliceSupportList
11136 * @return ROK     - success
11137 *         RFAILED - failure
11138 *
11139 * ****************************************************************/
11140 uint8_t buildSliceList(SliceSupportList_t *sliceSupportList)
11141 {
11142    uint8_t sliceListIdx = 0;
11143
11144    if(sliceSupportList)
11145    {
11146       if(sliceSupportList->list.array)
11147       {
11148          cuCb.numSnssaiSupported = sliceSupportList->list.count;
11149          for(sliceListIdx=0; sliceListIdx<sliceSupportList->list.count; sliceListIdx++)
11150          {
11151             if(sliceSupportList->list.array[sliceListIdx])
11152             {
11153                CU_ALLOC(cuCb.snssaiList[sliceListIdx], sizeof(Snssai));
11154                if(cuCb.snssaiList[sliceListIdx] == NULLP)
11155                {
11156                    DU_LOG("\nERROR  --> CU_STUB: buildSliceList(): Memory allocation failed");
11157                    return RFAILED;
11158                }
11159                if(sliceSupportList->list.array[sliceListIdx]->sNSSAI.sST.buf)
11160                {
11161                   memcpy(&cuCb.snssaiList[sliceListIdx]->sst, sliceSupportList->list.array[sliceListIdx]->\
11162                   sNSSAI.sST.buf, sliceSupportList->list.array[sliceListIdx]->sNSSAI.sST.size);
11163                }
11164                if(sliceSupportList->list.array[sliceListIdx]->sNSSAI.sD->size)
11165                {
11166                   memcpy(&cuCb.snssaiList[sliceListIdx]->sd,\
11167                   sliceSupportList->list.array[sliceListIdx]->sNSSAI.sD->buf,\
11168                   sliceSupportList->list.array[sliceListIdx]->sNSSAI.sD->size);
11169                }
11170             }
11171          }
11172       }
11173    }
11174    return ROK;
11175 }
11176
11177 /****************************************************************
11178  * @brief Function to process Srb Setup Mod List
11179  *
11180  * @details
11181  *
11182  *    Function : procSrbSetupModList
11183  *
11184  *    Functionality:
11185  *         - Function to process SRB Setup Mod List
11186  *
11187  * @params[in]
11188  * @return ROK     - success
11189  *         RFAILED - failure
11190  *
11191  * ****************************************************************/
11192 uint8_t procSrbSetupModList(CuUeCb *ueCb, SRBs_SetupMod_List_t *srbSetupList)
11193 {
11194    uint8_t arrIdx = 0, srbIdx;
11195    struct SRBs_SetupMod_ItemIEs *srbItemIe = NULLP;
11196
11197    if(srbSetupList != NULLP)
11198    {
11199       for(arrIdx = 0; arrIdx < srbSetupList->list.count; arrIdx++)
11200       {
11201          srbItemIe = ((struct SRBs_SetupMod_ItemIEs *)srbSetupList->list.array[arrIdx]);
11202          if(srbItemIe->value.present == SRBs_SetupMod_ItemIEs__value_PR_SRBs_SetupMod_Item)
11203          {
11204             for(srbIdx = 0; srbIdx < ueCb->numSrb; srbIdx++)
11205             {
11206                if(ueCb->srbList[srbIdx].srbId == srbItemIe->value.choice.SRBs_SetupMod_Item.sRBID)
11207                {
11208                   ueCb->srbList[srbIdx].lcId = srbItemIe->value.choice.SRBs_SetupMod_Item.lCID;
11209                   break;
11210                }
11211             }
11212          }
11213
11214       }
11215    }
11216    return ROK;
11217 }
11218
11219
11220 /****************************************************************
11221  * @brief Function to process Drb Setup Mod List
11222  *
11223  * @details
11224  *
11225  *    Function : procDrbSetupModList
11226  *
11227  *    Functionality:
11228  *         - Function to process DRB Setup Mod List
11229  *
11230  * @params[in]
11231  * @return ROK     - success
11232  *         RFAILED - failure
11233  *
11234  * ****************************************************************/
11235 uint8_t procDrbSetupModList(uint32_t duId, CuUeCb *ueCb, DRBs_SetupMod_List_t *drbSetupList)
11236 {
11237    uint8_t arrIdx = 0, drbIdx;
11238    uint32_t teId = 0;
11239    struct DRBs_SetupMod_ItemIEs *drbItemIe = NULLP;
11240
11241    if(drbSetupList != NULLP)
11242    {
11243       for(arrIdx = 0; arrIdx < drbSetupList->list.count; arrIdx++)
11244       {
11245          drbItemIe = ((struct DRBs_SetupMod_ItemIEs *)drbSetupList->list.array[arrIdx]);
11246          if(drbItemIe->value.present == DRBs_SetupMod_ItemIEs__value_PR_DRBs_SetupMod_Item)
11247          {
11248             for(drbIdx = 0; drbIdx < ueCb->numDrb; drbIdx++)
11249             {
11250                if(ueCb->drbList[drbIdx].drbId == drbItemIe->value.choice.DRBs_SetupMod_Item.dRBID)
11251                {
11252                   if(drbItemIe->value.choice.DRBs_SetupMod_Item.lCID)
11253                      ueCb->drbList[drbIdx].lcId = *(drbItemIe->value.choice.DRBs_SetupMod_Item.lCID);
11254                   break;
11255                }
11256             }
11257
11258             if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
11259             {
11260             /* extracting teId */
11261             teId  = extractTeId(&drbItemIe->value.choice.DRBs_SetupMod_Item.dLUPTNLInformation_ToBeSetup_List);
11262             if(teId > 0)
11263             {
11264               if(addDrbTunnels(duId, teId)== ROK)
11265               {
11266                 DU_LOG("\nDEBUG  --> EGTP: Tunnel Added for TeId %d", teId);
11267               }
11268             }
11269             else
11270                return RFAILED;
11271             }
11272          }
11273       }
11274    }
11275    return ROK;
11276 }
11277
11278 /*******************************************************************
11279 *
11280 * @brief processing of GNB_DU_Served_Cells Plmn list  information
11281 *
11282 * @details
11283 *
11284 *    Function : procServedCellPlmnList
11285 *
11286 *    Functionality:
11287 *         - processing of GNB_DU_Served_Cells Plmn list information for storing
11288 *         SNSSAI list
11289 *
11290 * @params[in] F1AP_PDU_t *f1apMsg
11291 * @return ROK     - success
11292 *         RFAILED - failure
11293 *
11294 * ****************************************************************/
11295 uint8_t procServedCellPlmnList(ServedPLMNs_List_t *srvPlmn)
11296 {
11297    uint8_t srvPlmnIdx=0, ieExtensionsLstIdx=0;
11298    ProtocolExtensionContainer_4624P3_t **ieExtend;
11299
11300    if(srvPlmn->list.array)
11301    {
11302       for(srvPlmnIdx=0; srvPlmnIdx<srvPlmn->list.count; srvPlmnIdx++)
11303       {
11304          if(srvPlmn->list.array[srvPlmnIdx])
11305          {
11306             ieExtend =  &srvPlmn->list.array[srvPlmnIdx]->iE_Extensions;
11307             if(*ieExtend)
11308             {
11309                if((*ieExtend)->list.array)
11310                {
11311                   for(ieExtensionsLstIdx = 0; ieExtensionsLstIdx<(*ieExtend)->list.count; ieExtensionsLstIdx++)
11312                   {
11313                      if((*ieExtend)->list.array[ieExtensionsLstIdx])
11314                      {
11315                         switch((*ieExtend)->list.array[ieExtensionsLstIdx]->id )
11316                         {
11317                            case ProtocolIE_ID_id_TAISliceSupportList:
11318                               {
11319                                  if(buildSliceList(&(*ieExtend)->list.array[ieExtensionsLstIdx]->\
11320                                           extensionValue.choice.SliceSupportList) != ROK)
11321                                  {
11322                                     DU_LOG("\nERROR  --> CU_STUB: procServedCellPlmnList(): Failed to build slice List");
11323                                     return RFAILED;
11324                                  }
11325                               }
11326                         }
11327                      }
11328                   }
11329                }
11330             }
11331          }
11332       }
11333    }
11334    return ROK;
11335 }
11336
11337 /****************************************************************
11338  * @brief Function to process Ue Context Modification Response
11339  *
11340  * @details
11341  *
11342  *    Function : procUeContextModificationResponse
11343  *
11344  *    Functionality:
11345  *         - Function to process Ue Context Modification Response
11346  *
11347  * @params[in]
11348  * @return ROK     - success
11349  *         RFAILED - failure
11350  *
11351  * ****************************************************************/
11352 uint8_t procUeContextModificationResponse(uint32_t duId, F1AP_PDU_t *f1apMsg)
11353 {
11354    uint8_t idx=0, duIdx=0;
11355    uint8_t duUeF1apId = 0, cuUeF1apId = 0;
11356    DuDb *duDb = NULLP;
11357    CuUeCb *ueCb = NULLP;
11358    UEContextModificationResponse_t *ueCtxtModRsp = NULLP;
11359
11360    SEARCH_DU_DB(duIdx, duId, duDb);
11361    ueCtxtModRsp = &f1apMsg->choice.successfulOutcome->value.choice.UEContextModificationResponse;
11362
11363    for(idx=0; idx < ueCtxtModRsp->protocolIEs.list.count; idx++)
11364    {
11365       switch(ueCtxtModRsp->protocolIEs.list.array[idx]->id)
11366       {
11367           case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
11368              {
11369                 cuUeF1apId = ueCtxtModRsp->protocolIEs.list.array[idx]->value.choice.GNB_CU_UE_F1AP_ID;
11370                 break;
11371              }
11372           case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
11373              {
11374                 duUeF1apId = ueCtxtModRsp->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID;
11375                 ueCb = &duDb->ueCb[duUeF1apId-1];
11376                 break;
11377              }
11378           case ProtocolIE_ID_id_DRBs_SetupMod_List:
11379              {
11380                 /* Adding Tunnels for successful DRB */
11381                 procDrbSetupModList(duId, ueCb, &ueCtxtModRsp->protocolIEs.list.array[idx]->value.choice.DRBs_SetupMod_List);
11382                 break;
11383
11384              }
11385           case ProtocolIE_ID_id_SRBs_SetupMod_List:
11386              {
11387                 procSrbSetupModList(ueCb, &ueCtxtModRsp->protocolIEs.list.array[idx]->value.choice.SRBs_SetupMod_List);
11388                 break;
11389              }
11390          case ProtocolIE_ID_id_DUtoCURRCInformation:
11391              {
11392                 DU_LOG("\nINFO  -->  Received Du to Cu RRC Information ");
11393                 if((extractDuToCuRrcCont(ueCb, ueCtxtModRsp->protocolIEs.list.array[idx]->value.choice.\
11394                    DUtoCURRCInformation.cellGroupConfig)) != ROK)
11395                 {
11396                    DU_LOG("\nERROR  -->  F1AP : Failed to extract Du to Cu RRC Information");
11397                    return RFAILED;
11398                 }
11399                 break;
11400              }
11401
11402       }
11403    }
11404
11405    /* If UE is in handover and UE context is not yet created at target DU, then send
11406     * UE context setup request to target DU */
11407    if(ueCb->state == UE_HANDOVER_IN_PROGRESS)
11408    {
11409       uint8_t ueIdx = 0;
11410       DuDb *tgtDuDb = NULLP;
11411       CuUeCb *ueCbInTgtDu = NULLP;
11412
11413       SEARCH_DU_DB(duIdx, ueCb->hoInfo.targetDuId, tgtDuDb);
11414       if(tgtDuDb)
11415       {
11416          /* Since DU UE F1AP ID assigned by target DU to this UE in handover is
11417           * not known here, using CU UE F1AP ID to search for UE Cb in target DU
11418           * DB */
11419          for(ueIdx = 0; ueIdx < MAX_NUM_UE; ueIdx++)
11420          {
11421             if(tgtDuDb->ueCb[ueIdx].gnbCuUeF1apId == cuUeF1apId)
11422             {
11423                ueCbInTgtDu = &tgtDuDb->ueCb[ueIdx];
11424                break;
11425             }
11426          }
11427
11428          /* If UE context is not found in Target DU DU, send UE context setup
11429           * request */
11430          if(ueCbInTgtDu == NULLP)
11431          {
11432             if((BuildAndSendUeContextSetupReq(ueCb->hoInfo.targetDuId, ueCb, 0, NULLP)) != ROK)
11433             {
11434                DU_LOG("\nERROR  ->  F1AP : Failed at BuildAndSendUeContextSetupReq");
11435                return RFAILED;
11436             }
11437          }
11438       }
11439    }
11440
11441    return ROK;
11442 }
11443
11444 /*******************************************************************
11445 *
11446 * @brief processing of F1 setup request
11447 *
11448 * @details
11449 *
11450 *    Function : procF1SetupReq
11451 *
11452 *    Functionality:
11453 *         - processing of  F1 setup request
11454 *
11455 * @params[in] F1AP_PDU_t *f1apMsg
11456 * @return ROK     - success
11457 *         RFAILED - failure
11458 *
11459 * ****************************************************************/
11460 void procF1SetupReq(uint32_t *destDuId, F1AP_PDU_t *f1apMsg)
11461 {
11462    uint8_t ieIdx = 0, plmnidx=0, duIdx = 0, ret=ROK, cellIdx = 0;
11463    uint32_t duId = 0, nrCellId = 0;
11464    DuDb     *duDb = NULLP;
11465    CuCellCb *cellCb = NULLP;
11466    BIT_STRING_t nrcellIdentity;
11467    F1SetupRequest_t *f1SetupReq = NULLP;
11468    GNB_DU_Served_Cells_Item_t *srvCellItem = NULLP;
11469    GNB_DU_Served_Cells_List_t *duServedCell = NULLP;
11470
11471    f1SetupReq = &f1apMsg->choice.initiatingMessage->value.choice.F1SetupRequest;
11472    for(ieIdx=0; ieIdx < f1SetupReq->protocolIEs.list.count; ieIdx++)
11473    {
11474       switch(f1SetupReq->protocolIEs.list.array[ieIdx]->id)
11475       {
11476          case ProtocolIE_ID_id_gNB_DU_ID:
11477            {
11478               duId = f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf[0];
11479               SEARCH_DU_DB(duIdx, duId, duDb);
11480               if(duDb == NULLP)
11481               {
11482                  duDb = &cuCb.duInfo[cuCb.numDu];
11483                  memset(duDb, 0, sizeof(DuDb));
11484                  duDb->duId = duId;
11485                  cuCb.numDu++;
11486                  *destDuId = duId;
11487               }
11488               else
11489                  return;
11490               break;
11491            }
11492          case ProtocolIE_ID_id_gNB_DU_Name:
11493            {
11494               strcpy((char *)duDb->duName, (char*)f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_Name.buf);
11495               break;
11496            }
11497          case ProtocolIE_ID_id_gNB_DU_Served_Cells_List:
11498            {
11499                duServedCell = &f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_Served_Cells_List;
11500                if(duServedCell->list.array)
11501                {
11502                   for(plmnidx=0; plmnidx<duServedCell->list.count; plmnidx++)
11503                   {
11504                      if(duServedCell->list.array[plmnidx])
11505                      {
11506                         switch(duServedCell->list.array[plmnidx]->id)
11507                         {
11508                            case ProtocolIE_ID_id_GNB_DU_Served_Cells_Item:
11509                            {
11510                               srvCellItem =  &duServedCell->list.array[plmnidx]->value.choice.GNB_DU_Served_Cells_Item;
11511                               ret = procServedCellPlmnList(&srvCellItem->served_Cell_Information.servedPLMNs);
11512                               memcpy(&nrcellIdentity, &srvCellItem->served_Cell_Information.nRCGI.nRCellIdentity, sizeof(BIT_STRING_t));
11513
11514                               /* TODO : Use bitStringToInt */
11515                               nrCellId = nrcellIdentity.buf[4] >> nrcellIdentity.bits_unused;
11516                               SEARCH_CELL_DB(cellIdx, duDb, nrCellId, cellCb);
11517                               if(cellCb == NULLP)
11518                               {
11519                                  cellCb = &duDb->cellCb[duDb->numCells];
11520                                  memset(cellCb, 0, sizeof(CuCellCb));
11521                                  cellCb->nrCellId = nrCellId;
11522                                  cellCb->cellStatus = CELL_ACTIVE;
11523                                  duDb->numCells++;
11524                               }
11525                            }
11526                         }
11527                      }
11528                   }
11529                }
11530            }
11531       }
11532    }
11533    if(ret == ROK)
11534    {
11535       BuildAndSendF1SetupRsp(duId, &nrcellIdentity);
11536    }
11537    else
11538    {
11539        DU_LOG("\nERROR  --> CU_STUB: procF1SetupReq(): Failed to process F1 setup request");
11540    }
11541 }
11542
11543 /****************************************************************
11544 *
11545 * @brief processing of UE Context Release Complete
11546 *
11547 * @details
11548 *
11549 *    Function : procUeContextReleaseComplete
11550 *
11551 *    Functionality:
11552 *         - processing of UE Context Release Complete
11553 *
11554 * @params[in] F1AP_PDU_t *f1apMsg
11555 * @return ROK     - success
11556 *         RFAILED - failure
11557 *
11558 * ****************************************************************/
11559 void procUeContextReleaseComplete(uint32_t duId, F1AP_PDU_t *f1apMsg)
11560 {
11561    uint8_t duIdx = 0, ieIdx = 0, ueIdx = 0;
11562    uint8_t gnbDuUeF1apId = 0, gnbCuUeF1apId = 0;
11563    DuDb *duDb = NULLP;
11564    CuUeCb *ueCb = NULLP;
11565    UEContextReleaseComplete_t *ueReleaseComplete = NULLP;
11566
11567    SEARCH_DU_DB(duIdx, duId, duDb);
11568    if(!duDb)
11569    {
11570       DU_LOG("\nERROR  -->  F1AP : No entry found for DU ID [%d]", duId);
11571       return;
11572    }
11573
11574    ueReleaseComplete = &f1apMsg->choice.successfulOutcome->value.choice.UEContextReleaseComplete;
11575    for(ieIdx=0; ieIdx < ueReleaseComplete->protocolIEs.list.count; ieIdx++)
11576    {
11577       switch(ueReleaseComplete->protocolIEs.list.array[ieIdx]->id)
11578       {
11579          case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
11580             {
11581                gnbCuUeF1apId = ueReleaseComplete->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID;
11582                break;
11583             }
11584          case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
11585             {
11586                gnbDuUeF1apId = ueReleaseComplete->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID;
11587                ueCb = &duDb->ueCb[gnbDuUeF1apId-1];
11588                for(ueIdx = 0; ueIdx <MAX_NUM_UE; ueIdx++)
11589                {
11590                   if(ueCb->cellCb && ueCb->cellCb->ueCb[ueIdx])
11591                   {
11592                      if((ueCb->cellCb->ueCb[ueIdx]->gnbCuUeF1apId == gnbCuUeF1apId) &&
11593                            (ueCb->cellCb->ueCb[ueIdx]->gnbDuUeF1apId == gnbDuUeF1apId))
11594                      {
11595                         ueCb->cellCb->ueCb[ueIdx] = NULLP;
11596                         ueCb->cellCb->numUe--;
11597                         if((ueCb->cellCb->numUe == 0) && (ueCb->cellCb->cellStatus = CELL_DELETION_IN_PROGRESS))
11598                         {
11599                            memset(ueCb->cellCb, 0, sizeof(CuCellCb));
11600                            duDb->numCells--;
11601                         }
11602                         break;
11603                      }
11604                   }
11605                }
11606                memset(ueCb, 0, sizeof(CuUeCb));
11607                duDb->numUe--;
11608                break;
11609             }
11610       }
11611    }
11612 }
11613
11614 /*******************************************************************
11615  *
11616  * @brief Builds the Paging cell list
11617  *
11618  * @details
11619  *
11620  *    Function : BuildPagingCellList
11621  *
11622  *    Functionality: Build the paging cell list
11623  *
11624  * @params[in] PagingCell_list_t  *pagingCelllist,
11625  *
11626  * @return ROK     - success
11627  *         RFAILED - failure
11628  *
11629  * ****************************************************************/
11630 uint8_t BuildPagingCellList(PagingCell_list_t *pagingCelllist, uint8_t numCells, CuCellCb *cellCb)
11631 {
11632    uint8_t cellIdx =0;
11633    PagingCell_ItemIEs_t *pagingCellItemIes;
11634    PagingCell_Item_t *pagingCellItem;
11635
11636    pagingCelllist->list.count = numCells;
11637    pagingCelllist->list.size = pagingCelllist->list.count * (sizeof(PagingCell_ItemIEs_t*));
11638    CU_ALLOC(pagingCelllist->list.array, pagingCelllist->list.size);
11639    if(pagingCelllist->list.array == NULLP)
11640    {
11641       DU_LOG("\nERROR  -->  F1AP : BuildPagingCellList(): Memory allocation failed ");
11642       return RFAILED;
11643    }
11644
11645    for(cellIdx = 0; cellIdx < pagingCelllist->list.count; cellIdx++)
11646    {
11647       CU_ALLOC(pagingCelllist->list.array[cellIdx], sizeof(PagingCell_ItemIEs_t));
11648       if(pagingCelllist->list.array[cellIdx] == NULLP)
11649       {
11650          DU_LOG("\nERROR  -->  F1AP : BuildPagingCellList(): Memory allocation failed ");
11651          return RFAILED;
11652       }
11653    }
11654
11655    for(cellIdx = 0; cellIdx < pagingCelllist->list.count; cellIdx++)
11656    {
11657       pagingCellItemIes = (PagingCell_ItemIEs_t *)pagingCelllist->list.array[cellIdx];
11658       pagingCellItemIes->id =  ProtocolIE_ID_id_PagingCell_Item;
11659       pagingCellItemIes->criticality = Criticality_ignore;
11660       pagingCellItemIes->value.present = PagingCell_ItemIEs__value_PR_PagingCell_Item;
11661       pagingCellItem = &pagingCellItemIes->value.choice.PagingCell_Item;
11662
11663       /* Fill NrCgi Information */
11664       BuildNrcgi(&pagingCellItem->nRCGI, cellCb[cellIdx].nrCellId);
11665    }
11666
11667    return ROK;
11668 }
11669
11670 /*******************************************************************
11671  *
11672  * @brief Deallocation of memory allocated in paging msg
11673  *
11674  * @details
11675  *
11676  *    Function :FreePagingMsg
11677  *
11678  *    Functionality: Deallocation of memory allocated in paging msg
11679  *
11680  * @params[in] F1AP_PDU_t *f1apMsg
11681  *
11682  * @return void
11683  *
11684  * ****************************************************************/
11685 void FreePagingMsg(F1AP_PDU_t *f1apMsg)
11686 {
11687    uint8_t ieIdx, cellIdx;
11688    Paging_t   *paging;
11689    PagingCell_ItemIEs_t *pagingCellItemIes;
11690    PagingCell_Item_t *pagingCellItem;
11691    PagingCell_list_t  *pagingCelllist;
11692
11693    if(f1apMsg)
11694    {
11695       if(f1apMsg->choice.initiatingMessage)
11696       {
11697          paging = &f1apMsg->choice.initiatingMessage->value.choice.Paging;
11698          if(paging->protocolIEs.list.array)
11699          {
11700             for(ieIdx=0 ; ieIdx<paging->protocolIEs.list.count; ieIdx++)
11701             {
11702                if(paging->protocolIEs.list.array[ieIdx])
11703                {
11704                   switch(paging->protocolIEs.list.array[ieIdx]->id)
11705                   {
11706                      case ProtocolIE_ID_id_UEIdentityIndexValue:
11707                      {
11708                         CU_FREE(paging->protocolIEs.list.array[ieIdx]->value.choice.UEIdentityIndexValue.choice.indexLength10.buf,\
11709                         paging->protocolIEs.list.array[ieIdx]->value.choice.UEIdentityIndexValue.choice.indexLength10.size);
11710                         break;
11711                      }
11712
11713                      case ProtocolIE_ID_id_PagingIdentity:
11714                      {
11715                         if(paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.present == PagingIdentity_PR_cNUEPagingIdentity)
11716                         {
11717                            if(paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity)
11718                            {
11719                               if(paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity->present == CNUEPagingIdentity_PR_fiveG_S_TMSI)
11720                               {
11721                                  CU_FREE(paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity->choice.fiveG_S_TMSI.buf,\
11722                                  paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity->choice.fiveG_S_TMSI.size);
11723                               }
11724                                 CU_FREE(paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity,\
11725                                 sizeof(struct CNUEPagingIdentity));
11726                            }
11727                         }
11728                         break;
11729                      }
11730
11731                      case ProtocolIE_ID_id_PagingCell_List:
11732                      {
11733                         pagingCelllist = &paging->protocolIEs.list.array[ieIdx]->value.choice.PagingCell_list;
11734                         if(pagingCelllist->list.array)
11735                         {
11736                            for(cellIdx = 0; cellIdx < pagingCelllist->list.count; cellIdx++)
11737                            {
11738                               if(pagingCelllist->list.array[cellIdx])
11739                               {
11740                                   pagingCellItemIes = (PagingCell_ItemIEs_t *)pagingCelllist->list.array[cellIdx];
11741                                   if(pagingCellItemIes->id == ProtocolIE_ID_id_PagingCell_Item)
11742                                   {
11743                                      pagingCellItem = &pagingCellItemIes->value.choice.PagingCell_Item;
11744                                      CU_FREE(pagingCellItem->nRCGI.pLMN_Identity.buf, pagingCellItem->nRCGI.pLMN_Identity.size);
11745                                      CU_FREE(pagingCellItem->nRCGI.nRCellIdentity.buf, pagingCellItem->nRCGI.nRCellIdentity.size);
11746                                   }
11747                                   CU_FREE(pagingCelllist->list.array[cellIdx], sizeof(PagingCell_ItemIEs_t));
11748                               }
11749                            }
11750                            CU_FREE(pagingCelllist->list.array, pagingCelllist->list.size);
11751                         }
11752                         break;
11753                      }
11754                   }
11755                   CU_FREE(paging->protocolIEs.list.array[ieIdx], sizeof(Paging_t));
11756                }
11757             }
11758             CU_FREE(paging->protocolIEs.list.array, paging->protocolIEs.list.size);
11759          }
11760          CU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
11761       }
11762       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
11763    }
11764 }
11765 /*******************************************************************
11766  *
11767  * @brief Builds and sends the paging message if UE is in idle mode
11768  *
11769  * @details
11770  *
11771  *    Function : BuildAndSendPagingMsg
11772  *
11773  *    Functionality: Builds and sends the paging message
11774  *
11775  * @params[in] uint32_t duId, uint8_t gsTmsi
11776  *
11777  * @return ROK     - success
11778  *         RFAILED - failure
11779  *
11780  * ****************************************************************/
11781 uint8_t BuildAndSendPagingMsg(uint64_t gsTmsi, uint8_t duId)
11782 {
11783    bool       memAllocFailed = false;
11784    uint8_t    ieIdx = 0, elementCnt = 0, ret = RFAILED;
11785    uint16_t   ueId = 0, duIdx = 0;
11786
11787    /*As per 38.473 Sec 9.3.1.39, UE Identity Index Value (10bits) > 2 Bytes + 6 Unused Bits
11788     *5G-S-TMSI :48 Bits  >> 6 Bytes and 0 UnusedBits */
11789    uint8_t    totalByteInUeId = 2, totalByteInTmsi = 6;
11790    uint8_t    unusedBitsInUeId = 6, unusedBitsInTmsi = 0;
11791
11792    F1AP_PDU_t *f1apMsg = NULLP;
11793    Paging_t   *paging = NULLP;
11794    DuDb       *duDb;
11795    asn_enc_rval_t         encRetVal;
11796
11797    DU_LOG("\nINFO  -->  F1AP : Building PAGING Message command\n");
11798
11799    SEARCH_DU_DB(duIdx, duId, duDb);
11800    if(duDb == NULLP)
11801    {
11802       DU_LOG("\nERROR  -->  F1AP : BuildAndSendPagingMsg(): DuDb is empty");
11803       return ret;
11804    }
11805
11806    while(true)
11807    {
11808       CU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
11809       if(f1apMsg == NULLP)
11810       {
11811          DU_LOG("\nERROR  -->  F1AP : BuildAndSendPagingMsg(): Memory allocation for F1AP-PDU");
11812          break;
11813       }
11814
11815       f1apMsg->present =  F1AP_PDU_PR_initiatingMessage;
11816
11817       CU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
11818       if(f1apMsg->choice.initiatingMessage == NULLP)
11819       {
11820          DU_LOG("\nERROR  -->  F1AP : BuildAndSendPagingMsg(): Memory allocation for F1AP-PDU failed ");
11821          break;
11822       }
11823       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_Paging;
11824       f1apMsg->choice.initiatingMessage->criticality = Criticality_reject;
11825       f1apMsg->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_Paging;
11826
11827       paging = &f1apMsg->choice.initiatingMessage->value.choice.Paging;
11828
11829       elementCnt = 5;
11830       paging->protocolIEs.list.count = elementCnt;
11831       paging->protocolIEs.list.size = elementCnt * sizeof(Paging_t*);
11832
11833       /* Initialize the Paging Message members */
11834       CU_ALLOC(paging->protocolIEs.list.array, paging->protocolIEs.list.size);
11835       if(paging->protocolIEs.list.array == NULLP)
11836       {
11837          DU_LOG("\nERROR  -->  F1AP : BuildAndSendPagingMsg():Memory allocation failed");
11838          break;
11839       }
11840
11841       for(ieIdx=0 ; ieIdx<elementCnt; ieIdx++)
11842       {
11843          CU_ALLOC(paging->protocolIEs.list.array[ieIdx], sizeof(Paging_t));
11844          if(paging->protocolIEs.list.array[ieIdx] == NULLP)
11845          {
11846             DU_LOG("\nERROR  -->  F1AP : BuildAndSendPagingMsg(): Memory allocation failed ");
11847             memAllocFailed = true;
11848             break;
11849          }
11850       }
11851
11852       if(memAllocFailed == true)
11853       {
11854          break;
11855       }
11856
11857       /* UE Identity Index Value */
11858       ieIdx=0;
11859       paging->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_UEIdentityIndexValue;
11860       paging->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
11861       paging->protocolIEs.list.array[ieIdx]->value.present = PagingIEs__value_PR_UEIdentityIndexValue;
11862       paging->protocolIEs.list.array[ieIdx]->value.choice.UEIdentityIndexValue.present = UEIdentityIndexValue_PR_indexLength10;
11863       paging->protocolIEs.list.array[ieIdx]->value.choice.UEIdentityIndexValue.choice.indexLength10.size = totalByteInUeId*sizeof(uint8_t);
11864       CU_ALLOC(paging->protocolIEs.list.array[ieIdx]->value.choice.UEIdentityIndexValue.choice.indexLength10.buf,\
11865             paging->protocolIEs.list.array[ieIdx]->value.choice.UEIdentityIndexValue.choice.indexLength10.size);
11866       if(paging->protocolIEs.list.array[ieIdx]->value.choice.UEIdentityIndexValue.choice.indexLength10.buf == NULLP)
11867       {
11868          DU_LOG("\nERROR  -->  F1AP : BuildAndSendPagingMsg(): Memory allocation failed ");
11869          break;
11870       }
11871
11872       /*As per 3gpp Spec 38.304 Sec 7.1: UE_ID: 5G-S-TMSI mod 1024*/
11873       ueId = gsTmsi % 1024;
11874       fillBitString(&paging->protocolIEs.list.array[ieIdx]->value.choice.UEIdentityIndexValue.choice.indexLength10, unusedBitsInUeId, totalByteInUeId, ueId);
11875
11876       /* Paging Identity */
11877       ieIdx++;
11878       paging->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_PagingIdentity;
11879       paging->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
11880       paging->protocolIEs.list.array[ieIdx]->value.present = PagingIEs__value_PR_PagingIdentity;
11881       paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.present = \
11882                                                                                    PagingIdentity_PR_cNUEPagingIdentity;
11883       CU_ALLOC(paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity, \
11884             sizeof(struct CNUEPagingIdentity));
11885       if(!paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity)
11886       {
11887          DU_LOG("\nERROR  -->  F1AP : BuildAndSendPagingMsg(): Memory allocation failed ");
11888          break;
11889       }
11890
11891       paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity->present = \
11892                                                                                                               CNUEPagingIdentity_PR_fiveG_S_TMSI;
11893
11894       paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity->choice.fiveG_S_TMSI.size = totalByteInTmsi*sizeof(uint8_t);
11895       CU_ALLOC(paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity->choice.fiveG_S_TMSI.buf,\
11896             paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity->choice.fiveG_S_TMSI.size);
11897       if(!paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity->choice.fiveG_S_TMSI.buf)
11898       {
11899          DU_LOG("\nERROR  -->  F1AP : BuildAndSendPagingMsg(): Memory allocation failed ");
11900          break;
11901       }
11902
11903       fillBitString(&paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity->choice.fiveG_S_TMSI,\
11904             unusedBitsInTmsi, totalByteInTmsi, gsTmsi);
11905
11906       /* Paging Drx */
11907       ieIdx++;
11908       paging->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_PagingDRX;
11909       paging->protocolIEs.list.array[ieIdx]->criticality = Criticality_ignore;
11910       paging->protocolIEs.list.array[ieIdx]->value.present = PagingIEs__value_PR_PagingDRX;
11911       paging->protocolIEs.list.array[ieIdx]->value.choice.PagingDRX = PagingDRX_v32;
11912
11913       /* Paging Priority */
11914       ieIdx++;
11915       paging->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_PagingPriority;
11916       paging->protocolIEs.list.array[ieIdx]->criticality = Criticality_ignore;
11917       paging->protocolIEs.list.array[ieIdx]->value.present = PagingIEs__value_PR_PagingPriority;
11918       paging->protocolIEs.list.array[ieIdx]->value.choice.PagingPriority = PagingPriority_priolevel2;
11919
11920       /* Paging Cell List */
11921       ieIdx++;
11922       paging->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_PagingCell_List;
11923       paging->protocolIEs.list.array[ieIdx]->criticality = Criticality_ignore;
11924       paging->protocolIEs.list.array[ieIdx]->value.present = PagingIEs__value_PR_PagingCell_list;
11925       if(BuildPagingCellList(&paging->protocolIEs.list.array[ieIdx]->value.choice.PagingCell_list, duDb->numCells, duDb->cellCb) != ROK)
11926       {
11927          DU_LOG("\nERROR  -->  F1AP : BuildAndSendPagingMsg(): Failed to build Paging cell list ");
11928          break;
11929       }
11930
11931       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
11932
11933       /* Encode the UE Context Release Command type as APER */
11934       memset(encBuf, 0, ENC_BUF_MAX_LEN);
11935       encBufSize = 0;
11936       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
11937             encBuf);
11938
11939       /* Encode results */
11940       if(encRetVal.encoded == ENCODE_FAIL)
11941       {
11942          DU_LOG("\nERROR  -->  F1AP : Could not encode Release Command structure (at %s)\n",\
11943                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
11944          break;
11945       }
11946       else
11947       {
11948          DU_LOG("\nDEBUG  -->  F1AP : Created APER encoded buffer for Paging\n");
11949          for(ieIdx=0; ieIdx< encBufSize; ieIdx++)
11950          {
11951             DU_LOG("%x",encBuf[ieIdx]);
11952          }
11953       }
11954
11955       if(SendF1APMsg(CU_APP_MEM_REG, CU_POOL, duId) != ROK)
11956       {
11957          DU_LOG("\nERROR  -->  F1AP : Sending Ue context Release Command failed");
11958          break;
11959       }
11960
11961       ret = ROK;
11962       break;
11963
11964    }
11965
11966    FreePagingMsg(f1apMsg);
11967    return ret;
11968 }
11969
11970 /*******************************************************************
11971  *
11972  * @brief Handles received F1AP message and sends back response
11973  *
11974  * @details
11975  *
11976  *    Function : F1APMsgHdlr
11977  *
11978  *    Functionality:
11979  *         - Decodes received F1AP control message
11980  *         - Prepares response message, encodes and sends to SCTP
11981  *
11982  * @params[in]
11983  * @return ROK     - success
11984  *         RFAILED - failure
11985  *
11986  * ****************************************************************/
11987 void F1APMsgHdlr(uint32_t *duId, Buffer *mBuf)
11988 {
11989    int i;
11990    char *recvBuf;
11991    MsgLen copyCnt;
11992    MsgLen recvBufLen;
11993    F1AP_PDU_t *f1apMsg = NULLP;
11994    asn_dec_rval_t rval; /* Decoder return value */
11995    F1AP_PDU_t f1apasnmsg ;
11996
11997    DU_LOG("\nINFO  -->  F1AP : Received F1AP message buffer");
11998    ODU_PRINT_MSG(mBuf, 0,0);
11999
12000    /* Copy mBuf into char array to decode it */
12001    ODU_GET_MSG_LEN(mBuf, &recvBufLen);
12002    CU_ALLOC(recvBuf, (Size)recvBufLen);
12003
12004    if(recvBuf == NULLP)
12005    {
12006       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed");
12007       return;
12008    }
12009    if(ODU_COPY_MSG_TO_FIX_BUF(mBuf, 0, recvBufLen, (Data *)recvBuf, &copyCnt) != ROK)
12010    {
12011       DU_LOG("\nERROR  -->  F1AP : Failed while copying %d", copyCnt);
12012       return;
12013    }
12014
12015    DU_LOG("\nDEBUG  -->  F1AP : Received flat buffer to be decoded : ");
12016    for(i=0; i< recvBufLen; i++)
12017    {
12018       DU_LOG("%x",recvBuf[i]);
12019    }
12020
12021    /* Decoding flat buffer into F1AP messsage */
12022    f1apMsg = &f1apasnmsg;
12023    memset(f1apMsg, 0, sizeof(F1AP_PDU_t));
12024
12025    rval = aper_decode(0, &asn_DEF_F1AP_PDU, (void **)&f1apMsg, recvBuf, recvBufLen, 0, 0);
12026    CU_FREE(recvBuf, (Size)recvBufLen);
12027
12028    if(rval.code == RC_FAIL || rval.code == RC_WMORE)
12029    {
12030       DU_LOG("\nERROR  -->  F1AP : ASN decode failed");
12031       return;
12032    }
12033    DU_LOG("\n");
12034    xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
12035
12036    switch(f1apMsg->present)
12037    {
12038       case F1AP_PDU_PR_initiatingMessage:
12039          {
12040             switch(f1apMsg->choice.initiatingMessage->value.present)
12041             {
12042                case InitiatingMessage__value_PR_Reset:
12043                   {
12044                      DU_LOG("\nINFO  -->  F1AP : F1 reset request received ");
12045                      BuildAndSendF1ResetAck();
12046                      break;
12047                   }
12048
12049                case InitiatingMessage__value_PR_F1SetupRequest:
12050                   {
12051                      DU_LOG("\nINFO  -->  F1AP : F1 setup request received");
12052                      procF1SetupReq(duId, f1apMsg);
12053                      break;
12054                   }
12055
12056                case InitiatingMessage__value_PR_GNBDUConfigurationUpdate:
12057                   {
12058                      DU_LOG("\nINFO  -->  F1AP : GNB-DU config update received");
12059                      procGnbDuUpdate(*duId, f1apMsg);
12060                      break;
12061                   }
12062                case InitiatingMessage__value_PR_InitialULRRCMessageTransfer:
12063                   {
12064                      DU_LOG("\nINFO  -->  F1AP : Received InitialULRRCMessageTransfer");
12065                      procInitULRRCMsg(*duId, f1apMsg);
12066                      break;
12067                   }
12068                case InitiatingMessage__value_PR_ULRRCMessageTransfer:
12069                   {
12070                      DU_LOG("\nINFO  -->  F1AP : Received ULRRCMessageTransfer");
12071                      procUlRrcMsg(*duId, f1apMsg);
12072                      break;
12073                   }
12074
12075                case InitiatingMessage__value_PR_RRCDeliveryReport:
12076                   {
12077                      DU_LOG("\nINFO  -->  F1AP : Received RRC delivery report");
12078                      break;
12079                   }
12080                case InitiatingMessage__value_PR_UEContextReleaseRequest:
12081                   {
12082                      DU_LOG("\nINFO  -->  F1AP : Received UE Context Release Request");
12083                      procUeContextReleaseReq(*duId, f1apMsg);
12084                      break;
12085                   }
12086                default:
12087                   {
12088                      DU_LOG("\nERROR  -->  F1AP : Invalid type of intiating message [%d]",\
12089                            f1apMsg->choice.initiatingMessage->value.present);
12090                      return;
12091                   }
12092             }/* End of switch(initiatingMessage) */
12093             break;
12094          }
12095
12096       case F1AP_PDU_PR_successfulOutcome:
12097          {
12098             switch(f1apMsg->choice.successfulOutcome->value.present)
12099             {
12100                case SuccessfulOutcome__value_PR_ResetAcknowledge:
12101                   {
12102                      DU_LOG("\nINFO  -->  F1Reset Acknowledgement is received successfully ");
12103                      break;
12104                   }
12105                case SuccessfulOutcome__value_PR_UEContextSetupResponse:
12106                   {
12107                      DU_LOG("\nINFO  -->  F1AP : UE ContextSetupResponse received");
12108                      procUeContextSetupResponse(*duId, f1apMsg);
12109                      break;
12110                   }
12111                case SuccessfulOutcome__value_PR_UEContextModificationResponse:
12112                   {
12113                      DU_LOG("\nINFO  -->  F1AP : UE Context Modification Response received");
12114                      procUeContextModificationResponse(*duId, f1apMsg);
12115                      break;
12116                   }
12117                case SuccessfulOutcome__value_PR_UEContextReleaseComplete:
12118                   {
12119                       DU_LOG("\nINFO  -->  F1AP : UE Context release complete received");
12120                       procUeContextReleaseComplete(*duId, f1apMsg);
12121                       break;
12122                   }
12123                default:
12124                   {
12125                      DU_LOG("\nERROR  -->  F1AP : Invalid type of successful outcome message [%d]",\
12126                            f1apMsg->choice.successfulOutcome->value.present);
12127                      return;
12128                   }
12129             }/* End of switch(successfulOutcome) */
12130             break;
12131          }
12132       default:
12133          {
12134             DU_LOG("\nERROR  -->  F1AP : Invalid type of f1apMsg->present [%d]",f1apMsg->present);
12135             return;
12136          }
12137    }/* End of switch(f1apMsg->present) */
12138
12139 } /* End of F1APMsgHdlr */
12140
12141 /**********************************************************************
12142   End of file
12143  **********************************************************************/