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
 131 #include "cu_stub_sctp.h"
 132 #include "cu_stub_egtp.h"
 133 #include "cu_f1ap_msg_hdl.h"
 134 #include "cu_stub.h"
 135
 136 uint8_t fillCellGrpCfg(CuUeCb *ueCb, OCTET_STRING_t *cellGrp, bool updateAllRbCfg);
 137 uint8_t fillRrcReconfig(CuUeCb *ueCb, RRCReconfiguration_t *rrcReconfig, bool updateAllRbCfg);
 138
 139 /*******************************************************************
 140  *
 141  * @brief Sends F1 msg over SCTP
 142  *
 143  * @details
 144  *
 145  *    Function : SendF1APMsg
 146  *
 147  *    Functionality: Sends F1 msg over SCTP
 148  *
 149  * @params[in] Region region
 150  *             Pool pool
 151  * @return ROK     - success
 152  *         RFAILED - failure
 153  *
 154  * ****************************************************************/
 155 S16 SendF1APMsg(Region region, Pool pool, uint32_t duId)
 156 {
 157    Buffer *mBuf = NULLP;
 158
 159    if(ODU_GET_MSG_BUF(region, pool, &mBuf) == ROK)
 160    {
 161       if(ODU_ADD_POST_MSG_MULT((Data *)encBuf, encBufSize, mBuf) == ROK)
 162       {
 163          ODU_PRINT_MSG(mBuf, 0,0);
 164
 165          if(sctpSend(duId, mBuf) != ROK)
 166          {
 167             DU_LOG("\nERROR  -->  F1AP : SCTP Send failed");
 168             ODU_PUT_MSG_BUF(mBuf);
 169             return RFAILED;
 170          }
 171       }
 172       else
 173       {
 174          DU_LOG("\nERROR  -->  F1AP : ODU_ADD_POST_MSG_MULT failed");
 175          ODU_PUT_MSG_BUF(mBuf);
 176          return RFAILED;
 177       }
 178       ODU_PUT_MSG_BUF(mBuf);
 179    }
 180    else
 181    {
 182       DU_LOG("\nERROR  -->  F1AP : Failed to allocate memory");
 183       return RFAILED;
 184    }
 185
 186    return ROK;
 187 } /* SendF1APMsg */
 188
 189 /*******************************************************************
 190  *
 191  * @brief Builds NRCell ID
 192  *
 193  * @details
 194  *
 195  *    Function : BuildNrCellId
 196  *
 197  *    Functionality: Building the NR Cell ID
 198  *
 199  * @params[in] BIT_STRING_t *nrcell
 200  * @return ROK     - success
 201  *         RFAILED - failure
 202  *
 203  * ****************************************************************/
 204
 205 S16 BuildNrCellId(BIT_STRING_t *nrcell)
 206 {
 207    memset(nrcell->buf, 0, nrcell->size);
 208    nrcell->buf[4]   = 16;
 209    nrcell->bits_unused = 4;
 210    nrcell->size = 5 * sizeof(uint8_t);
 211    return ROK;
 212 }
 213
 214 /********************************************************************
 215  *
 216  * @brief Builds and sends the F1SetupResponse
 217  *
 218  * @details
 219  *
 220  *    Function : BuildAndSendF1SetupRsp
 221  *
 222  *    Functionality: Constructs the F1SetupResponse message and sends
 223  *                   it back to the DU through SCTP.
 224  *
 225  * @params[in] void **buf,Buffer to which encoded pattern is written into
 226  * @params[in] int *size,size of buffer
 227  *
 228  * @return ROK     - success
 229  *         RFAILED - failure
 230  *
 231  * ****************************************************************/
 232 uint8_t BuildAndSendF1SetupRsp(uint32_t duId, BIT_STRING_t *nrcellId)
 233 {
 234    uint8_t    idx,ieIdx;
 235    uint8_t    elementCnt,cellCnt;
 236    F1AP_PDU_t         *f1apMsg = NULL;
 237    F1SetupResponse_t  *f1SetupRsp;
 238    GNB_CU_Name_t      *cuName;
 239    Cells_to_be_Activated_List_t *cellToActivate;
 240    RRC_Version_t      *rrcVer;
 241    asn_enc_rval_t     encRetVal;
 242    DU_LOG("\nINFO  -->  F1AP : Building F1 Setup Response\n");
 243
 244    /* Allocate the memory for F1SetupRequest_t */
 245    CU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
 246    if(f1apMsg == NULLP)
 247    {
 248       DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
 249       return RFAILED;
 250    }
 251    f1apMsg->present =  F1AP_PDU_PR_successfulOutcome;
 252
 253    CU_ALLOC(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 254    if(f1apMsg->choice.successfulOutcome == NULLP)
 255    {
 256       DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
 257       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 258       return RFAILED;
 259    }
 260
 261    f1apMsg->choice.successfulOutcome->procedureCode = ProcedureCode_id_F1Setup;
 262    f1apMsg->choice.successfulOutcome->criticality = Criticality_reject;
 263    f1apMsg->choice.successfulOutcome->value.present = \
 264                                                       SuccessfulOutcome__value_PR_F1SetupResponse;
 265    f1SetupRsp = &f1apMsg->choice.successfulOutcome->value.choice.F1SetupResponse;
 266
 267    elementCnt = 4;
 268    f1SetupRsp->protocolIEs.list.count = elementCnt;
 269    f1SetupRsp->protocolIEs.list.size = elementCnt*sizeof(F1SetupResponseIEs_t *);
 270
 271    CU_ALLOC(f1SetupRsp->protocolIEs.list.array, \
 272          elementCnt * sizeof(F1SetupResponseIEs_t *));
 273    if(f1SetupRsp->protocolIEs.list.array == NULLP)
 274    {
 275       DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1ResponseIEs failed");
 276       CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 277       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 278       return RFAILED;
 279    }
 280
 281    for(idx=0; idx<elementCnt; idx++)
 282    {
 283       CU_ALLOC(f1SetupRsp->protocolIEs.list.array[idx], \
 284             sizeof(F1SetupResponseIEs_t));
 285       if(f1SetupRsp->protocolIEs.list.array[idx] == NULLP)
 286       {
 287          CU_FREE(f1SetupRsp->protocolIEs.list.array,\
 288                elementCnt * sizeof(F1SetupResponseIEs_t *));
 289          CU_FREE(f1apMsg->choice.successfulOutcome, \
 290                sizeof(SuccessfulOutcome_t));
 291          CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 292          return RFAILED;
 293       }
 294    }
 295
 296    /*TransactionID*/
 297    idx = 0;
 298    f1SetupRsp->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_TransactionID;
 299    f1SetupRsp->protocolIEs.list.array[idx]->criticality = Criticality_reject;
 300    f1SetupRsp->protocolIEs.list.array[idx]->value.present = \
 301                                                             F1SetupResponseIEs__value_PR_TransactionID;
 302    f1SetupRsp->protocolIEs.list.array[idx]->value.choice.TransactionID =\
 303                                                                         TRANS_ID;
 304
 305    /*CU Name*/
 306    idx++;
 307    f1SetupRsp->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_gNB_CU_Name;
 308    f1SetupRsp->protocolIEs.list.array[idx]->criticality = Criticality_ignore;
 309    f1SetupRsp->protocolIEs.list.array[idx]->value.present = \
 310                                                             F1SetupResponseIEs__value_PR_GNB_CU_Name;
 311    cuName = &f1SetupRsp->protocolIEs.list.array[idx]->value.choice.GNB_CU_Name;
 312    cuName->size = sizeof(cuCb.cuCfgParams.cuName);
 313
 314    CU_ALLOC(cuName->buf, sizeof(cuName->size));
 315    if(cuName->buf == NULLP)
 316    {
 317       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
 318       {
 319          CU_FREE(f1SetupRsp->protocolIEs.list.array[ieIdx],\
 320                sizeof(F1SetupResponseIEs_t));
 321       }
 322       CU_FREE(f1SetupRsp->protocolIEs.list.array,\
 323             elementCnt * sizeof(F1SetupResponseIEs_t *));
 324       CU_FREE(f1apMsg->choice.successfulOutcome,\
 325             sizeof(SuccessfulOutcome_t));
 326       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 327       return RFAILED;
 328    }
 329    strcpy((char*)cuName->buf, (char*)cuCb.cuCfgParams.cuName);
 330
 331    /*Cells to be activated list*/
 332    idx++;
 333    f1SetupRsp->protocolIEs.list.array[idx]->id = \
 334                                                  ProtocolIE_ID_id_Cells_to_be_Activated_List ;
 335    f1SetupRsp->protocolIEs.list.array[idx]->criticality = Criticality_reject;
 336    f1SetupRsp->protocolIEs.list.array[idx]->value.present = \
 337                                                             F1SetupResponseIEs__value_PR_Cells_to_be_Activated_List;
 338    cellToActivate = &f1SetupRsp->protocolIEs.list.array[idx]->value.choice.\
 339                     Cells_to_be_Activated_List;
 340    cellCnt=1;
 341    cellToActivate->list.count = cellCnt;
 342    cellToActivate->list.size = \
 343                                cellCnt*sizeof(struct Cells_to_be_Activated_List_ItemIEs  *);
 344    CU_ALLOC(cellToActivate->list.array,\
 345          sizeof(struct Cells_to_be_Activated_List_ItemIEs  *));
 346    if(cellToActivate->list.array == NULLP)
 347    {
 348       CU_FREE(cuName->buf, sizeof(cuName->size));
 349       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
 350       {
 351          CU_FREE(f1SetupRsp->protocolIEs.list.array[ieIdx],\
 352                sizeof(F1SetupResponseIEs_t));
 353       }
 354       CU_FREE(f1SetupRsp->protocolIEs.list.array,\
 355             elementCnt * sizeof(F1SetupResponseIEs_t *));
 356       CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 357       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 358       return RFAILED;
 359    }
 360    for(ieIdx=0; ieIdx<cellCnt; ieIdx++)
 361    {
 362       CU_ALLOC(cellToActivate->list.array[ieIdx],sizeof(struct Cells_to_be_Activated_List_ItemIEs ));
 363       if(cellToActivate->list.array[ieIdx] == NULLP)
 364       {
 365          CU_FREE(cellToActivate->list.array,\
 366                sizeof(struct Cells_to_be_Activated_List_ItemIEs  *));
 367          CU_FREE(cuName->buf, sizeof(cuName->size));
 368          for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
 369          {
 370             CU_FREE(f1SetupRsp->protocolIEs.list.array[ieIdx], \
 371                   sizeof(F1SetupResponseIEs_t));
 372          }
 373          CU_FREE(f1SetupRsp->protocolIEs.list.array, \
 374                elementCnt * sizeof(F1SetupResponseIEs_t *));
 375          CU_FREE(f1apMsg->choice.successfulOutcome, \
 376                sizeof(SuccessfulOutcome_t));
 377          CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 378          return RFAILED;
 379       }
 380    }
 381    cellToActivate->list.array[0]->id = \
 382                                        ProtocolIE_ID_id_Cells_to_be_Activated_List_Item;
 383    cellToActivate->list.array[0]->criticality = Criticality_ignore;
 384    cellToActivate->list.array[0]->value.present = \
 385                                                   Cells_to_be_Activated_List_ItemIEs__value_PR_Cells_to_be_Activated_List_Item;
 386    cellToActivate->list.array[0]->value.choice.Cells_to_be_Activated_List_Item.\
 387       nRCGI.pLMN_Identity.size = 3*sizeof(uint8_t);
 388    CU_ALLOC(cellToActivate->list.array[0]->\
 389          value.choice.Cells_to_be_Activated_List_Item.nRCGI.pLMN_Identity.buf,\
 390          3*sizeof(uint8_t));
 391    if(cellToActivate->list.array[0]->value.choice.\
 392          Cells_to_be_Activated_List_Item.nRCGI.pLMN_Identity.buf == NULLP)
 393    {
 394
 395       for(ieIdx=0; ieIdx<cellCnt; ieIdx++)
 396       {
 397          CU_FREE(cellToActivate->list.array[ieIdx],\
 398                sizeof(struct Cells_to_be_Activated_List_ItemIEs ));
 399       }
 400
 401       CU_FREE(cellToActivate->list.array,\
 402             sizeof(struct Cells_to_be_Activated_List_ItemIEs  *));
 403       CU_FREE(cuName->buf, sizeof(cuName->size));
 404       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
 405       {
 406          CU_FREE(f1SetupRsp->protocolIEs.list.array[ieIdx], \
 407                sizeof(F1SetupResponseIEs_t));
 408       }
 409       CU_FREE(f1SetupRsp->protocolIEs.list.array, \
 410             elementCnt * sizeof(F1SetupResponseIEs_t *));
 411       CU_FREE(f1apMsg->choice.successfulOutcome, \
 412             sizeof(SuccessfulOutcome_t));
 413       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 414       return RFAILED;
 415    }
 416    buildPlmnId(cuCb.cuCfgParams.plmn , cellToActivate->list.array[0]->value.choice.\
 417          Cells_to_be_Activated_List_Item.nRCGI.pLMN_Identity.buf);
 418    cellToActivate->list.array[0]->value.choice.Cells_to_be_Activated_List_Item.\
 419       nRCGI.nRCellIdentity.size = 5;
 420    CU_ALLOC(cellToActivate->list.array[0]->value.choice.\
 421          Cells_to_be_Activated_List_Item.nRCGI.nRCellIdentity.buf,\
 422          5*sizeof(uint8_t));
 423    if(cellToActivate->list.array[0]->value.choice.\
 424          Cells_to_be_Activated_List_Item.nRCGI.nRCellIdentity.buf == NULLP)
 425    {
 426       CU_FREE(cellToActivate->list.array[0]->\
 427             value.choice.Cells_to_be_Activated_List_Item.nRCGI.pLMN_Identity.buf,\
 428             3*sizeof(uint8_t));
 429       for(ieIdx=0; ieIdx<cellCnt; ieIdx++)
 430       {
 431          CU_FREE(cellToActivate->list.array[ieIdx],\
 432                sizeof(struct Cells_to_be_Activated_List_ItemIEs ));
 433       }
 434
 435       CU_FREE(cellToActivate->list.array,\
 436             sizeof(struct Cells_to_be_Activated_List_ItemIEs  *));
 437       CU_FREE(cuName->buf, sizeof(cuName->size));
 438       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
 439       {
 440          CU_FREE(f1SetupRsp->protocolIEs.list.array[ieIdx], \
 441                sizeof(F1SetupResponseIEs_t));
 442       }
 443       CU_FREE(f1SetupRsp->protocolIEs.list.array, \
 444             elementCnt * sizeof(F1SetupResponseIEs_t *));
 445       CU_FREE(f1apMsg->choice.successfulOutcome, \
 446             sizeof(SuccessfulOutcome_t));
 447       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 448       return RFAILED;
 449    }
 450    memcpy(&cellToActivate->list.array[0]->value.choice.Cells_to_be_Activated_List_Item.nRCGI.nRCellIdentity, nrcellId, sizeof(BIT_STRING_t));
 451    /* RRC Version */
 452    idx++;
 453    f1SetupRsp->protocolIEs.list.array[idx]->id = \
 454                                                  ProtocolIE_ID_id_GNB_CU_RRC_Version;
 455    f1SetupRsp->protocolIEs.list.array[idx]->criticality = Criticality_reject;
 456    f1SetupRsp->protocolIEs.list.array[idx]->value.present = \
 457                                                             F1SetupResponseIEs__value_PR_RRC_Version;
 458    rrcVer = &f1SetupRsp->protocolIEs.list.array[idx]->value.choice.RRC_Version;
 459    rrcVer->latest_RRC_Version.size = RRC_SIZE;
 460
 461    CU_ALLOC(rrcVer->latest_RRC_Version.buf, sizeof(uint8_t));
 462    if(rrcVer->latest_RRC_Version.buf == NULLP)
 463    {
 464       CU_FREE(cuName->buf, sizeof(cuName->size));
 465       for(ieIdx=0; ieIdx<elementCnt; idx++)
 466       {
 467          CU_FREE(f1SetupRsp->protocolIEs.list.array[ieIdx], \
 468                sizeof(F1SetupResponseIEs_t));
 469       }
 470       CU_FREE(f1SetupRsp->protocolIEs.list.array,\
 471             elementCnt * sizeof(F1SetupResponseIEs_t *));
 472       CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 473       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 474       return RFAILED;
 475    }
 476
 477    /* Need to check RRC Version */
 478    rrcVer->latest_RRC_Version.buf[0] = cuCb.cuCfgParams.rrcVersion.rrcVer;
 479    rrcVer->latest_RRC_Version.bits_unused = 5; //TODO: pick from cuCfgParam. If not present, add it
 480    CU_ALLOC(rrcVer->iE_Extensions,sizeof(ProtocolExtensionContainer_4624P81_t));
 481    if(rrcVer->iE_Extensions == NULLP)
 482    {
 483       CU_FREE(rrcVer->latest_RRC_Version.buf, sizeof(uint8_t));
 484       CU_FREE(cuName->buf, sizeof(cuName->size));
 485       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
 486       {
 487          CU_FREE(f1SetupRsp->protocolIEs.list.array[ieIdx], \
 488                sizeof(F1SetupResponseIEs_t));
 489       }
 490       CU_FREE(f1SetupRsp->protocolIEs.list.array,\
 491             elementCnt * sizeof(F1SetupResponseIEs_t *));
 492       CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 493       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 494       return RFAILED;
 495    }
 496    rrcVer->iE_Extensions->list.count = 1;
 497    rrcVer->iE_Extensions->list.size = sizeof(struct RRC_Version_ExtIEs *);
 498    CU_ALLOC(rrcVer->iE_Extensions->list.array,\
 499          sizeof(struct RRC_Version_ExtIEs *));
 500    if(rrcVer->iE_Extensions->list.array == NULLP)
 501    {
 502       CU_FREE(rrcVer->iE_Extensions,\
 503             sizeof(ProtocolExtensionContainer_4624P81_t));
 504       CU_FREE(rrcVer->latest_RRC_Version.buf, sizeof(uint8_t));
 505       CU_FREE(cuName->buf, sizeof(cuName->size));
 506       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
 507       {
 508          CU_FREE(f1SetupRsp->protocolIEs.list.array[ieIdx], \
 509                sizeof(F1SetupResponseIEs_t));
 510       }
 511       CU_FREE(f1SetupRsp->protocolIEs.list.array,\
 512             elementCnt * sizeof(F1SetupResponseIEs_t *));
 513       CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 514       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 515       return RFAILED;
 516    }
 517    CU_ALLOC(rrcVer->iE_Extensions->list.array[0],\
 518          sizeof(struct RRC_Version_ExtIEs));
 519    if(rrcVer->iE_Extensions->list.array[0] == NULLP)
 520    {
 521       CU_FREE(rrcVer->iE_Extensions->list.array,\
 522             sizeof(struct RRC_Version_ExtIEs *));
 523       CU_FREE(rrcVer->iE_Extensions,\
 524             sizeof(ProtocolExtensionContainer_4624P81_t));
 525       CU_FREE(rrcVer->latest_RRC_Version.buf, sizeof(uint8_t));
 526       CU_FREE(cuName->buf, sizeof(cuName->size));
 527       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
 528       {
 529          CU_FREE(f1SetupRsp->protocolIEs.list.array[ieIdx], \
 530                sizeof(F1SetupResponseIEs_t));
 531       }
 532       CU_FREE(f1SetupRsp->protocolIEs.list.array,\
 533             elementCnt * sizeof(F1SetupResponseIEs_t *));
 534       CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 535       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 536       return RFAILED;
 537    }
 538    rrcVer->iE_Extensions->list.array[0]->id = \
 539                                               ProtocolIE_ID_id_latest_RRC_Version_Enhanced;
 540    rrcVer->iE_Extensions->list.array[0]->criticality = Criticality_reject;
 541    rrcVer->iE_Extensions->list.array[0]->extensionValue.present = \
 542                                                                   RRC_Version_ExtIEs__extensionValue_PR_Latest_RRC_Version_Enhanced;
 543    rrcVer->iE_Extensions->list.array[0]->extensionValue.choice.\
 544       Latest_RRC_Version_Enhanced.size = 3*sizeof(uint8_t);
 545    CU_ALLOC(rrcVer->iE_Extensions->list.\
 546          array[0]->extensionValue.choice.Latest_RRC_Version_Enhanced.buf,\
 547          3*sizeof(uint8_t));
 548    if(rrcVer->iE_Extensions->list.\
 549          array[0]->extensionValue.choice.Latest_RRC_Version_Enhanced.buf == NULLP)
 550    {
 551       CU_FREE(rrcVer->iE_Extensions->list.array[0],\
 552             sizeof(struct RRC_Version_ExtIEs));
 553       CU_FREE(rrcVer->iE_Extensions->list.array,\
 554             sizeof(struct RRC_Version_ExtIEs *));
 555       CU_FREE(rrcVer->iE_Extensions,\
 556             sizeof(ProtocolExtensionContainer_4624P81_t));
 557       CU_FREE(rrcVer->latest_RRC_Version.buf, sizeof(uint8_t));
 558       CU_FREE(cuName->buf, sizeof(cuName->size));
 559       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
 560       {
 561          CU_FREE(f1SetupRsp->protocolIEs.list.array[ieIdx], \
 562                sizeof(F1SetupResponseIEs_t));
 563       }
 564       CU_FREE(f1SetupRsp->protocolIEs.list.array,\
 565             elementCnt * sizeof(F1SetupResponseIEs_t *));
 566       CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 567       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 568       return RFAILED;
 569    }
 570    rrcVer->iE_Extensions->list.array[0]->extensionValue.choice.\
 571       Latest_RRC_Version_Enhanced.buf[0] = 0;
 572    rrcVer->iE_Extensions->list.array[0]->extensionValue.choice.\
 573       Latest_RRC_Version_Enhanced.buf[1] = 5;
 574    rrcVer->iE_Extensions->list.array[0]->extensionValue.choice.\
 575       Latest_RRC_Version_Enhanced.buf[2] = 15;
 576
 577    xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
 578
 579    /* Encode the F1SetupRequest type as UPER */
 580    memset(encBuf, 0, ENC_BUF_MAX_LEN);
 581    encBufSize = 0;
 582    encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
 583
 584    /* Clean up */
 585    CU_FREE(rrcVer->latest_RRC_Version.buf, sizeof(uint8_t));
 586    CU_FREE(cuName->buf, sizeof(cuName->size));
 587    for(idx=0; idx<elementCnt; idx++)
 588    {
 589       CU_FREE(f1SetupRsp->protocolIEs.list.array[idx], sizeof(F1SetupResponseIEs_t));
 590    }
 591    CU_FREE(f1SetupRsp->protocolIEs.list.array, elementCnt * sizeof(F1SetupResponseIEs_t *));
 592    CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 593    CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 594
 595    /* Check encode results */
 596    if(encRetVal.encoded == ENCODE_FAIL)
 597    {
 598       DU_LOG("\nERROR  -->  F1AP : Could not encode F1SetupResponse structure (at %s)\n",\
 599             encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
 600       return RFAILED;
 601    }
 602    else
 603    {
 604       DU_LOG("\nDEBUG  -->  F1AP : Created APER encoded buffer for F1SetupResponse\n");
 605       for(int i=0; i< encBufSize; i++)
 606       {
 607          DU_LOG("%x",encBuf[i]);
 608       }
 609    }
 610
 611    /* Sending msg */
 612    if(SendF1APMsg(CU_APP_MEM_REG, CU_POOL, duId) != ROK)
 613    {
 614       DU_LOG("\nERROR  -->  F1AP : Sending F1 Setup Response failed");
 615       return RFAILED;
 616    }
 617
 618    return ROK;
 619 }/* End of BuildAndSendF1SetupRsp */
 620
 621 /*******************************************************************
 622  *
 623  * @brief Builds and sends the DUUpdateAcknowledge
 624  *
 625  * @details
 626  *
 627  *    Function : BuildAndSendDUUpdateAck
 628  *
 629  *    Functionality: Constructs the DU Update Acknowledge message and sends
 630  *                   it to the DU through SCTP.
 631  *
 632  * @params[in]
 633  *
 634  * @return ROK     - success
 635  *         RFAILED - failure
 636  *
 637  * ****************************************************************/
 638
 639 uint8_t BuildAndSendDUUpdateAck(uint32_t duId)
 640 {
 641    uint8_t   idx;
 642    uint8_t   elementCnt;
 643    F1AP_PDU_t *f1apMsg = NULL;
 644    GNBDUConfigurationUpdateAcknowledge_t *gNBDuCfgAck;
 645    asn_enc_rval_t enRetVal; /* Encoder return value */
 646
 647    DU_LOG("\nINFO  -->  F1AP : Building GNB-DU Config Update Ack\n");
 648
 649    /* Allocate the memory for F1SetupRequest_t */
 650    CU_ALLOC(f1apMsg, (Size)sizeof(F1AP_PDU_t));
 651    if(f1apMsg == NULLP)
 652    {
 653       DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
 654       return RFAILED;
 655    }
 656
 657    f1apMsg->present =  F1AP_PDU_PR_successfulOutcome;
 658
 659    CU_ALLOC(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 660    if(f1apMsg->choice.successfulOutcome == NULLP)
 661    {
 662       DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
 663       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 664       return RFAILED;
 665    }
 666
 667    f1apMsg->choice.successfulOutcome->procedureCode = ProcedureCode_id_gNBDUConfigurationUpdate;
 668    f1apMsg->choice.successfulOutcome->criticality = Criticality_reject;
 669    f1apMsg->choice.successfulOutcome->value.present = SuccessfulOutcome__value_PR_GNBDUConfigurationUpdateAcknowledge;
 670    gNBDuCfgAck = &f1apMsg->choice.successfulOutcome->value.choice.GNBDUConfigurationUpdateAcknowledge;
 671
 672    elementCnt = 1;
 673    gNBDuCfgAck->protocolIEs.list.count = elementCnt;
 674    gNBDuCfgAck->protocolIEs.list.size = elementCnt*sizeof(GNBDUConfigurationUpdateAcknowledgeIEs_t);
 675
 676    /* Initialize the F1Setup members */
 677    CU_ALLOC(gNBDuCfgAck->protocolIEs.list.array, elementCnt * sizeof(GNBDUConfigurationUpdateAcknowledgeIEs_t *));
 678    if(gNBDuCfgAck->protocolIEs.list.array == NULLP)
 679    {
 680       DU_LOG("\nERROR  -->  F1AP : Memory allocation for DuUpdateAcknowledgeIEs failed");
 681       CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 682       CU_FREE(f1apMsg,(Size)sizeof(F1AP_PDU_t));
 683       return RFAILED;
 684    }
 685
 686    for(idx=0; idx<elementCnt; idx++)
 687    {
 688       CU_ALLOC(gNBDuCfgAck->protocolIEs.list.array[idx], sizeof(GNBDUConfigurationUpdateAcknowledgeIEs_t));
 689       if(gNBDuCfgAck->protocolIEs.list.array[idx] == NULLP)
 690       {
 691          CU_FREE(gNBDuCfgAck->protocolIEs.list.array, elementCnt * sizeof(GNBDUConfigurationUpdateAcknowledgeIEs_t *));
 692          CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 693          CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 694          return RFAILED;
 695       }
 696    }
 697
 698    /*TransactionID*/
 699    idx = 0;
 700    gNBDuCfgAck->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_TransactionID ;
 701    gNBDuCfgAck->protocolIEs.list.array[idx]->criticality = Criticality_reject;
 702    gNBDuCfgAck->protocolIEs.list.array[idx]->value.present =\
 703    GNBDUConfigurationUpdateAcknowledgeIEs__value_PR_TransactionID;
 704    gNBDuCfgAck->protocolIEs.list.array[idx]->value.choice.TransactionID = TRANS_ID;
 705
 706    xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
 707
 708    /* Encode the F1SetupRequest type as UPER */
 709    memset(encBuf, 0, ENC_BUF_MAX_LEN);
 710    encBufSize = 0;
 711    enRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
 712
 713    /* Clean up */
 714    for(idx=0; idx<elementCnt; idx++)
 715    {
 716       CU_FREE(gNBDuCfgAck->protocolIEs.list.array[idx], sizeof(GNBDUConfigurationUpdateAcknowledgeIEs_t));
 717    }
 718    CU_FREE(gNBDuCfgAck->protocolIEs.list.array, elementCnt * sizeof(GNBDUConfigurationUpdateAcknowledgeIEs_t *));
 719    CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 720    CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 721
 722    /* Checking encode results */
 723    if(enRetVal.encoded == ENCODE_FAIL)
 724    {
 725       DU_LOG("\nERROR  -->  F1AP : Could not encode DUConfigUpdateAcknowledge structure (at %s)",\
 726       enRetVal.failed_type ? enRetVal.failed_type->name : "unknown");
 727       return RFAILED;
 728    }
 729    else
 730    {
 731       DU_LOG("\nDEBUG  -->  F1AP : Created APER encoded buffer for DuConfigUpdateAcknowledge\n");
 732       for(int i=0; i< encBufSize; i++)
 733       {
 734          DU_LOG("%x",encBuf[i]);
 735       }
 736    }
 737
 738    /* Sending msg */
 739    /* TODO : Hardcoding DU ID to 1 for messages other than F1 Setup Response. This will be made generic in future gerrit */
 740    if(SendF1APMsg(CU_APP_MEM_REG, CU_POOL, duId) != ROK)
 741    {
 742       DU_LOG("\nERROR  -->  F1AP : Sending GNB-DU Config Update Ack failed");
 743       return RFAILED;
 744    }
 745
 746    return ROK;
 747
 748 }/* End of BuildAndSendDUUpdateAck*/
 749
 750 /*******************************************************************
 751 *
 752 * @brief deallocating the memory of  F1reset msg
 753 *
 754 * @details
 755 *
 756 *    Function : FreeF1ResetReq
 757 *
 758 *    Functionality :
 759 *         - freeing memory of F1reset request msg
 760 *
 761 * @params[in]
 762 * @return void
 763 *
 764 *
 765 * ****************************************************************/
 766 void FreeF1ResetReq(F1AP_PDU_t *f1apMsg)
 767 {
 768    uint8_t idx = 0;
 769    Reset_t *f1ResetMsg = NULLP;
 770
 771    if(f1apMsg)
 772    {
 773       if(f1apMsg->choice.initiatingMessage)
 774       {
 775          f1ResetMsg = &f1apMsg->choice.initiatingMessage->value.choice.Reset;
 776          if(f1ResetMsg->protocolIEs.list.array)
 777          {
 778             for(idx=0 ;idx < f1ResetMsg->protocolIEs.list.count ; idx++)
 779             {
 780                if(f1ResetMsg->protocolIEs.list.array[idx])
 781                {
 782                   CU_FREE(f1ResetMsg->protocolIEs.list.array[idx],sizeof(ResetIEs_t));
 783                }
 784             }
 785             CU_FREE(f1ResetMsg->protocolIEs.list.array,f1ResetMsg->protocolIEs.list.size);
 786          }
 787          CU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
 788       }
 789       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 790    }
 791 }
 792 /*******************************************************************
 793  *
 794  * @brief build ansld ans send f1reset msg
 795  *
 796  * @details
 797  *
 798  *    Function : BuildAndSendF1ResetReq
 799  *
 800  *    Functionality: build and send f1reset msg
 801  *
 802  * @return ROK     - success
 803  *         RFAILED - failure
 804  *
 805  * ****************************************************************/
 806 uint8_t BuildAndSendF1ResetReq()
 807 {
 808    uint8_t          elementCnt=0;
 809    uint8_t          idx=0;
 810    uint8_t          ret= RFAILED;
 811    Reset_t          *f1ResetMsg = NULLP;
 812    F1AP_PDU_t       *f1apMsg = NULLP;
 813    asn_enc_rval_t   encRetVal;
 814    DU_LOG("\nINFO  -->  F1AP : Building F1 Reset request \n");
 815    do
 816    {
 817       CU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
 818       if(f1apMsg == NULLP)
 819       {
 820          DU_LOG("\nERROR  -->  F1AP : Memory allocation for the BuildAndSendF1ResetReq's F1AP-PDU failed");
 821          break;
 822       }
 823       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
 824       CU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
 825       if(f1apMsg->choice.initiatingMessage == NULLP)
 826       {
 827          DU_LOG("\nERROR  -->  F1AP : Memory allocation for BuildAndSendF1ResetReq failed");
 828          break;
 829       }
 830       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_Reset;
 831       f1apMsg->choice.initiatingMessage->criticality = Criticality_reject;
 832       f1apMsg->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_Reset;
 833
 834       f1ResetMsg = &f1apMsg->choice.initiatingMessage->value.choice.Reset;
 835
 836       elementCnt = 3;
 837       f1ResetMsg->protocolIEs.list.count = elementCnt;
 838       f1ResetMsg->protocolIEs.list.size = elementCnt * sizeof(ResetIEs_t *);
 839
 840       /* Initialize the F1Reset members */
 841       CU_ALLOC(f1ResetMsg->protocolIEs.list.array,f1ResetMsg->protocolIEs.list.size);
 842       if(f1ResetMsg->protocolIEs.list.array == NULLP)
 843       {
 844          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed for BuildAndSendF1ResetReq");
 845          break;
 846       }
 847       for(idx=0; idx<elementCnt; idx++)
 848       {
 849          CU_ALLOC(f1ResetMsg->protocolIEs.list.array[idx],sizeof(ResetIEs_t));
 850          if(f1ResetMsg->protocolIEs.list.array[idx] == NULLP)
 851          {
 852             DU_LOG("\nERROR  -->  F1AP : Memory allocation failed for BuildAndSendF1ResetReq msg array");
 853             break;
 854          }
 855       }
 856
 857       /*TransactionID*/
 858       idx=0;
 859       f1ResetMsg->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_TransactionID;
 860       f1ResetMsg->protocolIEs.list.array[idx]->criticality = Criticality_reject;
 861       f1ResetMsg->protocolIEs.list.array[idx]->value.present = ResetIEs__value_PR_TransactionID;
 862       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.TransactionID = 1;
 863
 864       /*Cause*/
 865       idx++;
 866       f1ResetMsg->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_Cause;
 867       f1ResetMsg->protocolIEs.list.array[idx]->criticality = Criticality_ignore;
 868       f1ResetMsg->protocolIEs.list.array[idx]->value.present = ResetIEs__value_PR_Cause;
 869       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.Cause.present = Cause_PR_radioNetwork;
 870       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.Cause.choice.radioNetwork = CauseRadioNetwork_action_desirable_for_radio_reasons;
 871
 872       /*Reset Type*/
 873       idx++;
 874       f1ResetMsg->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_ResetType;
 875       f1ResetMsg->protocolIEs.list.array[idx]->criticality = Criticality_reject;
 876       f1ResetMsg->protocolIEs.list.array[idx]->value.present = ResetIEs__value_PR_ResetType;
 877       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.ResetType.present = ResetType_PR_f1_Interface;
 878       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.ResetType.choice.f1_Interface = ResetAll_reset_all;
 879
 880       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
 881
 882       /* Encode the F1SetupRequest type as APER */
 883       memset(encBuf, 0, ENC_BUF_MAX_LEN);
 884       encBufSize = 0;
 885       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
 886             encBuf);
 887
 888       /* Encode results */
 889       if(encRetVal.encoded == ENCODE_FAIL)
 890       {
 891          DU_LOG("\nERROR  -->  F1AP : Could not encode F1Reset structure (at %s)\n",\
 892                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
 893          break;
 894       }
 895       else
 896       {
 897          DU_LOG("\nDEBUG  -->  F1AP : Created APER encoded buffer for F1Reset\n");
 898          for(idx=0; idx< encBufSize; idx++)
 899          {
 900             DU_LOG("%x",encBuf[idx]);
 901          }
 902       }
 903
 904       /* TODO : Hardcoding DU ID to 1 for messages other than F1 Setup Response. This will be made generic in future gerrit */
 905       if(SendF1APMsg(CU_APP_MEM_REG, CU_POOL, DU_ID) != ROK)
 906       {
 907          DU_LOG("\nERROR  -->  F1AP : Sending F1 Reset request failed");
 908          break;
 909       }
 910
 911       ret = ROK;
 912       break;
 913    }while(true);
 914
 915    FreeF1ResetReq(f1apMsg);
 916    return ret;
 917 }
 918
 919 /*******************************************************************
 920  *
 921  * @brief Fills Radio Bearer Config
 922  *
 923  * @details
 924  *
 925  *    Function : fillSrbCfg
 926  *
 927  *    Functionality: Fills Radio Bearer Config
 928  *
 929  * @params[in] SRB_ToAddModList *
 930  *
 931  * @return ROK     - success
 932  *         RFAILED - failure
 933  *
 934  * ****************************************************************/
 935 uint8_t fillSrbCfg(CuUeCb *ueCb, SRB_ToAddModList_t *bearerCfg)
 936 {
 937    uint8_t elementCnt = 0;
 938    uint8_t idx, ieId, srbIdx = 0;
 939
 940    for(srbIdx=0; srbIdx < ueCb->numSrb; srbIdx++)
 941    {
 942       if(ueCb->srbList[srbIdx].cfgSentToUe == false)
 943          elementCnt++;
 944    }
 945
 946    if(bearerCfg != NULLP)
 947    {
 948       bearerCfg->list.count = elementCnt;
 949       bearerCfg->list.size = elementCnt * sizeof(SRB_ToAddMod_t *);
 950       CU_ALLOC(bearerCfg->list.array, bearerCfg->list.size);
 951       if(bearerCfg->list.array != NULLP)
 952       {
 953          for(idx = 0; idx < elementCnt; idx++)
 954          {
 955             CU_ALLOC(bearerCfg->list.array[idx], sizeof(SRB_ToAddMod_t));
 956             if(bearerCfg->list.array[idx] == NULLP)
 957             {
 958                for(ieId = 0; ieId < idx; ieId++)
 959                {
 960                   CU_FREE(bearerCfg->list.array[ieId], sizeof(SRB_ToAddMod_t));
 961                }
 962                CU_FREE(bearerCfg->list.array, bearerCfg->list.size);
 963                return RFAILED;
 964             }
 965          }
 966       }
 967       else
 968       {
 969          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed for bearer list arry in fillSrbCfg");
 970          return RFAILED;
 971       }
 972
 973       idx = 0;
 974       for(srbIdx=0; srbIdx < ueCb->numSrb; srbIdx++)
 975       {
 976          if(ueCb->srbList[srbIdx].cfgSentToUe == false)
 977             bearerCfg->list.array[idx++]->srb_Identity = ueCb->srbList[srbIdx].srbId;
 978       }
 979    }
 980    return ROK;
 981 }
 982
 983 /*******************************************************************
 984  *
 985  * @brief Fills Master CellGroup Info
 986  *
 987  * @details
 988  *
 989  *    Function : fillMasterCellGroup
 990  *
 991  *    Functionality: Fills Master Cell Group IE
 992  *
 993  * @params[in] RRCSetup_IEs_t *
 994  *
 995  * @return ROK     - success
 996  *         RFAILED - failure
 997  *
 998  * ****************************************************************/
 999
1000 uint8_t fillMasterCellGroup(CuUeCb *ueCb, OCTET_STRING_t *masterCellGroup)
1001 {
1002    uint8_t ret = ROK;
1003    masterCellGroup->buf = NULLP;
1004    if(ueCb->f1apMsgDb.duToCuContainer.buf)
1005    {
1006       masterCellGroup->size = ueCb->f1apMsgDb.duToCuContainer.size;
1007       CU_ALLOC(masterCellGroup->buf, masterCellGroup->size);
1008       if(masterCellGroup->buf != NULLP)
1009       {
1010          memcpy(masterCellGroup->buf, ueCb->f1apMsgDb.duToCuContainer.buf, masterCellGroup->size);
1011       }
1012       else
1013       {
1014          DU_LOG( "\nERROR  -->  F1AP : Master Cell Group buffer is NULL");
1015          ret = RFAILED;
1016       }
1017    }
1018    else
1019    {
1020       ret =  RFAILED;
1021    }
1022    return ret;
1023 }
1024
1025 /*******************************************************************
1026  *
1027  * @brief Fills RRC setup IE
1028  *
1029  * @details
1030  *
1031  *    Function : fillRRCSetupIE
1032  *
1033  *    Functionality: Fills RRC Setup IE
1034  *
1035  * @params[in] RRCSetup_IEs_t *
1036  *
1037  * @return ROK     - success
1038  *         RFAILED - failure
1039  *
1040  * ****************************************************************/
1041
1042 uint8_t fillRRCSetupIE(CuUeCb *ueCb, RRCSetup_IEs_t *rrcSetupIE)
1043 {
1044    uint8_t ret = ROK, srbIdx = 0;
1045    if(rrcSetupIE)
1046    {
1047       CU_ALLOC(rrcSetupIE->radioBearerConfig.srb_ToAddModList, sizeof(SRB_ToAddModList_t));
1048       if(rrcSetupIE->radioBearerConfig.srb_ToAddModList != NULLP)
1049       {
1050          ret = fillSrbCfg(ueCb, rrcSetupIE->radioBearerConfig.srb_ToAddModList);
1051       }
1052       if(ret == ROK)
1053       {
1054          ret = fillCellGrpCfg(ueCb, &rrcSetupIE->masterCellGroup, false);
1055       }
1056       else
1057       {
1058          CU_FREE(rrcSetupIE->radioBearerConfig.srb_ToAddModList, sizeof(SRB_ToAddModList_t));
1059          ret = RFAILED;
1060       }
1061
1062       /* If SRB configuration are filled successfully in RRC Setup, mark these
1063        * configurartion as sent to UE */
1064       for(srbIdx=0; srbIdx < ueCb->numSrb; srbIdx++)
1065       {
1066          if(ueCb->srbList[srbIdx].cfgSentToUe == false)
1067             ueCb->srbList[srbIdx].cfgSentToUe = true;
1068       }
1069    }
1070    return ret;
1071 }
1072 /*******************************************************************
1073  *
1074  * @brief Fills DL DCCCH Message required for DLRRCMessageTransfer
1075  *
1076  * @details
1077  *
1078  *    Function : fillDlCcchRrcMsg
1079  *
1080  *    Functionality: Fills DL DCCCH Message required for
1081  *                   DLRRCMessageTransfer
1082  *
1083  * @params[in] RRCContainer_t *rrcContainer
1084  *
1085  * @return ROK     - success
1086  *         RFAILED - failure
1087  *
1088  * ****************************************************************/
1089
1090 uint8_t fillDlCcchRrcMsg(CuUeCb *ueCb, RRCContainer_t *rrcContainer)
1091 {
1092    uint8_t ret = ROK;
1093    uint16_t idx2;
1094    DL_CCCH_Message_t dl_CCCH_Msg;
1095    asn_enc_rval_t    encRetVal;
1096
1097    if(rrcContainer != NULLP)
1098    {
1099       dl_CCCH_Msg.message.present = DL_CCCH_MessageType_PR_c1;
1100
1101       CU_ALLOC(dl_CCCH_Msg.message.choice.c1 , sizeof(DL_CCCH_MessageType_t));
1102       if(dl_CCCH_Msg.message.choice.c1 != NULLP)
1103       {
1104          dl_CCCH_Msg.message.choice.c1->present = DL_CCCH_MessageType__c1_PR_rrcSetup;
1105          CU_ALLOC(dl_CCCH_Msg.message.choice.c1->choice.rrcSetup, sizeof(RRCSetup_t));
1106          if(dl_CCCH_Msg.message.choice.c1->choice.rrcSetup != NULLP)
1107          {
1108             dl_CCCH_Msg.message.choice.c1->choice.rrcSetup->rrc_TransactionIdentifier = 0;
1109             dl_CCCH_Msg.message.choice.c1->choice.rrcSetup->criticalExtensions.present = \
1110                RRCSetup__criticalExtensions_PR_rrcSetup;
1111
1112             /* Fill RRC Setup IE */
1113             CU_ALLOC(dl_CCCH_Msg.message.choice.c1->choice.rrcSetup->criticalExtensions.choice.rrcSetup, \
1114                sizeof(RRCSetup_IEs_t));
1115             if(dl_CCCH_Msg.message.choice.c1->choice.rrcSetup->criticalExtensions.choice.rrcSetup != NULLP)
1116             {
1117                ret = fillRRCSetupIE(ueCb, dl_CCCH_Msg.message.choice.c1->choice.rrcSetup->criticalExtensions.choice.rrcSetup);
1118
1119                if(ret == ROK)
1120                {
1121                   /* encode DL-CCCH message into RRC Container */
1122                   xer_fprint(stdout, &asn_DEF_DL_CCCH_MessageType, &dl_CCCH_Msg);
1123                   memset(encBuf, 0, ENC_BUF_MAX_LEN);
1124                   encBufSize = 0;
1125                   encRetVal = aper_encode(&asn_DEF_DL_CCCH_MessageType, 0, &dl_CCCH_Msg, PrepFinalEncBuf, encBuf);
1126                   /* Encode results */
1127                   if(encRetVal.encoded == ENCODE_FAIL)
1128                   {
1129                      DU_LOG( "\nERROR  -->  F1AP : Could not encode RRCContainer for DL-CCCH Msg(at %s)\n",\
1130                            encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
1131                      return RFAILED;
1132                   }
1133                   else
1134                   {
1135                      DU_LOG("\nDEBUG  -->  F1AP : Created APER encoded buffer for RRCContainer for DL-CCCH Msg\n");
1136                      for(int i = 0; i< encBufSize; i++)
1137                      {
1138                         DU_LOG("%x",encBuf[i]);
1139                      }
1140                      rrcContainer->size = encBufSize;
1141                      CU_ALLOC(rrcContainer->buf, rrcContainer->size);
1142                      if(rrcContainer->buf != NULLP)
1143                      {
1144                         memset(rrcContainer->buf, 0, encBufSize);
1145                         for(idx2 = 0; idx2 < encBufSize; idx2++)
1146                         {
1147                            rrcContainer->buf[idx2] =    encBuf[idx2];
1148                         }
1149                      }
1150                   }
1151                }
1152                else
1153                {
1154                   ret = RFAILED;
1155                }
1156             }
1157             else
1158             {
1159                DU_LOG("\nERROR  -->  F1AP: Memory Alloc failed for RRC Setup Msg at fillDlCcchRrcMsg()");
1160                ret = RFAILED;
1161             }
1162          }
1163          else
1164          {
1165             DU_LOG("\nERROR  -->  F1AP: Memory Alloc failed for RRC Msg at fillDlCcchRrcMsg()");
1166             ret = RFAILED;
1167          }
1168       }
1169       else
1170       {
1171          DU_LOG("\nF1AP: Memory Alloc failed for DL Ccch Msg choice at fillDlCcchRrcMsg()");
1172          ret = RFAILED;
1173       }
1174    }
1175    else
1176    {
1177       DU_LOG("\nERROR  -->  F1AP: RRC Container is NULLP at fillDlCcchRrcMsg()");
1178       ret = RFAILED;
1179    }
1180 }
1181
1182 uint8_t fillQosFlowsToAdd(struct SDAP_Config__mappedQoS_FlowsToAdd *qosFlow)
1183 {
1184    uint8_t idx, ied, elementCnt;
1185
1186    elementCnt = 1;
1187    qosFlow->list.count = elementCnt;
1188    qosFlow->list.size  = elementCnt * sizeof(QFI_t *);
1189    CU_ALLOC(qosFlow->list.array, qosFlow->list.size);
1190    if(qosFlow->list.array != NULLP)
1191    {
1192       for(idx = 0; idx < elementCnt; idx++)
1193       {
1194          CU_ALLOC(qosFlow->list.array[idx], sizeof(QFI_t));
1195          if(qosFlow->list.array[idx] == NULLP)
1196          {
1197             for(ied = 0; ied < idx; ied++)
1198             {
1199                CU_FREE(qosFlow->list.array[idx], sizeof(QFI_t));
1200             }
1201             CU_FREE(qosFlow->list.array, qosFlow->list.size);
1202             return RFAILED;
1203          }
1204       }
1205    }
1206    idx = 0;
1207    *qosFlow->list.array[idx] = 9;
1208    return ROK;
1209 }
1210
1211 /*******************************************************************
1212  *
1213  * @brief Fills CN Assoc for Drb to Add/Mod List
1214  *
1215  * @details
1216  *
1217  *    Function : fillCnAssoc
1218  *
1219  *    Functionality: Fills CN Assoc for Drb to Add/Mod List
1220  *
1221  * @params[in] struct DRB_ToAddMod__cnAssociation *
1222  *
1223  * @return ROK     - success
1224  *         RFAILED - failure
1225  *
1226  * ****************************************************************/
1227
1228 uint8_t fillCnAssoc(struct DRB_ToAddMod__cnAssociation *cnAssoc)
1229 {
1230    uint8_t ret = ROK;
1231
1232    cnAssoc->present = DRB_ToAddMod__cnAssociation_PR_sdap_Config;
1233    if(cnAssoc->present == DRB_ToAddMod__cnAssociation_PR_eps_BearerIdentity)
1234    {
1235       cnAssoc->choice.eps_BearerIdentity = 5;
1236    }
1237    if(cnAssoc->present == DRB_ToAddMod__cnAssociation_PR_sdap_Config)
1238    {
1239       CU_ALLOC(cnAssoc->choice.sdap_Config, sizeof(SDAP_Config_t));
1240       if(cnAssoc->choice.sdap_Config)
1241       {
1242          cnAssoc->choice.sdap_Config->pdu_Session = 5;
1243          cnAssoc->choice.sdap_Config->sdap_HeaderDL = 0;
1244          cnAssoc->choice.sdap_Config->sdap_HeaderUL = 0;
1245          cnAssoc->choice.sdap_Config->defaultDRB = true;
1246          cnAssoc->choice.sdap_Config->mappedQoS_FlowsToAdd = NULLP;
1247          cnAssoc->choice.sdap_Config->mappedQoS_FlowsToRelease = NULLP;
1248          CU_ALLOC(cnAssoc->choice.sdap_Config->mappedQoS_FlowsToAdd, \
1249                sizeof(struct SDAP_Config__mappedQoS_FlowsToAdd));
1250          if(cnAssoc->choice.sdap_Config->mappedQoS_FlowsToAdd)
1251          {
1252             ret = fillQosFlowsToAdd(cnAssoc->choice.sdap_Config->mappedQoS_FlowsToAdd);
1253          }
1254          else
1255          {
1256             DU_LOG("\nERROR  -->  F1AP: Memory alloc failed at mappedQoS_FlowsToAdd in fillCnAssoc()");
1257             CU_FREE(cnAssoc->choice.sdap_Config, sizeof(SDAP_Config_t));
1258             ret = RFAILED;
1259          }
1260       }
1261       else
1262       {
1263          DU_LOG("\nERROR  -->  F1AP: Mem alloc failed at fillCnAssoc()");
1264          ret = RFAILED;
1265       }
1266    }
1267    return ret;
1268 }
1269
1270 /*******************************************************************
1271  *
1272  * @brief Fills Radio Bearer Config for Drb
1273  *
1274  * @details
1275  *
1276  *    Function : fillDrbCfg
1277  *
1278  *    Functionality: Fills Radio Bearer Config for Drb
1279  *
1280  * @params[in] drbId, DRB_ToAddModList *
1281  *
1282  * @return ROK     - success
1283  *         RFAILED - failure
1284  *
1285  * ****************************************************************/
1286 uint8_t fillDrbCfg(uint8_t drbId, DRB_ToAddModList_t *drbCfg)
1287 {
1288    uint8_t idx, ied, ret, elementCnt;
1289
1290    ret = ROK;
1291    if(drbCfg != NULLP)
1292    {
1293       elementCnt = 1;
1294       drbCfg->list.count = elementCnt;
1295       drbCfg->list.size =\
1296                          elementCnt * sizeof(DRB_ToAddMod_t *);
1297       CU_ALLOC(drbCfg->list.array, drbCfg->list.size);
1298       if(drbCfg->list.array != NULLP)
1299       {
1300          for(idx = 0; idx < elementCnt; idx++)
1301          {
1302             CU_ALLOC(drbCfg->list.array[idx], sizeof(DRB_ToAddMod_t));
1303             if(drbCfg->list.array[idx] == NULLP)
1304             {
1305                for(ied = 0; ied < idx; ied++)
1306                {
1307                   CU_FREE(drbCfg->list.array[idx], sizeof(DRB_ToAddMod_t));
1308                }
1309                CU_FREE(drbCfg->list.array, drbCfg->list.size);
1310                return RFAILED;
1311             }
1312          }
1313       }
1314       else
1315       {
1316          return RFAILED;
1317       }
1318       idx = 0;
1319       /* CN ASSOCIATION */
1320       CU_ALLOC(drbCfg->list.array[idx]->cnAssociation, sizeof(struct DRB_ToAddMod__cnAssociation));
1321       if(drbCfg->list.array[idx]->cnAssociation)
1322       {
1323          ret = fillCnAssoc(drbCfg->list.array[idx]->cnAssociation);
1324       }
1325       /* DRB */
1326       drbCfg->list.array[idx]->drb_Identity = drbId;
1327    }
1328    return ret;
1329 }
1330
1331 /*******************************************************************
1332  *
1333  * @brief Fills RRC Reconfig Message required for DLRRCMessageTransfer
1334  *
1335  * @details
1336  *
1337  *    Function : fillRrcReconfigIE
1338  *
1339  *    Functionality: Fills RRC Reconfig Message required for
1340  *                   DLRRCMessageTransfer
1341  *
1342  * @params[in] RRCReconfiguration_IEs_t* rrcReconfig
1343  *
1344  * @return ROK     - success
1345  *         RFAILED - failure
1346  *
1347  * ****************************************************************/
1348
1349 uint8_t fillRrcReconfigIE(RRCReconfiguration_IEs_t *rrcReconfigMsg)
1350 {
1351    uint8_t ret = ROK;
1352    CU_ALLOC(rrcReconfigMsg->radioBearerConfig, sizeof(RadioBearerConfig_t));
1353    if(rrcReconfigMsg->radioBearerConfig)
1354    {
1355       CU_ALLOC(rrcReconfigMsg->radioBearerConfig->srb_ToAddModList, sizeof(SRB_ToAddModList_t));
1356       if(rrcReconfigMsg->radioBearerConfig->srb_ToAddModList != NULLP)
1357       {
1358          ret = fillSrbCfg(SRB2, rrcReconfigMsg->radioBearerConfig->srb_ToAddModList);
1359
1360       }
1361       if(ret == ROK)
1362       {
1363          CU_ALLOC(rrcReconfigMsg->radioBearerConfig->drb_ToAddModList, sizeof(DRB_ToAddModList_t));
1364          if(rrcReconfigMsg->radioBearerConfig->drb_ToAddModList != NULLP)
1365          {
1366             ret = fillDrbCfg(DRB1, rrcReconfigMsg->radioBearerConfig->drb_ToAddModList);
1367             if(ret == RFAILED)
1368             {
1369                DU_LOG("\nERROR  -->  F1AP : Failed to fill DrbCfg at fillRrcReconfigIE()");
1370                CU_FREE(rrcReconfigMsg->radioBearerConfig->srb_ToAddModList, sizeof(SRB_ToAddModList_t));
1371                CU_FREE(rrcReconfigMsg->radioBearerConfig->drb_ToAddModList, sizeof(DRB_ToAddModList_t));
1372             }
1373          }
1374       }
1375       else
1376       {
1377          DU_LOG("\nERROR  -->  F1AP : memory Alloc failed at fillRrcReconfigIE()");
1378          CU_FREE(rrcReconfigMsg->radioBearerConfig->srb_ToAddModList, sizeof(SRB_ToAddModList_t));
1379       }
1380    }
1381
1382    return ret;
1383 }
1384 /*******************************************************************
1385  *
1386  * @brief Fills DL DCCH Message required for DLRRCMessageTransfer
1387  *
1388  * @details
1389  *
1390  *    Function : fillDlDcchRrcMsg
1391  *
1392  *    Functionality: Fills DL DCCH Message required for
1393  *                   DLRRCMessageTransfer
1394  *
1395  * @params[in] RRCContainer_t *rrcContainer
1396  *
1397  * @return ROK     - success
1398  *         RFAILED - failure
1399  *
1400  * ****************************************************************/
1401
1402 uint8_t fillDlDcchRrcMsg(CuUeCb *ueCb, RRCContainer_t *rrcContainer)
1403 {
1404    uint8_t ret = ROK;
1405    uint16_t idx2 = 0, drbIdx = 0, srbIdx = 0;
1406    DL_DCCH_Message_t dl_DCCH_Msg;
1407    memset(&dl_DCCH_Msg, 0, sizeof(DL_DCCH_Message_t));
1408    asn_enc_rval_t        encRetVal;
1409
1410    if(rrcContainer != NULLP)
1411    {
1412       dl_DCCH_Msg.message.present = DL_DCCH_MessageType_PR_c1;
1413
1414       CU_ALLOC(dl_DCCH_Msg.message.choice.c1 , sizeof(DL_DCCH_MessageType_t));
1415       if(dl_DCCH_Msg.message.choice.c1 != NULLP)
1416       {
1417          dl_DCCH_Msg.message.choice.c1->present = DL_DCCH_MessageType__c1_PR_rrcReconfiguration;
1418          CU_ALLOC(dl_DCCH_Msg.message.choice.c1->choice.rrcReconfiguration, sizeof(RRCReconfiguration_t));
1419          if(dl_DCCH_Msg.message.choice.c1->choice.rrcReconfiguration != NULLP)
1420          {
1421             DU_LOG("\nDEBUG --> F1AP : Filling DL DCCH RRC Reconfiguration Message ");
1422             fillRrcReconfig(ueCb, dl_DCCH_Msg.message.choice.c1->choice.rrcReconfiguration, false);
1423             if(ret == ROK)
1424             {
1425                /* If RB configuration are filled successfully in RRC Reconfiguration, mark these
1426                 * configurartion as sent to UE */
1427                for(srbIdx=0; srbIdx < ueCb->numSrb; srbIdx++)
1428                {
1429                   if(ueCb->srbList[srbIdx].cfgSentToUe == false)
1430                      ueCb->srbList[srbIdx].cfgSentToUe = true;
1431                }
1432                for(drbIdx=0; drbIdx < ueCb->numDrb; drbIdx++)
1433                {
1434                   if(ueCb->drbList[drbIdx].cfgSentToUe == false)
1435                      ueCb->drbList[drbIdx].cfgSentToUe = true;
1436                }
1437
1438                /* encode DL-DCCH message into RRC Container */
1439                xer_fprint(stdout, &asn_DEF_DL_DCCH_MessageType, &dl_DCCH_Msg);
1440                memset(encBuf, 0, ENC_BUF_MAX_LEN);
1441                encBufSize = 0;
1442                encRetVal = aper_encode(&asn_DEF_DL_DCCH_MessageType, 0, &dl_DCCH_Msg, PrepFinalEncBuf, encBuf);
1443                /* Encode results */
1444                if(encRetVal.encoded == ENCODE_FAIL)
1445                {
1446                   DU_LOG( "\nERROR  -->  F1AP : Could not encode RRCContainer for DL-DCCH Msg (at %s)\n",\
1447                         encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
1448                   return RFAILED;
1449                }
1450                else
1451                {
1452                   DU_LOG("\nDEBUG  -->  F1AP : Created APER encoded buffer for RRCContainer for DL-DCCH Msg\n");
1453                   for(int i = 0; i< encBufSize; i++)
1454                   {
1455                      DU_LOG("%x",encBuf[i]);
1456                   }
1457                   rrcContainer->size = encBufSize;
1458                   CU_ALLOC(rrcContainer->buf, rrcContainer->size);
1459                   if(rrcContainer->buf != NULLP)
1460                   {
1461                      memset(rrcContainer->buf, 0, encBufSize);
1462                      for(idx2 = 0; idx2 < encBufSize; idx2++)
1463                      {
1464                         rrcContainer->buf[idx2] =       encBuf[idx2];
1465                      }
1466                   }
1467                }
1468             }
1469          }
1470          else
1471          {
1472             DU_LOG("\nERROR  -->  F1AP: Memory Alloc failed for RRC Msg at fillDlDcchRrcMsg()");
1473             ret = RFAILED;
1474          }
1475       }
1476       else
1477       {
1478          DU_LOG("\nERROR  -->  F1AP: Memory Alloc failed for DL Dcch Msg choice at fillDlDcchRrcMsg()");
1479          ret = RFAILED;
1480       }
1481    }
1482    else
1483    {
1484       DU_LOG("\nERROR  -->  F1AP: RRC Container is NULLP at fillDlDcchRrcMsg()");
1485       ret = RFAILED;
1486    }
1487    return ret;
1488 }
1489
1490 /*******************************************************************
1491  *
1492  * @brief Builds RRC Container IE required for DLRRCMessageTransfer
1493  *
1494  * @details
1495  *
1496  *    Function : BuildDLRRCContainer
1497  *
1498  *    Functionality: Builds RRC Container IE required for
1499  *                   DLRRCMessageTransfer
1500  *
1501  * @params[in]
1502  *
1503  * @return ROK     - success
1504  *         RFAILED - failure
1505  *
1506  * ****************************************************************/
1507
1508 uint8_t BuildDLRRCContainer(CuUeCb *ueCb, uint8_t rrcMsgType, RRCContainer_t *rrcContainer)
1509 {
1510    uint8_t ret, bufLen;
1511
1512    ret =ROK;
1513    if(rrcMsgType == RRC_SETUP)
1514    {
1515       ret = fillDlCcchRrcMsg(ueCb, rrcContainer);
1516       if(ret == RFAILED)
1517          DU_LOG("\nERROR  -->  F1AP: Failed to fill DL-CCCH Msg at RRC SETUP");
1518    }
1519    else if(rrcMsgType == REGISTRATION_ACCEPT)
1520    {
1521       /*Hardcoded RRC Container from reference logs*/
1522       char buf[14] ={0x00, 0x03, 0x2a, 0x80, 0xaf, 0xc0, 0x08, 0x40, 0x20, 0x20, 0x00, 0x00, 0x00, 0x00};
1523       bufLen =14;
1524       rrcContainer->size = bufLen;
1525       CU_ALLOC(rrcContainer->buf, rrcContainer->size);
1526       if(rrcContainer->buf != NULLP)
1527       {
1528          memset(rrcContainer->buf, 0, bufLen);
1529          memcpy(rrcContainer->buf, buf, bufLen);
1530       }
1531       else
1532       {
1533          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure for RRC Container buffer");
1534          ret = RFAILED;
1535       }
1536    }
1537    else if(rrcMsgType == RRC_RECONFIG)
1538    {
1539       DU_LOG("\nDEBUG --> F1AP : Filling DL DCCH RRC Message ");
1540       ret = fillDlDcchRrcMsg(ueCb, rrcContainer);
1541       if(ret == RFAILED)
1542          DU_LOG("\nERROR  -->  F1AP: Failed to fill DL-DCCH Msg for RRC Reconfiguration");
1543    }
1544
1545    return ret;
1546 }
1547
1548 /*******************************************************************
1549  *
1550  * @brief Frees the DLRRCMessageTransfer
1551  *
1552  * @details
1553  *
1554  *    Function : freeDlRrcMessageTransfer
1555  *
1556  *    Functionality: Frees the DLRRCMessageTransfer
1557  *
1558  * @params[in]
1559  *
1560  * @return ROK     - success
1561  *         RFAILED - failure
1562  *
1563  * ****************************************************************/
1564 void freeDlRrcMessageTransfer(F1AP_PDU_t *f1apMsg)
1565 {
1566    uint8_t idx=0;
1567    DLRRCMessageTransfer_t  *dlRRCMsg = NULLP;
1568
1569    if(f1apMsg)
1570    {
1571       dlRRCMsg = &f1apMsg->choice.initiatingMessage->value.choice.DLRRCMessageTransfer;
1572       if(dlRRCMsg->protocolIEs.list.array)
1573       {
1574          idx = 3;
1575          CU_FREE(dlRRCMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.buf, \
1576             dlRRCMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.size);
1577          for(idx=0; idx<dlRRCMsg->protocolIEs.list.count; idx++)
1578          {
1579             CU_FREE(dlRRCMsg->protocolIEs.list.array[idx], sizeof(DLRRCMessageTransferIEs_t));
1580          }
1581          CU_FREE(dlRRCMsg->protocolIEs.list.array, dlRRCMsg->protocolIEs.list.size);
1582       }
1583       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
1584    }
1585 }
1586
1587 /*******************************************************************
1588  *
1589  * @brief Builds and sends the DLRRCMessageTransfer
1590  *
1591  * @details
1592  *
1593  *    Function : BuildAndSendDLRRCMessageTransfer
1594  *
1595  *    Functionality: Constructs the DL RRC Message Transfer and sends
1596  *                   it to the CU through SCTP.
1597  *
1598  * @params[in]
1599  *
1600  * @return ROK     - success
1601  *         RFAILED - failure
1602  *
1603  * ****************************************************************/
1604 uint8_t BuildAndSendDLRRCMessageTransfer(uint32_t duId, CuUeCb *ueCb, uint8_t srbId, uint8_t rrcMsgType)
1605 {
1606    uint8_t   elementCnt = 0;
1607    uint8_t  ieId;
1608    uint8_t  idx;
1609    F1AP_PDU_t  *f1apMsg = NULLP;
1610    DLRRCMessageTransfer_t  *dlRRCMsg = NULLP;
1611    asn_enc_rval_t   encRetVal;        /* Encoder return value */
1612
1613    DU_LOG("\nINFO  -->  F1AP : Building DL RRC Message Transfer Message\n");
1614
1615    CU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
1616    if(f1apMsg == NULLP)
1617    {
1618       DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
1619       return RFAILED;
1620    }
1621
1622    f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
1623    CU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
1624    if(f1apMsg->choice.initiatingMessage == NULLP)
1625    {
1626       DU_LOG("\nERROR  -->  F1AP : Memory allocation for  F1AP-PDU failed");
1627       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
1628       return RFAILED;
1629    }
1630
1631    f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_DLRRCMessageTransfer;
1632    f1apMsg->choice.initiatingMessage->criticality = Criticality_ignore;
1633    f1apMsg->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_DLRRCMessageTransfer;
1634    dlRRCMsg = &f1apMsg->choice.initiatingMessage->value.choice.DLRRCMessageTransfer;
1635
1636    elementCnt = 4;
1637    dlRRCMsg->protocolIEs.list.count = elementCnt;
1638    dlRRCMsg->protocolIEs.list.size = elementCnt * sizeof(DLRRCMessageTransferIEs_t *);
1639
1640    /* Initialize the F1Setup members */
1641    CU_ALLOC(dlRRCMsg->protocolIEs.list.array, dlRRCMsg->protocolIEs.list.size);
1642    if(dlRRCMsg->protocolIEs.list.array == NULLP)
1643    {
1644       DU_LOG("\nERROR  -->  F1AP : Memory allocation for DL RRC MessageTransferIEs failed");
1645       CU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
1646       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
1647       return RFAILED;
1648    }
1649
1650    for(idx=0; idx<elementCnt; idx++)
1651    {
1652       CU_ALLOC(dlRRCMsg->protocolIEs.list.array[idx], sizeof(DLRRCMessageTransferIEs_t));
1653       if(dlRRCMsg->protocolIEs.list.array[idx] == NULLP)
1654       {
1655          for(ieId=0; ieId<idx; ieId++)
1656          {
1657             CU_FREE(dlRRCMsg->protocolIEs.list.array[ieId], sizeof(DLRRCMessageTransferIEs_t));
1658          }
1659          CU_FREE(dlRRCMsg->protocolIEs.list.array, dlRRCMsg->protocolIEs.list.size);
1660          CU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
1661          CU_FREE(f1apMsg,sizeof(F1AP_PDU_t));
1662          return RFAILED;
1663       }
1664    }
1665
1666    /* GNB CU UE F1AP ID */
1667    idx = 0;
1668    dlRRCMsg->protocolIEs.list.array[idx]->id  = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
1669    dlRRCMsg->protocolIEs.list.array[idx]->criticality  = Criticality_reject;
1670    dlRRCMsg->protocolIEs.list.array[idx]->value.present = DLRRCMessageTransferIEs__value_PR_GNB_CU_UE_F1AP_ID;
1671    dlRRCMsg->protocolIEs.list.array[idx]->value.choice.GNB_CU_UE_F1AP_ID = ueCb->gnbCuUeF1apId;
1672
1673    /* GNB DU UE F1AP ID */
1674    idx++;
1675    dlRRCMsg->protocolIEs.list.array[idx]->id  = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
1676    dlRRCMsg->protocolIEs.list.array[idx]->criticality  = Criticality_reject;
1677    dlRRCMsg->protocolIEs.list.array[idx]->value.present = DLRRCMessageTransferIEs__value_PR_GNB_DU_UE_F1AP_ID;
1678    dlRRCMsg->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID = ueCb->gnbDuUeF1apId;;
1679
1680    /* SRBID */
1681    idx++;
1682    dlRRCMsg->protocolIEs.list.array[idx]->id  = ProtocolIE_ID_id_SRBID;
1683    dlRRCMsg->protocolIEs.list.array[idx]->criticality  = Criticality_reject;
1684    dlRRCMsg->protocolIEs.list.array[idx]->value.present = DLRRCMessageTransferIEs__value_PR_SRBID;
1685    dlRRCMsg->protocolIEs.list.array[idx]->value.choice.SRBID = srbId;
1686
1687    /* RRCContainer */
1688    idx++;
1689    dlRRCMsg->protocolIEs.list.array[idx]->id  = ProtocolIE_ID_id_RRCContainer;
1690    dlRRCMsg->protocolIEs.list.array[idx]->criticality = Criticality_reject;
1691    dlRRCMsg->protocolIEs.list.array[idx]->value.present = DLRRCMessageTransferIEs__value_PR_RRCContainer;
1692    BuildDLRRCContainer(ueCb, rrcMsgType, &dlRRCMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer);
1693
1694    xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
1695
1696    /* Encode the F1SetupRequest type as APER */
1697    memset(encBuf, 0, ENC_BUF_MAX_LEN);
1698    encBufSize = 0;
1699    encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
1700          encBuf);
1701    /* Encode results */
1702    if(encRetVal.encoded == ENCODE_FAIL)
1703    {
1704       DU_LOG( "\nERROR  -->  F1AP : Could not encode DL RRC Message Transfer structure (at %s)\n",\
1705             encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
1706       return RFAILED;
1707    }
1708    else
1709    {
1710       DU_LOG("\nDEBUG  -->  F1AP : Created APER encoded buffer for DL RRC Message transfer\n");
1711       for(int i=0; i< encBufSize; i++)
1712       {
1713          DU_LOG("%x",encBuf[i]);
1714       }
1715    }
1716
1717    /* Sending  msg  */
1718    if(SendF1APMsg(CU_APP_MEM_REG,CU_POOL, duId)  !=  ROK)
1719    {
1720       DU_LOG("\nERROR  -->  F1AP : Sending  DL RRC Message Transfer Failed");
1721       return RFAILED;
1722    }
1723    freeDlRrcMessageTransfer(f1apMsg);
1724    return ROK;
1725 }/* End of BuildAndSendDLRRCMessageTransfer */
1726
1727 /*******************************************************************
1728  *
1729  * @brief Function to set the Dl RRC Msg Type
1730  *
1731  * @details
1732  *
1733  *    Function : setDlRRCMsgType
1734  *
1735  *    Functionality: Constructs the UE Setup Response and sends
1736  *                   it to the DU through SCTP.
1737  *
1738  * @params[in]
1739  *
1740  * @return ROK     - success
1741  *         RFAILED - failure
1742  *
1743  * ****************************************************************/
1744
1745 uint8_t setDlRRCMsgType(CuUeCb *ueCb)
1746 {
1747    uint8_t rrcMsgType = 0;
1748    switch(ueCb->f1apMsgDb.dlRrcMsgCount)
1749    {
1750       case RRC_SETUP:
1751          rrcMsgType = RRC_SETUP;
1752          break;
1753       case REGISTRATION_ACCEPT:
1754          rrcMsgType = REGISTRATION_ACCEPT;
1755          break;
1756       case UE_CONTEXT_SETUP_REQ:
1757          rrcMsgType = UE_CONTEXT_SETUP_REQ;
1758          break;
1759       case SECURITY_MODE_COMPLETE:
1760          rrcMsgType = SECURITY_MODE_COMPLETE;
1761          break;
1762       case RRC_RECONFIG:
1763          rrcMsgType = RRC_RECONFIG;
1764          break;
1765       case RRC_RECONFIG_COMPLETE:
1766          rrcMsgType = RRC_RECONFIG_COMPLETE;
1767          break;
1768       case UE_CONTEXT_MOD_REQ:
1769          rrcMsgType = UE_CONTEXT_MOD_REQ;
1770          break;
1771       default:
1772          break;
1773    }
1774    return rrcMsgType;
1775 }
1776
1777 /*******************************************************************
1778  *
1779  * @brief Extract configuration from CellGroupConfig
1780  *
1781  * @details
1782  *
1783  *    Function : extractCellGroupConfig
1784  *
1785  *    Functionality: Extract configuration from CellGroupConfig
1786  *        and store in local database
1787  *
1788  * @params[in] UE control block
1789  *             Cell Group Config
1790  *
1791  * @return ROK     - success
1792  *         RFAILED - failure
1793  *
1794  * ****************************************************************/
1795 uint8_t extractCellGroupConfig(CuUeCb *ueCb, CellGroupConfigRrc_t *cellGrpCfg)
1796 {
1797    uint8_t rbIdx, srbIdx, drbIdx;
1798    bool    srbFound, drbFound;
1799    SrbInfo *srbCfgDb = NULLP;
1800    DrbInfo *drbCfgDb = NULLP;
1801    RlcLcCfg *rlcLcCfgDb = NULLP;
1802    MacLcCfg *macLcCfgDb = NULLP;
1803    RLC_BearerConfig_t *rlcCfg = NULLP;
1804    RLC_Config_t *rlcLcCfg = NULLP;
1805    LogicalChannelConfig_t *macLcCfg = NULLP;
1806
1807    if(ueCb == NULLP)
1808    {
1809       DU_LOG("\nERROR  -->  F1AP: extractCellGroupConfig(): UE Cb is NULL");
1810       return RFAILED;
1811    }
1812
1813    if(cellGrpCfg == NULLP)
1814    {
1815       DU_LOG("\nERROR  -->  F1AP: extractCellGroupConfig(): cellGrpCfg is NULL");
1816       return RFAILED;
1817    }
1818
1819    for(rbIdx = 0; rbIdx < cellGrpCfg->rlc_BearerToAddModList->list.count; rbIdx++)
1820    {
1821       srbFound = false;
1822       drbFound = false;
1823
1824       rlcCfg = cellGrpCfg->rlc_BearerToAddModList->list.array[rbIdx];
1825
1826       /* Update SRB configuration in local DB */
1827       if(rlcCfg->servedRadioBearer->present == RLC_BearerConfig__servedRadioBearer_PR_srb_Identity)
1828       {
1829          /* Search if SRB entry is already present in DB */
1830          for(srbIdx = 0; srbIdx < ueCb->numSrb; srbIdx++)
1831          {
1832             if(ueCb->srbList[srbIdx].srbId == rlcCfg->servedRadioBearer->choice.srb_Identity)
1833             {
1834               srbCfgDb = &ueCb->srbList[srbIdx];
1835               srbFound = true;
1836               break;
1837             }
1838          }
1839
1840          /* If not, add SRB to UE CB's SRB list */
1841          if(!srbFound)
1842          {
1843             ueCb->srbList[ueCb->numSrb].srbId = rlcCfg->servedRadioBearer->choice.srb_Identity;
1844             srbCfgDb = &ueCb->srbList[ueCb->numSrb];
1845             ueCb->numSrb++;
1846          }
1847
1848          srbCfgDb->lcId = rlcCfg->logicalChannelIdentity;
1849          srbCfgDb->cfgSentToUe = false;
1850          rlcLcCfgDb = &srbCfgDb->rlcLcCfg;
1851          macLcCfgDb = &srbCfgDb->macLcCfg;
1852       }
1853
1854       /* Update DRB configuration in local DB */
1855       if(rlcCfg->servedRadioBearer->present == RLC_BearerConfig__servedRadioBearer_PR_drb_Identity)
1856       {
1857          /* Search if DRB entry is already present in DB */
1858          for(drbIdx = 0; drbIdx < ueCb->numDrb; drbIdx++)
1859          {
1860             if(ueCb->drbList[drbIdx].drbId == rlcCfg->servedRadioBearer->choice.drb_Identity)
1861             {
1862               drbCfgDb = &ueCb->drbList[drbIdx];
1863               drbFound = true;
1864               break;
1865             }
1866          }
1867
1868          /* If not, add DRB to UE CB's SRB list */
1869          if(!drbFound)
1870          {
1871             ueCb->drbList[ueCb->numDrb].drbId = rlcCfg->servedRadioBearer->choice.drb_Identity;
1872             drbCfgDb = &ueCb->drbList[ueCb->numDrb];
1873             ueCb->numDrb++;
1874          }
1875
1876          drbCfgDb->lcId = rlcCfg->logicalChannelIdentity;
1877          drbCfgDb->cfgSentToUe = false;
1878          rlcLcCfgDb = &drbCfgDb->rlcLcCfg;
1879          macLcCfgDb = &drbCfgDb->macLcCfg;
1880       }
1881
1882
1883       /* Update RLC configuration for this RB */
1884       rlcLcCfg = rlcCfg->rlc_Config;
1885       rlcLcCfgDb->rlcMode = rlcLcCfg->present;
1886       switch(rlcLcCfgDb->rlcMode)
1887       {
1888          case RLC_Config_PR_am:
1889             {
1890                rlcLcCfgDb->u.amCfg.ulAmCfg.snLenUl = *(rlcLcCfg->choice.am->ul_AM_RLC.sn_FieldLength);
1891                rlcLcCfgDb->u.amCfg.ulAmCfg.pollRetxTmr = rlcLcCfg->choice.am->ul_AM_RLC.t_PollRetransmit ;
1892                rlcLcCfgDb->u.amCfg.ulAmCfg.pollPdu = rlcLcCfg->choice.am->ul_AM_RLC.pollPDU ;
1893                rlcLcCfgDb->u.amCfg.ulAmCfg.pollByte = rlcLcCfg->choice.am->ul_AM_RLC.pollByte ;
1894                rlcLcCfgDb->u.amCfg.ulAmCfg.maxRetxTh = rlcLcCfg->choice.am->ul_AM_RLC.maxRetxThreshold ;
1895
1896                rlcLcCfgDb->u.amCfg.dlAmCfg.snLenDl = *(rlcLcCfg->choice.am->dl_AM_RLC.sn_FieldLength);
1897                rlcLcCfgDb->u.amCfg.dlAmCfg.reAssemTmr = rlcLcCfg->choice.am->dl_AM_RLC.t_Reassembly;
1898                rlcLcCfgDb->u.amCfg.dlAmCfg.statProhTmr = rlcLcCfg->choice.am->dl_AM_RLC.t_StatusProhibit;
1899                break;
1900             }
1901
1902          case RLC_Config_PR_um_Bi_Directional:
1903             {
1904                rlcLcCfgDb->u.umBiDirCfg.ulUmCfg.snLenUlUm = *(rlcLcCfg->choice.um_Bi_Directional->ul_UM_RLC.sn_FieldLength);
1905
1906                rlcLcCfgDb->u.umBiDirCfg.dlUmCfg.snLenDlUm = *(rlcLcCfg->choice.um_Bi_Directional->dl_UM_RLC.sn_FieldLength);
1907                rlcLcCfgDb->u.umBiDirCfg.dlUmCfg.reAssemTmr = rlcLcCfg->choice.um_Bi_Directional->dl_UM_RLC.t_Reassembly;
1908                break;
1909             }
1910       }
1911
1912       /* Update MAC configuration for this LC */
1913       macLcCfg = rlcCfg->mac_LogicalChannelConfig;
1914       macLcCfgDb->priority = macLcCfg->ul_SpecificParameters->priority ;
1915       macLcCfgDb->lcGroup = *(macLcCfg->ul_SpecificParameters->logicalChannelGroup) ;
1916       macLcCfgDb->schReqId = *(macLcCfg->ul_SpecificParameters->schedulingRequestID) ;
1917       macLcCfgDb->pbr = macLcCfg->ul_SpecificParameters->prioritisedBitRate ;
1918       macLcCfgDb->bsd = macLcCfg->ul_SpecificParameters->bucketSizeDuration ;
1919    }
1920    return ROK;
1921 }
1922
1923 /*******************************************************************
1924  *
1925  * @brief Function to decode DU to CU RRC container
1926  *
1927  * @details
1928  *
1929  *    Function : extractDuToCuRrcCont
1930  *
1931  *    Functionality: Function to decode DU to CU RRC container
1932  *
1933  * @params[in] UE Cb
1934  *             RRC conatiner octect string to be decoded
1935  *
1936  * @return ROK     - success
1937  *         RFAILED - failure
1938  *
1939  * ****************************************************************/
1940 uint8_t extractDuToCuRrcCont(CuUeCb *ueCb, OCTET_STRING_t rrcCont)
1941 {
1942    CellGroupConfigRrc_t  cellGrpCfg, *cellGrpCfgMsg = NULLP;
1943    asn_dec_rval_t rval; /* Decoder return value */
1944
1945    /* Decoding DU to CU RRC container octet string to cell group config */
1946    cellGrpCfgMsg = &cellGrpCfg;
1947    memset(cellGrpCfgMsg, 0, sizeof(CellGroupConfigRrc_t));
1948
1949    rval = aper_decode(0, &asn_DEF_CellGroupConfigRrc, (void **)&cellGrpCfgMsg, rrcCont.buf, rrcCont.size, 0, 0);
1950
1951    if(rval.code == RC_FAIL || rval.code == RC_WMORE)
1952    {
1953       DU_LOG("\nERROR  -->  F1AP : ASN decode failed");
1954       return RFAILED;
1955    }
1956    printf("\n");
1957    xer_fprint(stdout, &asn_DEF_CellGroupConfigRrc, cellGrpCfgMsg);
1958
1959    if((extractCellGroupConfig(ueCb, cellGrpCfgMsg)) != ROK)
1960    {
1961       DU_LOG("\nERROR  -->  F1AP : Failed to extract cell group config");
1962       return RFAILED;
1963    }
1964
1965    return ROK;
1966 }
1967
1968 /*******************************************************************
1969  *
1970  * @brief Function to build Initial UL RRC Message
1971  *
1972  * @details
1973  *
1974  *    Function : procInitULRRCMsg
1975  *
1976  *    Functionality: Function to build Initial UL RRC Message
1977  *
1978  * @params[in]
1979  *
1980  * @return ROK     - success
1981  *         RFAILED - failure
1982  *
1983  * ****************************************************************/
1984
1985 uint8_t procInitULRRCMsg(uint32_t duId, F1AP_PDU_t *f1apMsg)
1986 {
1987    uint8_t idx,cellIdx=0, duIdx=0, rrcMsgType, gnbDuUeF1apId;
1988    uint8_t ret =ROK;
1989    uint32_t nrCellId, crnti;
1990    DuDb     *duDb;
1991    CuCellCb *cellCb;
1992    CuUeCb   *ueCb;
1993    InitialULRRCMessageTransfer_t *initULRRCMsg = NULLP;
1994
1995    DU_LOG("\nINFO   -->  F1AP : filling the required values in DB in procInitULRRCMsg");
1996
1997    SEARCH_DU_DB(duIdx, duId, duDb);
1998    initULRRCMsg = &f1apMsg->choice.initiatingMessage->value.choice.InitialULRRCMessageTransfer;
1999
2000    for(idx=0; idx < initULRRCMsg->protocolIEs.list.count; idx++)
2001    {
2002       switch(initULRRCMsg->protocolIEs.list.array[idx]->id)
2003       {
2004          case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
2005             gnbDuUeF1apId = initULRRCMsg->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID;
2006             break;
2007
2008          case ProtocolIE_ID_id_NRCGI:
2009             nrCellId = initULRRCMsg->protocolIEs.list.array[idx]->value.choice.NRCGI.nRCellIdentity.buf[4] >>
2010                initULRRCMsg->protocolIEs.list.array[idx]->value.choice.NRCGI.nRCellIdentity.bits_unused;
2011             SEARCH_CELL_DB(cellIdx, duDb, nrCellId, cellCb);
2012             if(cellCb == NULLP)
2013                return RFAILED;
2014             break;
2015
2016          case ProtocolIE_ID_id_C_RNTI:
2017             crnti = initULRRCMsg->protocolIEs.list.array[idx]->value.choice.C_RNTI;
2018             if(duDb->ueCb[gnbDuUeF1apId-1].gnbDuUeF1apId == 0)
2019             {
2020                ueCb = &duDb->ueCb[gnbDuUeF1apId-1];
2021                memset(ueCb, 0, sizeof(CuUeCb));
2022                ueCb->cellCb = cellCb;
2023                ueCb->crnti = crnti;
2024                ueCb->gnbDuUeF1apId = gnbDuUeF1apId;
2025                ueCb->gnbCuUeF1apId = ++cuCb.gnbCuUeF1apIdGenerator;
2026                ueCb->state = UE_ATTACH_IN_PROGRESS;
2027                (duDb->numUe)++;
2028
2029                cellCb->ueCb[cellCb->numUe] = ueCb;
2030                cellCb->numUe++;
2031             }
2032             break;
2033
2034          case ProtocolIE_ID_id_RRCContainer:
2035             break;
2036
2037          case ProtocolIE_ID_id_DUtoCURRCContainer:
2038             {
2039                if((initULRRCMsg->protocolIEs.list.array[idx]->value.choice.DUtoCURRCContainer.size > 0) && \
2040                   (initULRRCMsg->protocolIEs.list.array[idx]->value.choice.DUtoCURRCContainer.buf != NULLP))
2041                {
2042                   DU_LOG("\nINFO  -->  Received Du to Cu RRC Container ");
2043                   ueCb->f1apMsgDb.duToCuContainer.size = initULRRCMsg->protocolIEs.list.array[idx]->value.choice.DUtoCURRCContainer.size;
2044                   CU_ALLOC(ueCb->f1apMsgDb.duToCuContainer.buf, ueCb->f1apMsgDb.duToCuContainer.size);
2045                   if(ueCb->f1apMsgDb.duToCuContainer.buf != NULLP)
2046                   {
2047                      memcpy(ueCb->f1apMsgDb.duToCuContainer.buf, \
2048                         initULRRCMsg->protocolIEs.list.array[idx]->value.choice.DUtoCURRCContainer.buf, \
2049                         ueCb->f1apMsgDb.duToCuContainer.size);
2050                   }
2051                   if((extractDuToCuRrcCont(ueCb, initULRRCMsg->protocolIEs.list.array[idx]->value.choice.DUtoCURRCContainer)) != ROK)
2052                   {
2053                      DU_LOG("\nERROR  --> F1AP : Failed to extract DU to CU RRC Container ");
2054                      ret = RFAILED;
2055                   }
2056                }
2057                else
2058                {
2059                   DU_LOG("\nERROR  -->  Failed to receive Du to Cu RRC Container ");
2060                   ret = RFAILED;
2061                }
2062                break;
2063             }
2064
2065          default:
2066             DU_LOG("\nERROR  -->  Invalid Event %ld", initULRRCMsg->protocolIEs.list.array[idx]->id);
2067             break;
2068       }
2069       if(ret == RFAILED)
2070          break;
2071    }
2072
2073    if(ret == ROK)
2074    {
2075       ueCb->f1apMsgDb.dlRrcMsgCount++;
2076       rrcMsgType = setDlRRCMsgType(ueCb);
2077       ret = BuildAndSendDLRRCMessageTransfer(duId, ueCb, SRB0, rrcMsgType);
2078    }
2079    return ret;
2080 }
2081
2082 /*******************************************************************
2083  *
2084  * @brief Builds Nrcgi
2085  *
2086  * @details
2087  *
2088  *    Function : BuildNrcgi
2089  *
2090  *    Functionality: Building the PLMN ID and NR Cell id
2091  *
2092  * @params[in] NRCGI_t *nrcgi
2093  * @return ROK     - success
2094  *         RFAILED - failure
2095  *
2096  * ****************************************************************/
2097 uint8_t BuildNrcgi(NRCGI_t *nrcgi, uint32_t nrCellId)
2098 {
2099    uint8_t ret;
2100    uint8_t unused_bits = 4;
2101    uint8_t byteSize = 5;
2102    uint8_t val = nrCellId << unused_bits;
2103
2104    /* Allocate Buffer Memory */
2105    nrcgi->pLMN_Identity.size = 3 * sizeof(uint8_t);
2106    CU_ALLOC(nrcgi->pLMN_Identity.buf, nrcgi->pLMN_Identity.size);
2107    if(nrcgi->pLMN_Identity.buf == NULLP)
2108    {
2109       return RFAILED;
2110    }
2111    ret = buildPlmnId(cuCb.cuCfgParams.plmn , nrcgi->pLMN_Identity.buf);
2112
2113    if(ret != ROK)
2114    {
2115       return RFAILED;
2116    }
2117    nrcgi->nRCellIdentity.size = byteSize * sizeof(uint8_t);
2118    CU_ALLOC(nrcgi->nRCellIdentity.buf, nrcgi->nRCellIdentity.size);
2119    if(nrcgi->nRCellIdentity.buf == NULLP)
2120    {
2121       return RFAILED;
2122    }
2123    fillBitString(&nrcgi->nRCellIdentity, unused_bits, byteSize, val);
2124
2125    return ROK;
2126 }
2127 /*******************************************************************
2128  *
2129  * @brief Builds Special cell list for UE Setup Request
2130  *
2131  * @details
2132  *
2133  *    Function : BuildSplCellList
2134  *
2135  *    Functionality: Constructs the Special Cell list for UESetReq
2136  *
2137  * @params[in] SCell_ToBeSetup_List_t *spCellLst
2138  *
2139  * @return ROK     - success
2140  *         RFAILED - failure
2141  *
2142  * ****************************************************************/
2143 uint8_t BuildSplCellList(CuUeCb *ueCb, SCell_ToBeSetup_List_t *spCellLst)
2144 {
2145    uint8_t  cellCnt;
2146    uint8_t  idx;
2147    uint8_t  ret;
2148    cellCnt = 1;
2149    spCellLst->list.count = cellCnt;
2150    spCellLst->list.size = cellCnt * sizeof(SCell_ToBeSetup_ItemIEs_t *);
2151    CU_ALLOC(spCellLst->list.array,spCellLst->list.size);
2152    if(spCellLst->list.array == NULLP)
2153    {
2154       return RFAILED;
2155    }
2156    for(idx=0; idx<cellCnt; idx++)
2157    {
2158       CU_ALLOC(spCellLst->list.array[idx],sizeof(SCell_ToBeSetup_ItemIEs_t));
2159       if(spCellLst->list.array[idx] == NULLP)
2160       {
2161          return RFAILED;
2162       }
2163    }
2164    idx = 0;
2165    spCellLst->list.array[idx]->id = ProtocolIE_ID_id_SCell_ToBeSetup_Item;
2166    spCellLst->list.array[idx]->criticality = Criticality_ignore;
2167    spCellLst->list.array[idx]->value.present = SCell_ToBeSetup_ItemIEs__value_PR_SCell_ToBeSetup_Item;
2168
2169    /* Special Cell ID -NRCGI */
2170    ret = BuildNrcgi(&spCellLst->list.array[idx]->value.choice.SCell_ToBeSetup_Item.sCell_ID, ueCb->cellCb->nrCellId);
2171    if(ret != ROK)
2172    {
2173       return RFAILED;
2174    }
2175    /*Special Cell Index*/
2176    spCellLst->list.array[idx]->value.choice.SCell_ToBeSetup_Item.sCellIndex = 1;
2177    return ROK;
2178 }/* End of BuildSplCellList*/
2179
2180 /*******************************************************************
2181  *
2182  * @brief Builds SRBS to be setup
2183  *
2184  * @details
2185  *
2186  *    Function : BuildSRBSetup
2187  *
2188  *    Functionality: Constructs the SRB's for UESetReq
2189  *
2190  * @params[in] SRBs_ToBeSetup_List_t *srbSet
2191  *
2192  * @return ROK     - success
2193  *         RFAILED - failure
2194  *
2195  * ****************************************************************/
2196 uint8_t BuildSRBSetup(CuUeCb *ueCb, SRBs_ToBeSetup_List_t *srbSet)
2197 {
2198    uint8_t idx;
2199    uint8_t srbCnt;
2200
2201    if(ueCb->state == UE_HANDOVER_IN_PROGRESS)
2202       srbCnt = ueCb->numSrb;
2203    else
2204       srbCnt = 1;
2205    srbSet->list.count = srbCnt;
2206    srbSet->list.size = srbCnt*sizeof(SRBs_ToBeSetup_ItemIEs_t *);
2207    CU_ALLOC(srbSet->list.array,srbSet->list.size);
2208    if(srbSet->list.array == NULLP)
2209    {
2210       DU_LOG("\nERROR  --> F1AP : BuildSRBSetup() : Memory allocation failed for SRB to be setup list's array");
2211       return RFAILED;
2212    }
2213
2214    for(idx=0; idx<srbCnt; idx++)
2215    {
2216       CU_ALLOC(srbSet->list.array[idx],sizeof(SRBs_ToBeSetup_ItemIEs_t));
2217       if(srbSet->list.array[idx] == NULLP)
2218       {
2219          DU_LOG("\nERROR  --> F1AP : BuildSRBSetup() : Memory allocation failed for SRB to be setup list's array element");
2220          return RFAILED;
2221       }
2222    }
2223
2224    if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
2225    {
2226       idx = 0;
2227       srbSet->list.array[idx]->id = ProtocolIE_ID_id_SRBs_ToBeSetup_Item;
2228       srbSet->list.array[idx]->criticality = Criticality_ignore;
2229       srbSet->list.array[idx]->value.present = SRBs_ToBeSetup_ItemIEs__value_PR_SRBs_ToBeSetup_Item;
2230       srbSet->list.array[idx]->value.choice.SRBs_ToBeSetup_Item.sRBID = 2;
2231       ueCb->srbList[ueCb->numSrb].srbId = srbSet->list.array[idx]->value.choice.SRBs_ToBeSetup_Item.sRBID;
2232       ueCb->numSrb++;
2233    }
2234    else
2235    {
2236       for(idx=0; idx<srbCnt; idx++)
2237       {
2238          srbSet->list.array[idx]->id = ProtocolIE_ID_id_SRBs_ToBeSetup_Item;
2239          srbSet->list.array[idx]->criticality = Criticality_ignore;
2240          srbSet->list.array[idx]->value.present = SRBs_ToBeSetup_ItemIEs__value_PR_SRBs_ToBeSetup_Item;
2241          srbSet->list.array[idx]->value.choice.SRBs_ToBeSetup_Item.sRBID = ueCb->srbList[idx].srbId;
2242       }
2243    }
2244    return ROK;
2245 }/* End of BuildSRBSetup*/
2246
2247 /*******************************************************************
2248  *
2249  * @brief Builds QOS Info for DRB Setum Item
2250  *
2251  * @details
2252  *
2253  *    Function : BuildQOSInfo
2254  *
2255  *    Functionality: Constructs the QOS Info for DRB Setup Item
2256  *
2257  * @params[in] QoSInformation_t *qosinfo
2258  *             int16_t pduSessionID
2259  *
2260  * @return ROK     - success
2261  *         RFAILED - failure
2262  *
2263  * ****************************************************************/
2264 uint8_t BuildQOSInfo(QosInfo *qosInfo, QoSFlowLevelQoSParameters_t *drbQos, uint8_t actionType, int16_t pduSessionID, bool hoInProgress)
2265 {
2266    uint8_t elementCnt = 0, qosCntIdx = 0;
2267    ProtocolExtensionContainer_4624P74_t *qosIeExt = NULLP;
2268
2269    /* NonDynamic5QIDescriptor */
2270    drbQos->qoS_Characteristics.present = QoS_Characteristics_PR_non_Dynamic_5QI;
2271    CU_ALLOC(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI,sizeof(NonDynamic5QIDescriptor_t));
2272    if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI == NULLP)
2273    {
2274       return RFAILED;
2275    }
2276
2277    if(hoInProgress)
2278       drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->fiveQI = qosInfo->nonDynFiveQI ;
2279    else
2280    {
2281       /*FiveQI*/
2282       if(actionType == ProtocolIE_ID_id_DRBs_ToBeModified_Item)
2283          drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->fiveQI = FIVE_QI_VALUE8;
2284       else
2285          drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->fiveQI = FIVE_QI_VALUE9;
2286
2287       qosInfo->nonDynFiveQI = drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->fiveQI;
2288    }
2289
2290    if(!hoInProgress)
2291    {
2292       /*AveragingWindow*/
2293       CU_ALLOC(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow, sizeof(AveragingWindow_t));
2294       if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow == NULLP)
2295       {
2296          return RFAILED;
2297       }
2298       *(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow) = 0;
2299       qosInfo->avgWindow = *(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow);
2300
2301       /*MaxDataBurstVolume*/
2302       CU_ALLOC(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume, sizeof(MaxDataBurstVolume_t));
2303       if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume == NULLP)
2304       {
2305          return RFAILED;
2306       }
2307       *(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume) = 0;
2308       qosInfo->maxBurstDataVol = *(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume);
2309    }
2310
2311    /*nRGRAN Allocation Retention Priority*/
2312    if(hoInProgress)
2313    {
2314       drbQos->nGRANallocationRetentionPriority.priorityLevel = qosInfo->priorityLevel;
2315       drbQos->nGRANallocationRetentionPriority.pre_emptionCapability = qosInfo->preemptionCapability;
2316       drbQos->nGRANallocationRetentionPriority.pre_emptionVulnerability = qosInfo->preemptionVulnerability;
2317    }
2318    else
2319    {
2320       drbQos->nGRANallocationRetentionPriority.priorityLevel = PriorityLevel_lowest;
2321       drbQos->nGRANallocationRetentionPriority.pre_emptionCapability = Pre_emptionCapability_may_trigger_pre_emption;
2322       drbQos->nGRANallocationRetentionPriority.pre_emptionVulnerability = Pre_emptionVulnerability_not_pre_emptable;
2323
2324       qosInfo->priorityLevel = PriorityLevel_lowest;
2325       qosInfo->preemptionCapability = Pre_emptionCapability_may_trigger_pre_emption;
2326       qosInfo->preemptionVulnerability = Pre_emptionVulnerability_not_pre_emptable;
2327    }
2328
2329    /* PDU session ID */
2330    if(!hoInProgress)
2331    {
2332       /*If PDU Session ID is INVALID thus not to be included in Qos IE, skip the PDU Session IE */
2333       if(pduSessionID <= INVALID_PDU_SESSION_ID)
2334       {
2335          DU_LOG("\nINFO  --> F1AP : Invalid PDU_SESSION_ID");
2336          return ROK;
2337       }
2338
2339       CU_ALLOC(drbQos->iE_Extensions, sizeof(ProtocolExtensionContainer_4624P74_t));
2340       qosIeExt = (ProtocolExtensionContainer_4624P74_t *)drbQos->iE_Extensions;
2341
2342       if(qosIeExt)
2343       {
2344          elementCnt = NUM_QOS_EXT;
2345          qosIeExt->list.count = elementCnt;
2346          qosIeExt->list.size = elementCnt * sizeof(QoSFlowLevelQoSParameters_ExtIEs_t *);
2347
2348          /*Initialize QoSFlowLevelQoSParameters_ExtIEs_t*/
2349          CU_ALLOC(qosIeExt->list.array, qosIeExt->list.size);
2350
2351          if(qosIeExt->list.array == NULLP)
2352          {
2353             DU_LOG("\nERROR  -->        F1AP : Memory allocation for QoSFlowLevelQoSParameters_ExtIEs_t failed");
2354             return  RFAILED;
2355          }
2356
2357          for(qosCntIdx=0; qosCntIdx < elementCnt; qosCntIdx++)
2358          {
2359             CU_ALLOC(qosIeExt->list.array[qosCntIdx], sizeof(QoSFlowLevelQoSParameters_ExtIEs_t));
2360             if(qosIeExt->list.array[qosCntIdx] == NULLP)
2361             {
2362                DU_LOG("\nERROR  -->     F1AP : Memory allocation for QoSFlowLevelQoSParameters_ExtIEs_t array failed");
2363                return  RFAILED;
2364             }
2365             /*Filling QoSFlowLevelQoSParameters_ExtIEs_t*/
2366             qosIeExt->list.array[qosCntIdx]->id = ProtocolIE_ID_id_PDUSessionID;
2367             /*Below Criticality mentioned in Spec38.473, 15.4.1 and later*/
2368             qosIeExt->list.array[qosCntIdx]->criticality = Criticality_ignore;
2369             qosIeExt->list.array[qosCntIdx]->extensionValue.present = \
2370                                                                       QoSFlowLevelQoSParameters_ExtIEs__extensionValue_PR_PDUSessionID;
2371             qosIeExt->list.array[qosCntIdx]->extensionValue.choice.PDUSessionID = (PDUSessionID_t)pduSessionID;
2372             qosInfo->pduSessionId = pduSessionID;
2373          }
2374       }
2375       else
2376       {
2377          DU_LOG("\nERROR  -->   F1AP : Memory allocation for QosIE_extension failed");
2378          return RFAILED;
2379       }
2380    }
2381    return ROK;
2382 }/*End of BuildQOSInfo*/
2383
2384 /*******************************************************************
2385  *
2386  * @brief Builds SNSSAI
2387  *
2388  * @details
2389  *
2390  *    Function : BuildSNSSAI
2391  *
2392  *    Functionality: Constructs the SNSSAI For DRB list
2393  *
2394  * @params[in] SNSSAI_t *snssai
2395  *             Snssai  *snssaiToCopy S-NSSAI from CuCfgParam to be copied
2396  *
2397  * @return ROK     - success
2398  *         RFAILED - failure
2399  *
2400  * ****************************************************************/
2401 uint8_t BuildSNSSAI(DrbInfo *drbInfo, SNSSAI_t *snssai, Snssai *snssaiToCopy, bool hoInProgress)
2402 {
2403    /*SNSSAI*/
2404    /*ssT*/
2405    snssai->sST.size = sizeof(uint8_t);
2406    CU_ALLOC(snssai->sST.buf, snssai->sST.size);
2407    if(snssai->sST.buf == NULLP)
2408    {
2409       return RFAILED;
2410    }
2411    if(!hoInProgress)
2412       memcpy(snssai->sST.buf, &snssaiToCopy->sst, snssai->sST.size);
2413    else
2414       memcpy(snssai->sST.buf, &drbInfo->snssai->sst, snssai->sST.size);
2415
2416    /*sD*/
2417    CU_ALLOC(snssai->sD, sizeof(OCTET_STRING_t));
2418    if(snssai->sD == NULLP)
2419    {
2420       return RFAILED;
2421    }
2422    snssai->sD->size = 3 * sizeof(uint8_t);
2423    CU_ALLOC(snssai->sD->buf, snssai->sD->size);
2424    if(snssai->sD->buf == NULLP)
2425    {
2426       return RFAILED;
2427    }
2428    if(!hoInProgress)
2429       memcpy(snssai->sD->buf, snssaiToCopy->sd, snssai->sD->size);
2430    else
2431       memcpy(snssai->sD->buf, drbInfo->snssai->sd, snssai->sD->size);
2432
2433    if(!hoInProgress)
2434       drbInfo->snssai = snssaiToCopy;
2435    return ROK;
2436 }/*End of BuildSNSSAI*/
2437
2438 /*******************************************************************
2439  *
2440  * @brief Builds the flow map.
2441  *
2442  * @details
2443  *
2444  *    Function : BuildFlowsMap
2445  *
2446  *    Functionality: Constructs the flowmap For DRB list
2447  *
2448  * @params[in] Flows_Mapped_To_DRB_List_t *flowMap
2449  *
2450  * @return ROK     - success
2451  *         RFAILED - failure
2452  *
2453  * ****************************************************************/
2454 uint8_t BuildFlowsMap(DrbInfo *drbInfo, Flows_Mapped_To_DRB_List_t *flowMap , uint8_t actionType, bool hoInProgress)
2455 {
2456    uint8_t  ret = ROK, idx = 0, flowCnt = 0, flowIdx = 0;
2457    FlowsMapped *qosFlow;
2458
2459    if(!hoInProgress)
2460       flowCnt = 1;
2461    else
2462       flowCnt = drbInfo->numFlowMap;
2463    flowMap->list.count = flowCnt;
2464    flowMap->list.size = flowCnt * sizeof(Flows_Mapped_To_DRB_Item_t *);
2465    CU_ALLOC(flowMap->list.array,flowMap->list.size);
2466    if(flowMap->list.array == NULLP)
2467    {
2468       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed for array in BuildFlowsMap()");
2469       return RFAILED;
2470    }
2471    for(idx=0; idx<flowCnt; idx++)
2472    {
2473       CU_ALLOC(flowMap->list.array[idx],sizeof(Flows_Mapped_To_DRB_Item_t));
2474       if(flowMap->list.array[idx] == NULLP)
2475       {
2476          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed for arrayIdx[%d] in BuildFlowsMap()", idx);
2477          return RFAILED;
2478       }
2479
2480       if(!hoInProgress)
2481       {
2482          flowMap->list.array[idx]->qoSFlowIdentifier = 0;
2483          if(actionType == ProtocolIE_ID_id_DRBs_ToBeModified_Item)
2484          {
2485             for(flowIdx =0; flowIdx < drbInfo->numFlowMap; flowIdx++)
2486             {
2487                if(drbInfo->flowMapList[flowIdx].qosFlowId == flowMap->list.array[idx]->qoSFlowIdentifier)
2488                {
2489                   qosFlow = &drbInfo->flowMapList[flowIdx];
2490                   break;
2491                }
2492             }
2493          }
2494          else
2495          {
2496             qosFlow = &drbInfo->flowMapList[drbInfo->numFlowMap];
2497             qosFlow->qosFlowId = flowMap->list.array[idx]->qoSFlowIdentifier;
2498          }
2499       }
2500       else
2501       {
2502          qosFlow = &drbInfo->flowMapList[idx];
2503          flowMap->list.array[idx]->qoSFlowIdentifier = qosFlow->qosFlowId;
2504       }
2505
2506       ret = BuildQOSInfo(&qosFlow->qos, &flowMap->list.array[idx]->qoSFlowLevelQoSParameters,\
2507             actionType, INVALID_PDU_SESSION_ID, hoInProgress);
2508       if(ret != ROK)
2509       {
2510          DU_LOG("\nERROR  -->  F1AP : Failed to Build QOS Info in BuildFlowsMap()");
2511          return RFAILED;
2512       }
2513
2514       if((!hoInProgress) && (actionType != ProtocolIE_ID_id_DRBs_ToBeModified_Item))
2515          drbInfo->numFlowMap++;
2516    }
2517    return ROK;
2518 }/*End of BuildFlowsMap*/
2519
2520 /*******************************************************************
2521  *
2522  * @brief Builds the Uplink Tunnel Info
2523  *
2524  * @details
2525  *
2526  *    Function : BuildULTnlInfo
2527  *
2528  *    Functionality: Constructs the UL TnlInfo For DRB list
2529  *
2530  * @params[in]  UPTNLInformation_ToBeSetup_List_t *ulInfo
2531  *
2532  * @return ROK     - success
2533  *         RFAILED - failure
2534  *
2535  * ****************************************************************/
2536 uint8_t BuildULTnlInfo(TnlInfo *ulUpTnlInfo, ULUPTNLInformation_ToBeSetup_List_t *ulInfo, bool hoInProgress)
2537 {
2538    uint8_t idx;
2539    uint8_t ulCnt;
2540
2541    ulCnt = 1;
2542    ulInfo->list.count = ulCnt;
2543    ulInfo->list.size = ulCnt * sizeof(ULUPTNLInformation_ToBeSetup_Item_t *);
2544    CU_ALLOC(ulInfo->list.array,ulInfo->list.size);
2545    if(ulInfo->list.array == NULLP)
2546    {
2547       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed for array in BuildULTnlInfo()");
2548       return RFAILED;
2549    }
2550    for(idx=0; idx<ulCnt; idx++)
2551    {
2552       CU_ALLOC(ulInfo->list.array[idx],sizeof(ULUPTNLInformation_ToBeSetup_Item_t));
2553       if(ulInfo->list.array[idx] == NULLP)
2554       {
2555          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed for arrayIdx [%d] in BuildULTnlInfo()", idx);
2556               return RFAILED;
2557       }
2558    }
2559    idx = 0;
2560    ulInfo->list.array[idx]->uLUPTNLInformation.present = UPTransportLayerInformation_PR_gTPTunnel;
2561    /*GTP TUNNEL*/
2562    CU_ALLOC(ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel, sizeof(GTPTunnel_t));
2563    if(ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel == NULLP)
2564    {
2565       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed for gTPTunnel in BuildULTnlInfo()");
2566       return RFAILED;
2567    }
2568    ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.size     = 4*sizeof(uint8_t);
2569    CU_ALLOC(ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf, \
2570       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.size);
2571    if(ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf == NULLP)
2572    {
2573       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed for gtp tunnel arrayIdx[%d] in BuildULTnlInfo()", idx);
2574       return RFAILED;
2575    }
2576
2577    if(!hoInProgress)
2578    {
2579       /* NOTE: Below IP address must be changed if running on different IP configuration */
2580       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[0] = 192;
2581       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[1] = 168;
2582       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[2] = 130;
2583       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[3] = 82;
2584       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.bits_unused = 0;
2585
2586       ulUpTnlInfo->address[0] = ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[0];
2587       ulUpTnlInfo->address[1] = ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[1];
2588       ulUpTnlInfo->address[2] = ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[2];
2589       ulUpTnlInfo->address[3] = ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[3];
2590    }
2591    else
2592    {
2593       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[0] = ulUpTnlInfo->address[0];
2594       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[1] = ulUpTnlInfo->address[1];
2595       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[2] = ulUpTnlInfo->address[2];
2596       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[3] = ulUpTnlInfo->address[3];
2597       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.bits_unused = 0;
2598    }
2599
2600    /*GTP TEID*/
2601    ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.size = 4 * sizeof(uint8_t);
2602    CU_ALLOC(ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf, \
2603       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.size);
2604    if(ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf == NULLP)
2605    {
2606       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed for gtp tunnel buffer in BuildULTnlInfo()");
2607       return RFAILED;
2608    }
2609
2610    if(!hoInProgress)
2611    {
2612       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[0] = 0;
2613       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[1] = 0;
2614       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[2] = 0;
2615       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[3] = cuCb.cuCfgParams.egtpParams.currTunnelId++;
2616
2617       ulUpTnlInfo->teId[0] = ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[0];
2618       ulUpTnlInfo->teId[1] = ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[1];
2619       ulUpTnlInfo->teId[2] = ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[2];
2620       ulUpTnlInfo->teId[3] = ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[3];
2621    }
2622    else
2623    {
2624       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[0] = ulUpTnlInfo->teId[0];
2625       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[1] = ulUpTnlInfo->teId[1];
2626       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[2] = ulUpTnlInfo->teId[2];
2627       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[3] = ulUpTnlInfo->teId[3];
2628    }
2629    return ROK;
2630 }/*End of BuildULTnlInfo*/
2631
2632 /*******************************************************************
2633  *
2634  * @brief Builds DRBS to be setup
2635  *
2636  * @details
2637  *
2638  *    Function : BuildDRBSetup
2639  *
2640  *    Functionality: Constructs the DRB's for UESetReq
2641  *
2642  * @params[in] DRBs_ToBeSetup_List_t *drbSet
2643  *
2644  * @return ROK     - success
2645  *         RFAILED - failure
2646  *
2647  * ****************************************************************/
2648 uint8_t BuildDRBSetup(CuUeCb *ueCb, DRBs_ToBeSetup_List_t *drbSet)
2649 {
2650    uint8_t idx = 0, extIeIdx = 0;
2651    uint8_t elementCnt = 0, drbCnt = 0;
2652    uint8_t BuildQOSInforet = 0,BuildSNSSAIret = 0;
2653    uint8_t BuildFlowsMapret =0, BuildULTnlInforet =0;
2654    DRBs_ToBeSetup_Item_t *drbSetItem;
2655    ProtocolExtensionContainer_4624P33_t *drbToBeSetupExt;
2656    DRBs_ToBeSetup_ItemExtIEs_t *drbToBeSetupExtIe = NULLP;
2657
2658    if(ueCb->state == UE_HANDOVER_IN_PROGRESS)
2659       drbCnt = ueCb->numDrb;
2660    else
2661       drbCnt = MAX_DRB_SET_UE_CONTEXT_SETUP_REQ;
2662    drbSet->list.count = drbCnt;
2663
2664    drbSet->list.size = drbCnt*sizeof(DRBs_ToBeSetup_ItemIEs_t *);
2665    CU_ALLOC(drbSet->list.array,drbSet->list.size);
2666    if(drbSet->list.array == NULLP)
2667    {
2668       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDRBSetup");
2669       return RFAILED;
2670    }
2671
2672    for(idx=0; idx<drbCnt; idx++)
2673    {
2674       CU_ALLOC(drbSet->list.array[idx],sizeof(DRBs_ToBeSetup_ItemIEs_t));
2675       if(drbSet->list.array[idx] == NULLP)
2676       {
2677          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDRBSetup for arry idx [%d]", idx);
2678          return RFAILED;
2679       }
2680
2681       drbSet->list.array[idx]->id = ProtocolIE_ID_id_DRBs_ToBeSetup_Item;
2682       drbSet->list.array[idx]->criticality = Criticality_ignore;
2683       drbSet->list.array[idx]->value.present = DRBs_ToBeSetup_ItemIEs__value_PR_DRBs_ToBeSetup_Item;
2684       drbSetItem = &drbSet->list.array[idx]->value.choice.DRBs_ToBeSetup_Item;
2685       /*dRBID*/
2686       if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
2687       {
2688          drbSetItem->dRBID = idx + 1;
2689          ueCb->drbList[ueCb->numDrb].drbId = drbSetItem->dRBID;
2690       }
2691       else
2692          drbSetItem->dRBID = ueCb->drbList[idx].drbId;
2693
2694       /*qoSInformation*/
2695       drbSetItem->qoSInformation.present = QoSInformation_PR_choice_extension;
2696       CU_ALLOC(drbSetItem->qoSInformation.choice.choice_extension,sizeof(QoSInformation_ExtIEs_t));
2697       if(drbSetItem->qoSInformation.choice.choice_extension == NULLP)
2698       {
2699          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed for QOS choice extension in BuildDRBSetup");
2700          return RFAILED;
2701       }
2702       drbSetItem->qoSInformation.choice.choice_extension->id = ProtocolIE_ID_id_DRB_Information;
2703       drbSetItem->qoSInformation.choice.choice_extension->criticality = Criticality_ignore;
2704       drbSetItem->qoSInformation.choice.choice_extension->value.present = QoSInformation_ExtIEs__value_PR_DRB_Information;
2705       if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
2706          BuildQOSInforet =  BuildQOSInfo(&ueCb->drbList[ueCb->numDrb].qos, &drbSetItem->qoSInformation.choice.\
2707                choice_extension->value.choice.DRB_Information.dRB_QoS, ProtocolIE_ID_id_DRBs_ToBeSetup_Item, PDU_SESSION_ID_1, FALSE);
2708       else
2709          BuildQOSInforet =  BuildQOSInfo(&ueCb->drbList[idx].qos, &drbSetItem->qoSInformation.choice.\
2710                choice_extension->value.choice.DRB_Information.dRB_QoS, ProtocolIE_ID_id_DRBs_ToBeSetup_Item, PDU_SESSION_ID_1, TRUE);
2711       if(BuildQOSInforet != ROK)
2712       {
2713          DU_LOG("\nERROR  -->  F1AP : Failed to build QOS Info in BuildDRBSetup");
2714          return RFAILED;
2715       }
2716
2717       /*SNSSAI*/
2718       if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
2719          BuildSNSSAIret = BuildSNSSAI(&ueCb->drbList[ueCb->numDrb], &drbSetItem->qoSInformation.choice.\
2720                choice_extension->value.choice.DRB_Information.sNSSAI, cuCb.snssaiList[0], FALSE);
2721       else
2722          BuildSNSSAIret = BuildSNSSAI(&ueCb->drbList[idx], &drbSetItem->qoSInformation.choice.\
2723                choice_extension->value.choice.DRB_Information.sNSSAI, cuCb.snssaiList[0], TRUE);
2724       if(BuildSNSSAIret != ROK)
2725       {
2726          DU_LOG("\nERROR  -->  F1AP : Failed to build SNSSAI Info in BuildDRBSetup");
2727          return RFAILED;
2728       }
2729
2730       /*Flows mapped to DRB List*/
2731       if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
2732          BuildFlowsMapret = BuildFlowsMap(&ueCb->drbList[ueCb->numDrb], &drbSetItem->qoSInformation.choice.choice_extension->\
2733                value.choice.DRB_Information.flows_Mapped_To_DRB_List, ProtocolIE_ID_id_DRBs_ToBeSetup_Item, FALSE);
2734       else
2735          BuildFlowsMapret = BuildFlowsMap(&ueCb->drbList[idx], &drbSetItem->qoSInformation.choice.choice_extension->\
2736                value.choice.DRB_Information.flows_Mapped_To_DRB_List, ProtocolIE_ID_id_DRBs_ToBeSetup_Item, TRUE);
2737       if(BuildFlowsMapret != ROK)
2738       {
2739          DU_LOG("\nERROR  -->  F1AP : Failed to build Flow Map Info in BuildDRBSetup");
2740          return RFAILED;
2741       }
2742
2743       /*ULUPTNLInformation To Be Setup List*/
2744       if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
2745          BuildULTnlInforet = BuildULTnlInfo(&ueCb->drbList[ueCb->numDrb].ulUpTnlInfo, &drbSetItem->uLUPTNLInformation_ToBeSetup_List,\
2746                FALSE);
2747       else
2748          BuildULTnlInforet = BuildULTnlInfo(&ueCb->drbList[idx].ulUpTnlInfo, &drbSetItem->uLUPTNLInformation_ToBeSetup_List,\
2749                TRUE);
2750       if(BuildULTnlInforet != ROK)
2751       {
2752          DU_LOG("\nERROR  -->  F1AP : Failed to build tunnel Info in BuildDRBSetup");
2753          return RFAILED;
2754       }
2755
2756       /*RLCMode*/
2757       if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
2758       {
2759          drbSetItem->rLCMode = RLCMode_rlc_um_bidirectional;
2760          ueCb->drbList[ueCb->numDrb].rlcMode = drbSetItem->rLCMode;
2761       }
2762       else
2763          drbSetItem->rLCMode = ueCb->drbList[idx].rlcMode;
2764
2765       /* DL PDCP SN Length */
2766       if(ueCb->state == UE_HANDOVER_IN_PROGRESS)
2767       {
2768          CU_ALLOC(drbToBeSetupExt, sizeof(ProtocolExtensionContainer_4624P33_t));
2769          if(!drbToBeSetupExt)
2770          {
2771             DU_LOG("\nERROR  -->  F1AP : Failed to allocate memory for extension IE list in BuildDRBSetup");
2772             return RFAILED;
2773          }
2774
2775          elementCnt = 1;
2776          drbToBeSetupExt->list.count = elementCnt;
2777          drbToBeSetupExt->list.size = drbToBeSetupExt->list.count * sizeof(DRBs_ToBeSetup_ItemExtIEs_t *);
2778
2779          CU_ALLOC(drbToBeSetupExt->list.array, drbToBeSetupExt->list.size);
2780          if(!drbToBeSetupExt->list.array)
2781          {
2782              DU_LOG("\nERROR  -->  F1AP : Failed to allocated memory for extension array in BuildDRBSetup");
2783              return RFAILED;
2784          }
2785
2786          for(extIeIdx=0; extIeIdx < drbToBeSetupExt->list.count; extIeIdx++)
2787          {
2788             CU_ALLOC(drbToBeSetupExt->list.array[extIeIdx], sizeof(DRBs_ToBeSetup_ItemExtIEs_t));
2789             if(!drbToBeSetupExt->list.array[extIeIdx])
2790             {
2791                DU_LOG("\nERROR  -->  F1AP : Failed to allocated memory for extension array element in BuildDRBSetup");
2792                return RFAILED;
2793             }
2794          }
2795
2796          extIeIdx = 0;
2797          drbToBeSetupExtIe = drbToBeSetupExt->list.array[extIeIdx];
2798
2799          drbToBeSetupExtIe->id = ProtocolIE_ID_id_DLPDCPSNLength;
2800          drbToBeSetupExtIe->criticality = Criticality_ignore;
2801          drbToBeSetupExtIe->extensionValue.present = DRBs_ToBeSetup_ItemExtIEs__extensionValue_PR_PDCPSNLength;
2802          drbToBeSetupExtIe->extensionValue.choice.PDCPSNLength = PDCPSNLength_twelve_bits;
2803          drbSetItem->iE_Extensions = drbToBeSetupExt;
2804       }
2805
2806       if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
2807          ueCb->numDrb++;
2808    }
2809    return ROK;
2810 }/* End of BuildDRBSetup*/
2811
2812 /*******************************************************************
2813  *
2814  * @brief Deallocating memory of function BuildAndSendUESetReq
2815  *
2816  * @details
2817  *
2818  *    Function : FreeNrcgi
2819  *
2820  *    Functionality: Deallocating memory for function BuildNrcgi
2821  *
2822  * @params[in] NRCGI_t *nrcgi
2823  *
2824  * @return void
2825  *
2826  *******************************************************************/
2827 void FreeNrcgi(NRCGI_t *nrcgi)
2828 {
2829    if(nrcgi->pLMN_Identity.buf != NULLP)
2830    {
2831       if(nrcgi->nRCellIdentity.buf != NULLP)
2832       {
2833          CU_FREE(nrcgi->nRCellIdentity.buf, nrcgi->nRCellIdentity.size);
2834       }
2835       CU_FREE(nrcgi->pLMN_Identity.buf, nrcgi->pLMN_Identity.size);
2836    }
2837 }
2838 /*******************************************************************
2839  *
2840  * @brief  Deallocating memory of function BuildAndSendUESetReq
2841  *
2842  * @details
2843  *
2844  *    Function : FreeSplCellList
2845  *
2846  *    Functionality: Deallocating memory for function BuildSplCellList
2847  *
2848  * @params[in] SCell_ToBeSetup_List_t *spCellLst
2849  *
2850  * @return void
2851  *
2852  *
2853  * *****************************************************************/
2854 void FreeSplCellList(SCell_ToBeSetup_List_t *spCellLst)
2855 {
2856    uint8_t  cellidx;
2857    if(spCellLst->list.array != NULLP)
2858    {
2859       for(cellidx=0; cellidx<spCellLst->list.count; cellidx++)
2860       {
2861          if(cellidx==0&&spCellLst->list.array[cellidx]!=NULLP)
2862          {
2863             FreeNrcgi(&spCellLst->list.array[cellidx]->value.choice.SCell_ToBeSetup_Item.sCell_ID);
2864          }
2865          if(spCellLst->list.array[cellidx]!=NULLP)
2866          {
2867             CU_FREE(spCellLst->list.array[cellidx],sizeof(SCell_ToBeSetup_ItemIEs_t));
2868          }
2869       }
2870       CU_FREE(spCellLst->list.array,spCellLst->list.size);
2871    }
2872 }
2873 /*******************************************************************
2874  *
2875  * @brief Deallocating memory of function BuildAndSendUESetReq
2876  *
2877  * @details
2878  *
2879  *    Function : FreeSRBSetup
2880  *
2881  *    Functionality: Deallocating memory for function BuildSRBSetup
2882  *
2883  * @params[in] SRBs_ToBeSetup_List_t *srbSet
2884  *
2885  * @return void
2886  *
2887  *
2888  * ******************************************************************/
2889 void FreeSRBSetup(SRBs_ToBeSetup_List_t *srbSet)
2890 {
2891    uint8_t srbidx;
2892    if(srbSet->list.array != NULLP)
2893    {
2894       for(srbidx=0; srbidx<srbSet->list.count; srbidx++)
2895       {
2896          if(srbSet->list.array[srbidx]!=NULLP)
2897          {
2898             CU_FREE(srbSet->list.array[srbidx],sizeof(SRBs_ToBeSetup_ItemIEs_t));
2899          }
2900       }
2901       CU_FREE(srbSet->list.array,srbSet->list.size);
2902    }
2903 }
2904 /*******************************************************************
2905  *
2906  * @brief Deallocating memory of function BuildAndSendUESetReq
2907  *
2908  * @details
2909  *
2910  *    Function : FreeQOSInfo
2911  *
2912  *    Functionality:  Deallocating memory for function BuildQOSInfo
2913  *
2914  * @params[in] QoSFlowLevelQoSParameters_t *drbQos
2915  *
2916  * @return void
2917  *
2918  * ****************************************************************/
2919 void FreeQOSInfo(QoSFlowLevelQoSParameters_t *drbQos)
2920 {
2921    ProtocolExtensionContainer_4624P74_t *qosIeExt = NULLP;
2922    uint8_t qosCntIdx = 0;
2923
2924    if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI != NULLP)
2925    {
2926       if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow!=NULLP)
2927       {
2928          if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume!=NULLP)
2929          {
2930             CU_FREE(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume,\
2931                   sizeof(MaxDataBurstVolume_t));
2932          }
2933          CU_FREE(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow,\
2934                sizeof(AveragingWindow_t));
2935       }
2936       CU_FREE(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI,\
2937             sizeof(NonDynamic5QIDescriptor_t));
2938    }
2939    if(drbQos->iE_Extensions)
2940    {
2941       qosIeExt = (ProtocolExtensionContainer_4624P74_t *)drbQos->iE_Extensions;
2942       if(qosIeExt->list.array != NULLP)
2943       {
2944          for(qosCntIdx=0; qosCntIdx <  qosIeExt->list.count; qosCntIdx++)
2945          {
2946             if(qosIeExt->list.array[qosCntIdx])
2947             {
2948                CU_FREE(qosIeExt->list.array[qosCntIdx], sizeof(QoSFlowLevelQoSParameters_ExtIEs_t));
2949             }
2950          }
2951          CU_FREE(qosIeExt->list.array, qosIeExt->list.size);
2952       }
2953
2954       CU_FREE(drbQos->iE_Extensions, sizeof(ProtocolExtensionContainer_4624P74_t));
2955    }
2956 }
2957 /*******************************************************************
2958  *
2959  * @brief Deallocating memory of function BuildAndSendUESetReq
2960  *
2961  * @details
2962  *
2963  *    Function : FreeULTnlInfo
2964  *
2965  *    Functionality:  Deallocating memory for function BuildULTnlInfo
2966  *
2967  * @params[in] ULUPTNLInformation_ToBeSetup_List_t *ulInfo
2968  *
2969  * @return void
2970  *
2971
2972  * ****************************************************************/
2973 void FreeULTnlInfo(ULUPTNLInformation_ToBeSetup_List_t *ulInfo)
2974 {
2975    uint8_t ulidx=0;
2976    if(ulInfo->list.array != NULLP)
2977    {
2978       for(ulidx=0; ulidx<ulInfo->list.count; ulidx++)
2979       {
2980          if(ulidx==0&&ulInfo->list.array[ulidx]!=NULLP)
2981          {
2982             if(ulInfo->list.array[ulidx]->uLUPTNLInformation.choice.gTPTunnel!=NULLP)
2983             {
2984                if(ulInfo->list.array[ulidx]->uLUPTNLInformation.choice.gTPTunnel->\
2985                      transportLayerAddress.buf != NULLP)
2986                {
2987                   if(ulInfo->list.array[ulidx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf\
2988                         !=NULLP)
2989                   {
2990                      CU_FREE(ulInfo->list.array[ulidx]->uLUPTNLInformation.choice.gTPTunnel->\
2991                            gTP_TEID.buf,ulInfo->list.array[ulidx]->uLUPTNLInformation.choice.\
2992                            gTPTunnel->gTP_TEID.size);
2993                   }
2994                   CU_FREE(ulInfo->list.array[ulidx]->uLUPTNLInformation.choice.gTPTunnel->\
2995                         transportLayerAddress.buf,ulInfo->list.array[ulidx]->\
2996                         uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.size);
2997                }
2998                CU_FREE(ulInfo->list.array[ulidx]->uLUPTNLInformation.choice.gTPTunnel,\
2999                      sizeof(GTPTunnel_t));
3000             }
3001          }
3002          if(ulInfo->list.array[ulidx]!=NULLP)
3003          {
3004             CU_FREE(ulInfo->list.array[ulidx],sizeof(ULUPTNLInformation_ToBeSetup_Item_t));
3005          }
3006       }
3007       CU_FREE(ulInfo->list.array,ulInfo->list.size);
3008    }
3009 }
3010 /*******************************************************************
3011  *
3012  * @brief Deallocating memory for BuildAndSendUESetReq
3013  *
3014  * @details
3015  *
3016  *    Function : FreeDRBSetup
3017  *
3018  *    Functionality:  Deallocating memory for BuildDRBSetup
3019  *
3020  * @params[in] DRBs_ToBeSetup_List_t *drbSet
3021  *
3022  * @return void
3023  *
3024  * ****************************************************************/
3025 void FreeDRBSetup(DRBs_ToBeSetup_List_t *drbSet)
3026 {
3027    DRBs_ToBeSetup_Item_t *drbSetItem;
3028    ProtocolExtensionContainer_4624P74_t *qosIeExt = NULLP;
3029
3030    uint8_t  flowidx = 0, drbidx = 0, qosCntIdx = 0;
3031
3032    /*BUG: Need to check drbSet->list.array is not Empty to procced with Deletion*/
3033    if(drbSet->list.array != NULLP)
3034    {
3035       for(drbidx=0; drbidx<drbSet->list.count; drbidx++)
3036       {
3037               if(drbSet->list.array[drbidx] != NULLP)
3038               {
3039                  drbSetItem =&drbSet->list.array[drbidx]->value.choice.DRBs_ToBeSetup_Item;
3040                  if(drbSetItem->qoSInformation.choice.choice_extension != NULLP)
3041                  {
3042                     if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
3043                                   qoS_Characteristics.choice.non_Dynamic_5QI !=NULLP)
3044                {
3045                    if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
3046                                           qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow!=NULLP)
3047                             {
3048                                if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
3049                                           qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume!=NULLP)
3050                                {
3051                                        if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sST.buf!=NULLP)
3052                                        {
3053                                           if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD!=NULLP)
3054                                           {
3055                                              if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD->buf!=NULLP)
3056                                              {
3057                                                      if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.\
3058                                                             flows_Mapped_To_DRB_List.list.array != NULLP)
3059                                                      {
3060                                                          for(flowidx=0;flowidx<drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.\
3061                                                                       flows_Mapped_To_DRB_List.list.count; flowidx++)
3062                                                          {
3063                                                              if(flowidx==0&&drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
3064                                                                            DRB_Information.flows_Mapped_To_DRB_List.list.array[flowidx]!=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!=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->averagingWindow!=NULLP)
3073                                                                          {
3074                                                                                  if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
3075                                                                                  DRB_Information.flows_Mapped_To_DRB_List.list.array[flowidx]->qoSFlowLevelQoSParameters.\
3076                                                                                   qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume!=NULLP)
3077                                                                                   {
3078                                                                                       FreeULTnlInfo(&drbSetItem->uLUPTNLInformation_ToBeSetup_List);
3079                                                                                       CU_FREE(drbSetItem->uLConfiguration,sizeof(ULConfiguration_t));
3080
3081                                                                                       CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
3082                                                                                                    DRB_Information.flows_Mapped_To_DRB_List.list.array[flowidx]->qoSFlowLevelQoSParameters.\
3083                                                                                                    qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume,\
3084                                                                                                    sizeof(MaxDataBurstVolume_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->averagingWindow,sizeof(AveragingWindow_t));
3089                                                                          }
3090                                                                          CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
3091                                                                                        DRB_Information.flows_Mapped_To_DRB_List.list.array[flowidx]->qoSFlowLevelQoSParameters.\
3092                                                                                        qoS_Characteristics.choice.non_Dynamic_5QI,sizeof(NonDynamic5QIDescriptor_t));
3093                                                                      }
3094                                                             }
3095                                                             if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
3096                                                                      DRB_Information.flows_Mapped_To_DRB_List.list.array[flowidx]!=NULLP)
3097                                                             {
3098                                                                     CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
3099                                                                                   DRB_Information.flows_Mapped_To_DRB_List.list.array[flowidx],sizeof(Flows_Mapped_To_DRB_Item_t));
3100                                                             }
3101                                                         }
3102                                                         CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.\
3103                                                                       flows_Mapped_To_DRB_List.list.array,drbSetItem->qoSInformation.choice.choice_extension->value.\
3104                                                                       choice.DRB_Information.flows_Mapped_To_DRB_List.list.size);
3105                                                      }
3106                                                      CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD->buf,\
3107                                                              drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD->size);
3108                                             }
3109                                             CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD,\
3110                                                               sizeof(OCTET_STRING_t));
3111                                        }
3112                                        CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sST.buf,\
3113                                                     drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sST.size);
3114                                     }
3115                                     CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
3116                                             qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume,sizeof(MaxDataBurstVolume_t));
3117                             }
3118                        CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
3119                                          qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow,sizeof(AveragingWindow_t));
3120                          }
3121                          CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
3122                                        qoS_Characteristics.choice.non_Dynamic_5QI, sizeof(NonDynamic5QIDescriptor_t));
3123              }
3124              if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
3125                         iE_Extensions != NULLP)
3126              {
3127                 qosIeExt = (ProtocolExtensionContainer_4624P74_t *)drbSetItem->qoSInformation.choice.\
3128                                     choice_extension->value.choice.DRB_Information.dRB_QoS.iE_Extensions;
3129                  if(qosIeExt->list.array != NULLP)
3130                  {
3131                    for(qosCntIdx=0; qosCntIdx < qosIeExt->list.count; qosCntIdx++)
3132                    {
3133                       if(qosIeExt->list.array[qosCntIdx] != NULLP)
3134                       {
3135                          CU_FREE(qosIeExt->list.array[qosCntIdx], sizeof(QoSFlowLevelQoSParameters_ExtIEs_t));
3136                       }
3137                     }
3138                     CU_FREE(qosIeExt->list.array, qosIeExt->list.size);
3139                   }
3140                   CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
3141                                    iE_Extensions, sizeof(ProtocolExtensionContainer_4624P74_t));
3142               }
3143
3144                   CU_FREE(drbSetItem->qoSInformation.choice.choice_extension,sizeof(QoSInformation_ExtIEs_t));
3145                 }
3146                 CU_FREE(drbSet->list.array[drbidx],sizeof(DRBs_ToBeSetup_ItemIEs_t));
3147               }
3148       }
3149       CU_FREE(drbSet->list.array,drbSet->list.size);
3150    }
3151 }
3152
3153
3154 /*******************************************************************
3155  *
3156  * @brief Free the UE Setup Request
3157  *
3158  * @details
3159  *
3160  *    Function : FreeUeContextSetupReq
3161  *
3162  *    Functionality: Deallocate the memory of BuildUESetReq
3163  *
3164  * @params[in]  F1AP_PDU_t  *f1apMsg
3165  *
3166  * @return void
3167  *
3168  *
3169  * ****************************************************************/
3170 void FreeUeContextSetupReq(F1AP_PDU_t  *f1apMsg)
3171 {
3172    uint8_t idx, ieId;
3173    UEContextSetupRequest_t  *ueSetReq = NULLP;
3174
3175    if(f1apMsg != NULLP)
3176    {
3177       if(f1apMsg->choice.initiatingMessage != NULLP)
3178       {
3179          ueSetReq = &f1apMsg->choice.initiatingMessage->value.choice.UEContextSetupRequest;
3180          if(ueSetReq->protocolIEs.list.array != NULLP)
3181          {
3182             for(idx = 0; idx < ueSetReq->protocolIEs.list.count; idx++)
3183             {
3184                if(ueSetReq->protocolIEs.list.array[idx])
3185                {
3186                   switch(ueSetReq->protocolIEs.list.array[idx]->id)
3187                   {
3188                      case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
3189                         break;
3190                      case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
3191                         break;
3192                      case ProtocolIE_ID_id_SpCell_ID:
3193                         FreeNrcgi(&ueSetReq->protocolIEs.list.array[idx]->value.choice.NRCGI);
3194                         break;
3195                      case ProtocolIE_ID_id_ServCellIndex:
3196                         break;
3197                      case ProtocolIE_ID_id_SpCellULConfigured:
3198                         break;
3199                      case ProtocolIE_ID_id_CUtoDURRCInformation:
3200                         FreeCuToDuInfo(&ueSetReq->protocolIEs.list.array[idx]->value.choice.CUtoDURRCInformation);
3201                         break;
3202                      case ProtocolIE_ID_id_SCell_ToBeSetup_List:
3203                         FreeSplCellList(&ueSetReq->protocolIEs.list.array[idx]->value.choice.SCell_ToBeSetup_List);
3204                         break;
3205                      case ProtocolIE_ID_id_SRBs_ToBeSetup_List:
3206                         FreeSRBSetup(&ueSetReq->protocolIEs.list.array[idx]->value.choice.SRBs_ToBeSetup_List);
3207                         break;
3208                      case ProtocolIE_ID_id_DRBs_ToBeSetup_List:
3209                         FreeDRBSetup(&ueSetReq->protocolIEs.list.array[idx]->value.choice.DRBs_ToBeSetup_List);
3210                         break;
3211                      case ProtocolIE_ID_id_RRCContainer:
3212                         if(ueSetReq->protocolIEs.list.array[idx]->value.choice.RRCContainer.buf != NULLP)
3213                         {
3214                            CU_FREE(ueSetReq->protocolIEs.list.array[idx]->value.choice.RRCContainer.buf, \
3215                                  ueSetReq->protocolIEs.list.array[idx]->value.choice.RRCContainer.size);
3216                         }
3217                         break;
3218                      case ProtocolIE_ID_id_GNB_DU_UE_AMBR_UL:
3219                         CU_FREE(ueSetReq->protocolIEs.list.array[idx]->value.choice.BitRate.buf,\
3220                               ueSetReq->protocolIEs.list.array[idx]->value.choice.BitRate.size);
3221                         break;
3222                      default:
3223                         DU_LOG("\nERROR  -->  F1AP: Invalid event type %ld", ueSetReq->protocolIEs.list.array[idx]->id);
3224                         break;
3225                   }
3226                }
3227                /*BUG: Break is causing to exit the for Loop before complete traversing and freeing of each IE*/
3228             }
3229             for(ieId=0; ieId<idx; ieId++)
3230             {
3231                if(ueSetReq->protocolIEs.list.array[ieId] != NULLP)
3232                {
3233                   CU_FREE(ueSetReq->protocolIEs.list.array[ieId],sizeof(UEContextSetupRequestIEs_t));
3234                }
3235             }
3236             CU_FREE(ueSetReq->protocolIEs.list.array,ueSetReq->protocolIEs.list.size);
3237          }
3238          CU_FREE(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
3239       }
3240       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
3241    }
3242 }
3243
3244 /**Filling cell group info **/
3245 /*******************************************************************
3246  *
3247  * @brief Build Control resource set to add/modify list
3248  *
3249  * @details
3250  *
3251  *    Function : BuildControlRSetToAddModList
3252  *
3253  *    Functionality: Build Control resource set to add/modify list
3254  *
3255  * @params[in]
3256  * struct PDCCH_Config__controlResourceSetToAddModList *controlRSetList
3257  *
3258  * @return ROK     - success
3259  *         RFAILED - failure
3260  *
3261  * ****************************************************************/
3262    uint8_t BuildControlRSetToAddModList
3263 (
3264  struct PDCCH_Config__controlResourceSetToAddModList *controlRSetList
3265  )
3266 {
3267    uint8_t idx;
3268    uint8_t elementCnt;
3269    uint8_t numBytes, bitsUnused;
3270    struct ControlResourceSet *controlRSet;
3271    uint8_t freqDomainResource[FREQ_DOM_RSRC_SIZE] = {0};
3272    uint8_t coreset0EndPrb, coreset1StartPrb, coreset1NumPrb;
3273
3274    elementCnt = 1;
3275    controlRSetList->list.count = elementCnt;
3276    controlRSetList->list.size = \
3277                                 elementCnt * sizeof(struct ControlResourceSet *);
3278
3279    controlRSetList->list.array = NULLP;
3280    CU_ALLOC(controlRSetList->list.array, controlRSetList->list.size);
3281    if(!controlRSetList->list.array)
3282    {
3283       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3284       return RFAILED;
3285    }
3286
3287    for(idx = 0; idx < elementCnt; idx++)
3288    {
3289       controlRSetList->list.array[idx] = NULLP;
3290       CU_ALLOC(controlRSetList->list.array[idx], sizeof(struct ControlResourceSet));
3291       if(!controlRSetList->list.array[idx])
3292       {
3293          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3294          return RFAILED;
3295       }
3296    }
3297
3298    idx=0;
3299    controlRSet = controlRSetList->list.array[idx];
3300    controlRSet->controlResourceSetId = PDCCH_CTRL_RSRC_SET_ONE_ID;
3301
3302    /* Values harcoded according to our design:
3303     * size 6 bytes
3304     * 3 LSBs unsued
3305     * Bit string stored ff0000000000
3306     */
3307    numBytes = 6;
3308    bitsUnused = 3;
3309    controlRSet->frequencyDomainResources.size = numBytes * sizeof(uint8_t);
3310    controlRSet->frequencyDomainResources.buf = NULLP;
3311    CU_ALLOC(controlRSet->frequencyDomainResources.buf, \
3312          controlRSet->frequencyDomainResources.size);
3313    if(!controlRSet->frequencyDomainResources.buf)
3314    {
3315       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3316       return RFAILED;
3317    }
3318
3319    memset(controlRSet->frequencyDomainResources.buf, 0, FREQ_DOM_RSRC_SIZE);
3320    coreset0EndPrb = CORESET0_END_PRB;
3321    coreset1StartPrb = coreset0EndPrb + 6;
3322    coreset1NumPrb = CORESET1_NUM_PRB;
3323    /* calculate the PRBs */
3324    fillCoresetFeqDomAllocMap(((coreset1StartPrb)/6), (coreset1NumPrb/6), freqDomainResource);
3325    memcpy(controlRSet->frequencyDomainResources.buf, freqDomainResource, FREQ_DOM_RSRC_SIZE);
3326    controlRSet->frequencyDomainResources.bits_unused = bitsUnused;
3327
3328    controlRSet->duration = PDCCH_CTRL_RSRC_SET_ONE_DURATION;
3329    controlRSet->cce_REG_MappingType.present = \
3330                                               ControlResourceSet__cce_REG_MappingType_PR_nonInterleaved;
3331
3332    controlRSet->precoderGranularity = PDCCH_CTRL_RSRC_SET_ONE_PRECOD_GRANULARITY;
3333    controlRSet->tci_StatesPDCCH_ToAddList = NULLP;
3334    controlRSet->tci_StatesPDCCH_ToReleaseList = NULLP;
3335    controlRSet->tci_PresentInDCI = NULLP;
3336 #if 0
3337    uint8_t tciStateIdx;
3338
3339    CU_ALLOC(controlRset->tci_StatesPDCCH_ToAddList, \
3340          sizeof(struct ControlResourceSet__tci_StatesPDCCH_ToAddList));
3341    if(!controlRset->tci_StatesPDCCH_ToAddList)
3342    {
3343       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3344       return RFAILED;
3345    }
3346
3347    elementCnt = 1;
3348    controlRset->tci_StatesPDCCH_ToAddList->list.count = elementCnt;
3349    controlRset->tci_StatesPDCCH_ToAddList->list.size = elementCnt * sizeof(TCI_StateId_t *);
3350    CU_ALLOC(controlRset->tci_StatesPDCCH_ToAddList->list.array, \
3351          controlRset->tci_StatesPDCCH_ToAddList->list.size)
3352       if(!controlRset->tci_StatesPDCCH_ToAddList->list.array)
3353       {
3354          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3355          return RFAILED;
3356       }
3357
3358    for(tciStateIdx = 0; tciStateIdx <elementCntl; tciStateIdx++)
3359    {
3360       CU_ALLOC(controlRset->tci_StatesPDCCH_ToAddList->list.array[tciStateIdx], sizeof(TCI_StateId_t));
3361       if(!controlRset->tci_StatesPDCCH_ToAddList->list.array[tciStateIdx])
3362       {
3363          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3364          return RFAILED;
3365       }
3366    }
3367
3368    tciStateIdx = 0;
3369    /* TODO */
3370    *(controlRset->tci_StatesPDCCH_ToAddList->list.array[tciStateIdx]);
3371
3372    CU_ALLOC(controlRset->tci_PresentInDCI, sizeof(long));
3373    if(!controlRset->tci_PresentInDCI)
3374    {
3375       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3376       return RFAILED;
3377    }
3378    /* TODO */
3379    *(controlRset->tci_PresentInDCI);
3380 #endif
3381
3382    controlRSet->pdcch_DMRS_ScramblingID = NULLP;
3383    CU_ALLOC(controlRSet->pdcch_DMRS_ScramblingID, sizeof(long));
3384    if(!controlRSet->pdcch_DMRS_ScramblingID)
3385    {
3386       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3387       return RFAILED;
3388    }
3389    *(controlRSet->pdcch_DMRS_ScramblingID) = SCRAMBLING_ID;
3390
3391    return ROK;
3392 } /* End BuildControlRSetToAddModList */
3393
3394 /*******************************************************************
3395  *
3396  * @brief Build search space to add/modify list
3397  *
3398  * @details
3399  *
3400  *    Function : BuildSearchSpcToAddModList
3401  *
3402  *    Functionality: Build search space to add/modify list
3403  *
3404  * @params[in]
3405  * @return ROK     - success
3406  *         RFAILED - failure
3407  *
3408  * ****************************************************************/
3409    uint8_t BuildSearchSpcToAddModList
3410 (
3411  struct PDCCH_Config__searchSpacesToAddModList *searchSpcList
3412  )
3413 {
3414    uint8_t idx;
3415    uint8_t numBytes;
3416    uint8_t byteIdx;
3417    uint8_t bitsUnused;
3418    uint8_t elementCnt;
3419    struct SearchSpace *searchSpc;
3420
3421    elementCnt = 1;
3422    searchSpcList->list.count = elementCnt;
3423    searchSpcList->list.size = elementCnt * sizeof(struct SearchSpace *);
3424
3425    searchSpcList->list.array = NULLP;
3426    CU_ALLOC(searchSpcList->list.array, searchSpcList->list.size);
3427    if(!searchSpcList->list.array)
3428    {
3429       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3430       return RFAILED;
3431    }
3432
3433    for(idx = 0; idx < elementCnt; idx++)
3434    {
3435       searchSpcList->list.array[idx] = NULLP;
3436       CU_ALLOC(searchSpcList->list.array[idx], sizeof(struct SearchSpace));
3437       if(!searchSpcList->list.array[idx])
3438       {
3439          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3440          return RFAILED;
3441       }
3442    }
3443
3444    idx = 0;
3445    searchSpc = searchSpcList->list.array[idx];
3446
3447    searchSpc->searchSpaceId = PDCCH_SRCH_SPC_TWO_ID;
3448
3449    searchSpc->controlResourceSetId = NULLP;
3450    CU_ALLOC(searchSpc->controlResourceSetId, sizeof(ControlResourceSetId_t));
3451    if(!searchSpc->controlResourceSetId)
3452    {
3453       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3454       return RFAILED;
3455    }
3456    *(searchSpc->controlResourceSetId) = PDCCH_CTRL_RSRC_SET_ONE_ID;
3457
3458    searchSpc->monitoringSlotPeriodicityAndOffset = NULLP;
3459    CU_ALLOC(searchSpc->monitoringSlotPeriodicityAndOffset, \
3460          sizeof(struct SearchSpace__monitoringSlotPeriodicityAndOffset));
3461    if(!searchSpc->monitoringSlotPeriodicityAndOffset)
3462    {
3463       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3464       return RFAILED;
3465    }
3466    searchSpc->monitoringSlotPeriodicityAndOffset->present = \
3467                                                             SearchSpace__monitoringSlotPeriodicityAndOffset_PR_sl1;
3468
3469    searchSpc->duration = NULLP;
3470    searchSpc->monitoringSymbolsWithinSlot = NULLP;
3471    CU_ALLOC(searchSpc->monitoringSymbolsWithinSlot, sizeof(BIT_STRING_t));
3472    if(!searchSpc->monitoringSymbolsWithinSlot)
3473    {
3474       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3475       return RFAILED;
3476    }
3477
3478    /* Values taken from reference logs :
3479     * size 2 bytes
3480     * 2 LSBs unsued
3481     * Bit string stores 8000
3482     */
3483    numBytes = 2;
3484    bitsUnused = 2;
3485
3486    searchSpc->monitoringSymbolsWithinSlot->size = numBytes * sizeof(uint8_t);
3487    searchSpc->monitoringSymbolsWithinSlot->buf = NULLP;
3488    CU_ALLOC(searchSpc->monitoringSymbolsWithinSlot->buf, \
3489          searchSpc->monitoringSymbolsWithinSlot->size);
3490    if(!searchSpc->monitoringSymbolsWithinSlot->buf)
3491    {
3492       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3493       return RFAILED;
3494    }
3495
3496    byteIdx = 0;
3497    searchSpc->monitoringSymbolsWithinSlot->buf[byteIdx++] = \
3498                                                             PDCCH_SYMBOL_WITHIN_SLOT /* setting MSB to 128 i.e. 0x80 */;
3499    searchSpc->monitoringSymbolsWithinSlot->buf[byteIdx++] = 0;
3500    searchSpc->monitoringSymbolsWithinSlot->bits_unused = bitsUnused;
3501
3502    searchSpc->nrofCandidates = NULLP;
3503    CU_ALLOC(searchSpc->nrofCandidates, sizeof(struct SearchSpace__nrofCandidates));
3504    if(!searchSpc->nrofCandidates)
3505    {
3506       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3507       return RFAILED;
3508    }
3509
3510    searchSpc->nrofCandidates->aggregationLevel1 = \
3511                                                   PDCCH_SRCH_SPC_TWO_AGG_LVL1_CANDIDATE;
3512    searchSpc->nrofCandidates->aggregationLevel2 = \
3513                                                   PDCCH_SRCH_SPC_TWO_AGG_LVL2_CANDIDATE;
3514    searchSpc->nrofCandidates->aggregationLevel4 = \
3515                                                   PDCCH_SRCH_SPC_TWO_AGG_LVL4_CANDIDATE;
3516    searchSpc->nrofCandidates->aggregationLevel8 = \
3517                                                   PDCCH_SRCH_SPC_TWO_AGG_LVL8_CANDIDATE;
3518    searchSpc->nrofCandidates->aggregationLevel16 = \
3519                                                    PDCCH_SRCH_SPC_TWO_AGG_LVL16_CANDIDATE;
3520
3521    searchSpc->searchSpaceType = NULLP;
3522    CU_ALLOC(searchSpc->searchSpaceType, sizeof(struct SearchSpace__searchSpaceType));
3523    if(!searchSpc->searchSpaceType)
3524    {
3525       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3526       return RFAILED;
3527    }
3528
3529    searchSpc->searchSpaceType->present = SearchSpace__searchSpaceType_PR_ue_Specific;
3530
3531    searchSpc->searchSpaceType->choice.ue_Specific = NULLP;
3532    CU_ALLOC(searchSpc->searchSpaceType->choice.ue_Specific, \
3533          sizeof(struct SearchSpace__searchSpaceType__ue_Specific));
3534    if(!searchSpc->searchSpaceType->choice.ue_Specific)
3535    {
3536       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3537       return RFAILED;
3538    }
3539    searchSpc->searchSpaceType->choice.ue_Specific->dci_Formats = \
3540                                                                  PDCCH_SRCH_SPC_TWO_UE_SPEC_DCI_FORMAT;
3541
3542    return ROK;
3543 }/* End BuildSearchSpcToAddModList */
3544
3545 /*******************************************************************
3546  *
3547  * @brief Builds BWP DL dedicated PDCCH config
3548  *
3549  * @details
3550  *
3551  *    Function : BuildBWPDlDedPdcchCfg
3552  *
3553  *    Functionality: Builds BWP DL dedicated PDCCH config
3554  *
3555  * @params[in] struct PDCCH_Config *pdcchCfg
3556  *
3557  * @return ROK     - success
3558  *         RFAILED - failure
3559  *
3560  * ****************************************************************/
3561 uint8_t BuildBWPDlDedPdcchCfg(struct PDCCH_Config *pdcchCfg)
3562 {
3563    pdcchCfg->controlResourceSetToAddModList = NULLP;
3564    CU_ALLOC(pdcchCfg->controlResourceSetToAddModList, \
3565          sizeof(struct PDCCH_Config__controlResourceSetToAddModList));
3566    if(!pdcchCfg->controlResourceSetToAddModList)
3567    {
3568       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdcchCfg");
3569       return RFAILED;
3570    }
3571
3572    if(BuildControlRSetToAddModList(pdcchCfg->controlResourceSetToAddModList) != ROK)
3573    {
3574       return RFAILED;
3575    }
3576
3577    pdcchCfg->controlResourceSetToReleaseList = NULLP;
3578
3579    pdcchCfg->searchSpacesToAddModList = NULLP;
3580    CU_ALLOC(pdcchCfg->searchSpacesToAddModList, \
3581          sizeof(struct PDCCH_Config__searchSpacesToAddModList));
3582    if(!pdcchCfg->searchSpacesToAddModList)
3583    {
3584       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdcchCfg");
3585       return RFAILED;
3586    }
3587
3588    if(BuildSearchSpcToAddModList(pdcchCfg->searchSpacesToAddModList) != ROK)
3589    {
3590       return RFAILED;
3591    }
3592
3593    pdcchCfg->searchSpacesToReleaseList = NULLP;
3594    pdcchCfg->downlinkPreemption = NULLP;
3595    pdcchCfg->tpc_PUSCH = NULLP;
3596    pdcchCfg->tpc_PUCCH = NULLP;
3597    pdcchCfg->tpc_SRS = NULLP;
3598
3599    return ROK;
3600 }
3601
3602 /*******************************************************************
3603  *
3604  * @brief Builds DMRS DL PDSCH Mapping type A
3605  *
3606  * @details
3607  *
3608  *    Function : BuildDMRSDLPdschMapTypeA
3609  *
3610  *    Functionality: Builds DMRS DL PDSCH Mapping type A
3611  *
3612  * @params[in]
3613  * struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA *dmrsDlCfg
3614  * @return ROK     - success
3615  *         RFAILED - failure
3616  *
3617  * ****************************************************************/
3618    uint8_t BuildDMRSDLPdschMapTypeA
3619 (
3620  struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA *dmrsDlCfg
3621  )
3622 {
3623    dmrsDlCfg->present = PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA_PR_setup;
3624    dmrsDlCfg->choice.setup = NULLP;
3625    CU_ALLOC(dmrsDlCfg->choice.setup, sizeof(struct DMRS_DownlinkConfig));
3626    if(!dmrsDlCfg->choice.setup)
3627    {
3628       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
3629       return RFAILED;
3630    }
3631
3632    dmrsDlCfg->choice.setup->dmrs_Type = NULLP;
3633    dmrsDlCfg->choice.setup->dmrs_AdditionalPosition = NULLP;
3634    CU_ALLOC(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition, sizeof(long));
3635    if(!dmrsDlCfg->choice.setup->dmrs_AdditionalPosition)
3636    {
3637       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSDLPdschMapTypeA");
3638       return RFAILED;
3639    }
3640    *(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition) = DMRS_ADDITIONAL_POS;
3641
3642    dmrsDlCfg->choice.setup->maxLength = NULLP;
3643    dmrsDlCfg->choice.setup->scramblingID0 = NULLP;
3644    dmrsDlCfg->choice.setup->scramblingID1 = NULLP;
3645    dmrsDlCfg->choice.setup->phaseTrackingRS = NULLP;
3646
3647    return ROK;
3648 }
3649
3650 /*******************************************************************
3651  *
3652  * @brief Builds TCI states to add/modify list
3653  *
3654  * @details
3655  *
3656  *    Function : BuildTCIStatesToAddModList
3657  *
3658  *    Functionality:Builds TCI states to add/modify list
3659  *
3660  * @params[in]
3661  * struct PDSCH_Config__tci_StatesToAddModList *tciStatesList
3662  *
3663  * @return ROK     - success
3664  *         RFAILED - failure
3665  *
3666  * ****************************************************************/
3667 uint8_t BuildTCIStatesToAddModList(struct PDSCH_Config__tci_StatesToAddModList *tciStatesList)
3668 {
3669    return ROK;
3670 }
3671
3672 /*******************************************************************
3673  *
3674  * @brief Builds PDSCH time domain allocation list
3675  *
3676  * @details
3677  *
3678  *    Function : BuildPdschTimeDomAllocList
3679  *
3680  *    Functionality: Builds PDSCH time domain allocation list
3681  *
3682  * @params[in]
3683  * struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList
3684  *
3685  * @return ROK     - success
3686  *         RFAILED - failure
3687  *
3688  * ****************************************************************/
3689    uint8_t BuildPdschTimeDomAllocList
3690 (
3691  struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList
3692  )
3693 {
3694    uint8_t idx;
3695    uint8_t elementCnt;
3696    struct PDSCH_TimeDomainResourceAllocation *timeDomAlloc;
3697
3698    timeDomAllocList->present = \
3699                                PDSCH_Config__pdsch_TimeDomainAllocationList_PR_setup;
3700
3701    timeDomAllocList->choice.setup = NULLP;
3702    CU_ALLOC(timeDomAllocList->choice.setup, \
3703          sizeof(struct PDSCH_TimeDomainResourceAllocationList));
3704    if(!timeDomAllocList->choice.setup)
3705    {
3706       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
3707       return RFAILED;
3708    }
3709
3710    elementCnt = 2;
3711    timeDomAllocList->choice.setup->list.count = elementCnt;
3712    timeDomAllocList->choice.setup->list.size = \
3713                                                elementCnt * sizeof(struct PDSCH_TimeDomainResourceAllocation *);
3714
3715    timeDomAllocList->choice.setup->list.array = NULLP;
3716    CU_ALLOC(timeDomAllocList->choice.setup->list.array, \
3717          timeDomAllocList->choice.setup->list.size);
3718    if(!timeDomAllocList->choice.setup->list.array)
3719    {
3720       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
3721       return RFAILED;
3722    }
3723
3724    for(idx = 0; idx < elementCnt; idx++)
3725    {
3726       timeDomAllocList->choice.setup->list.array[idx] = NULLP;
3727       CU_ALLOC(timeDomAllocList->choice.setup->list.array[idx], \
3728             sizeof(struct PDSCH_TimeDomainResourceAllocation));
3729       if(!timeDomAllocList->choice.setup->list.array[idx])
3730       {
3731          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
3732          return RFAILED;
3733       }
3734    }
3735
3736    idx = 0;
3737    timeDomAlloc = timeDomAllocList->choice.setup->list.array[idx];
3738    CU_ALLOC(timeDomAlloc->k0, sizeof(long));
3739    if(!timeDomAlloc->k0)
3740    {
3741        DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
3742        return RFAILED;
3743    }
3744    *(timeDomAlloc->k0) = 0;
3745    timeDomAlloc->mappingType = PDSCH_MAPPING_TYPE_A;
3746    timeDomAlloc->startSymbolAndLength = 66;
3747
3748    idx++;
3749    timeDomAlloc = timeDomAllocList->choice.setup->list.array[idx];
3750    CU_ALLOC(timeDomAlloc->k0, sizeof(long));
3751    if(!timeDomAlloc->k0)
3752    {
3753       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
3754       return RFAILED;
3755    }
3756    *(timeDomAlloc->k0) = 1;
3757    timeDomAlloc->mappingType = PDSCH_MAPPING_TYPE_A;
3758    timeDomAlloc->startSymbolAndLength = 66;
3759
3760    return ROK;
3761 }
3762
3763 /*******************************************************************
3764  *
3765  * @brief Builds PDSCH PRB Bundling type
3766  *
3767  * @details
3768  *
3769  *    Function : BuildPdschPrbBundlingType
3770  *
3771  *    Functionality: Builds PDSCH PRB Bundling type
3772  *
3773  * @params[in]
3774  * struct PDSCH_Config__prb_BundlingType *prbBndlType
3775  *
3776  * @return ROK     - success
3777  *         RFAILED - failure
3778  *
3779  * ****************************************************************/
3780    uint8_t BuildPdschPrbBundlingType
3781 (
3782  struct PDSCH_Config__prb_BundlingType *prbBndlType
3783  )
3784 {
3785    prbBndlType->present = PDSCH_Config__prb_BundlingType_PR_staticBundling;
3786
3787    prbBndlType->choice.staticBundling = NULLP;
3788    CU_ALLOC(prbBndlType->choice.staticBundling, \
3789          sizeof(struct PDSCH_Config__prb_BundlingType__staticBundling));
3790    if(!prbBndlType->choice.staticBundling)
3791    {
3792       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschPrbBundlingType");
3793       return RFAILED;
3794    }
3795    prbBndlType->choice.staticBundling->bundleSize = NULLP;
3796
3797    return ROK;
3798 }
3799
3800 /*******************************************************************
3801  *
3802  * @brief Builds BWP DL dedicated PDSCH config
3803  *
3804  * @details
3805  *
3806  *    Function : BuildBWPDlDedPdschCfg
3807  *
3808  *    Functionality: Builds BWP DL dedicated PDSCH config
3809  *
3810  * @params[in] struct PDSCH_Config *pdschCfg
3811  *
3812  * @return ROK     - success
3813  *         RFAILED - failure
3814  *
3815  * ****************************************************************/
3816 uint8_t BuildBWPDlDedPdschCfg(struct PDSCH_Config *pdschCfg)
3817 {
3818    pdschCfg->dataScramblingIdentityPDSCH = NULLP;
3819
3820    pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA = NULLP;
3821    CU_ALLOC(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA, \
3822          sizeof(struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA));
3823    if(!pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA)
3824    {
3825       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
3826       return RFAILED;
3827    }
3828
3829    if(BuildDMRSDLPdschMapTypeA(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA) != ROK)
3830    {
3831       return RFAILED;
3832    }
3833
3834    pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeB = NULLP;
3835    pdschCfg->tci_StatesToAddModList = NULLP;
3836    pdschCfg->tci_StatesToReleaseList = NULLP;
3837    pdschCfg->vrb_ToPRB_Interleaver = NULLP;
3838 #if 0
3839    CU_ALLOC(pdschCfg->tci_StatesToAddModList, sizeof(struct PDSCH_Config__tci_StatesToAddModList));
3840    if(!pdschCfg->tci_StatesToAddModList)
3841    {
3842       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
3843       return RFAILED;
3844    }
3845    if(BuildTCIStatesToAddModList(pdschCfg->tci_StatesToAddModList) != ROK)
3846    {
3847       return RFAILED;
3848    }
3849 #endif
3850
3851    pdschCfg->resourceAllocation = RES_ALLOC_TYPE;
3852
3853    pdschCfg->pdsch_TimeDomainAllocationList = NULLP;
3854    CU_ALLOC(pdschCfg->pdsch_TimeDomainAllocationList, \
3855          sizeof(struct PDSCH_Config__pdsch_TimeDomainAllocationList));
3856    if(!pdschCfg->pdsch_TimeDomainAllocationList)
3857    {
3858       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
3859       return RFAILED;
3860    }
3861    if(BuildPdschTimeDomAllocList(pdschCfg->pdsch_TimeDomainAllocationList) != ROK)
3862    {
3863       return RFAILED;
3864    }
3865    pdschCfg->pdsch_AggregationFactor = NULLP;
3866    pdschCfg->rateMatchPatternToAddModList = NULLP;
3867    pdschCfg->rateMatchPatternToReleaseList = NULLP;
3868    pdschCfg->rateMatchPatternGroup1 = NULLP;
3869    pdschCfg->rateMatchPatternGroup2 = NULLP;
3870    pdschCfg->rbg_Size = PDSCH_RBG_SIZE;
3871    pdschCfg->mcs_Table = NULLP;
3872
3873    pdschCfg->maxNrofCodeWordsScheduledByDCI = NULLP;
3874    CU_ALLOC(pdschCfg->maxNrofCodeWordsScheduledByDCI, sizeof(long));
3875    if(!pdschCfg->maxNrofCodeWordsScheduledByDCI)
3876    {
3877       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
3878       return RFAILED;
3879    }
3880    *(pdschCfg->maxNrofCodeWordsScheduledByDCI) = PDSCH_MAX_CODEWORD_SCH_BY_DCI;
3881
3882    if(BuildPdschPrbBundlingType(&pdschCfg->prb_BundlingType) != ROK)
3883    {
3884       return RFAILED;
3885    }
3886
3887    pdschCfg->zp_CSI_RS_ResourceToAddModList = NULLP;
3888    pdschCfg->zp_CSI_RS_ResourceToReleaseList = NULLP;
3889    pdschCfg->aperiodic_ZP_CSI_RS_ResourceSetsToAddModList = NULLP;
3890    pdschCfg->aperiodic_ZP_CSI_RS_ResourceSetsToReleaseList = NULLP;
3891    pdschCfg->sp_ZP_CSI_RS_ResourceSetsToAddModList = NULLP;
3892    pdschCfg->sp_ZP_CSI_RS_ResourceSetsToReleaseList = NULLP;
3893    pdschCfg->p_ZP_CSI_RS_ResourceSet = NULLP;
3894
3895    return ROK;
3896 }
3897
3898 /*******************************************************************
3899  *
3900  * @brief Builds intitial DL BWP
3901  * @details
3902  *
3903  *    Function : BuildInitialDlBWP
3904  *
3905  *    Functionality: Builds intitial DL BWP in spCellCfgDed
3906  *
3907  * @params[in] BWP_DownlinkDedicated_t *dlBwp
3908  *
3909  * @return ROK     - success
3910  *         RFAILED - failure
3911  *
3912  * ****************************************************************/
3913 uint8_t BuildInitialDlBWP(BWP_DownlinkDedicated_t *dlBwp)
3914 {
3915    dlBwp->pdcch_Config = NULLP;
3916    CU_ALLOC(dlBwp->pdcch_Config, sizeof(struct BWP_DownlinkDedicated__pdcch_Config));
3917    if(!dlBwp->pdcch_Config)
3918    {
3919       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failure in BuildInitialDlBWP");
3920       return RFAILED;
3921    }
3922    dlBwp->pdcch_Config->present = BWP_DownlinkDedicated__pdcch_Config_PR_setup;
3923
3924    dlBwp->pdcch_Config->choice.setup = NULLP;
3925    CU_ALLOC(dlBwp->pdcch_Config->choice.setup, sizeof(struct PDCCH_Config));
3926    if(!dlBwp->pdcch_Config->choice.setup)
3927    {
3928       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failure in BuildInitialDlBWP");
3929       return RFAILED;
3930    }
3931    if(BuildBWPDlDedPdcchCfg(dlBwp->pdcch_Config->choice.setup) != ROK)
3932    {
3933       return RFAILED;
3934    }
3935
3936    dlBwp->pdsch_Config = NULLP;
3937    CU_ALLOC(dlBwp->pdsch_Config, sizeof(struct BWP_DownlinkDedicated__pdsch_Config));
3938    if(!dlBwp->pdsch_Config)
3939    {
3940       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failure in BuildInitialDlBWP");
3941       return RFAILED;
3942    }
3943    dlBwp->pdsch_Config->present = BWP_DownlinkDedicated__pdsch_Config_PR_setup;
3944
3945    dlBwp->pdsch_Config->choice.setup = NULLP;
3946    CU_ALLOC(dlBwp->pdsch_Config->choice.setup, sizeof(struct PDSCH_Config));
3947    if(!dlBwp->pdsch_Config->choice.setup)
3948    {
3949       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failure in BuildInitialDlBWP");
3950       return RFAILED;
3951    }
3952
3953    if(BuildBWPDlDedPdschCfg(dlBwp->pdsch_Config->choice.setup) != ROK)
3954    {
3955       return RFAILED;
3956    }
3957
3958    dlBwp->sps_Config = NULLP;
3959    dlBwp->radioLinkMonitoringConfig = NULLP;
3960    return ROK;
3961 }
3962
3963 /*******************************************************************
3964  *
3965  * @brief Builds DMRS UL Pusch Mapping type A
3966  *
3967  * @details
3968  *
3969  *    Function : BuildDMRSULPuschMapTypeA
3970  *
3971  *    Functionality: Builds DMRS UL Pusch Mapping type A
3972  *
3973  * @params[in]
3974  *    struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA *dmrsUlCfg
3975  * @return ROK     - success
3976  *         RFAILED - failure
3977  *
3978  * ****************************************************************/
3979    uint8_t BuildDMRSULPuschMapTypeA
3980 (
3981  struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA *dmrsUlCfg
3982  )
3983 {
3984    dmrsUlCfg->present = PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA_PR_setup;
3985    dmrsUlCfg->choice.setup= NULLP;
3986    CU_ALLOC(dmrsUlCfg->choice.setup, sizeof(DMRS_UplinkConfig_t));
3987    if(!dmrsUlCfg->choice.setup)
3988    {
3989       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
3990       return RFAILED;
3991    }
3992
3993    dmrsUlCfg->choice.setup->dmrs_Type = NULLP;
3994    dmrsUlCfg->choice.setup->dmrs_AdditionalPosition = NULLP;
3995    CU_ALLOC(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition, sizeof(long));
3996    if(!dmrsUlCfg->choice.setup->dmrs_AdditionalPosition)
3997    {
3998       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
3999       return RFAILED;
4000    }
4001    *(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition) = DMRS_ADDITIONAL_POS;
4002
4003    dmrsUlCfg->choice.setup->phaseTrackingRS = NULLP;
4004    dmrsUlCfg->choice.setup->maxLength = NULLP;
4005    dmrsUlCfg->choice.setup->transformPrecodingDisabled = NULLP;
4006    CU_ALLOC(dmrsUlCfg->choice.setup->transformPrecodingDisabled, \
4007          sizeof(struct DMRS_UplinkConfig__transformPrecodingDisabled));
4008    if(!dmrsUlCfg->choice.setup->transformPrecodingDisabled)
4009    {
4010       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
4011       return RFAILED;
4012    }
4013
4014    dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0 = NULLP;
4015    CU_ALLOC(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0,\
4016          sizeof(long));
4017    if(!dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0)
4018    {
4019       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
4020       return RFAILED;
4021    }
4022    *(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0) = SCRAMBLING_ID;
4023
4024    dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID1 = NULLP;
4025    dmrsUlCfg->choice.setup->transformPrecodingEnabled = NULLP;
4026    return ROK;
4027 }
4028
4029 /*******************************************************************
4030  *
4031  * @brief Build PUSCH time domain allocation list
4032  *
4033  * @details
4034  *
4035  *    Function : BuildPuschTimeDomAllocList
4036  *
4037  *    Functionality: Build PUSCH time domain allocation list
4038  *
4039  * @params[in]
4040  * struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList
4041  *
4042  * @return ROK     - success
4043  *         RFAILED - failure
4044  *
4045  * ****************************************************************/
4046    uint8_t BuildPuschTimeDomAllocList
4047 (
4048  struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList
4049  )
4050 {
4051    uint8_t idx;
4052    uint8_t elementCnt;
4053    PUSCH_TimeDomainResourceAllocation_t  *timeDomAlloc;
4054
4055    timeDomAllocList->present = PUSCH_Config__pusch_TimeDomainAllocationList_PR_setup;
4056    timeDomAllocList->choice.setup = NULLP;
4057    CU_ALLOC(timeDomAllocList->choice.setup, \
4058          sizeof(struct PUSCH_TimeDomainResourceAllocationList));
4059    if(!timeDomAllocList->choice.setup)
4060    {
4061       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
4062       return RFAILED;
4063    }
4064
4065    elementCnt = 2;
4066    timeDomAllocList->choice.setup->list.count = elementCnt;
4067    timeDomAllocList->choice.setup->list.size = \
4068                                                elementCnt * sizeof(PUSCH_TimeDomainResourceAllocation_t *);
4069    timeDomAllocList->choice.setup->list.array = NULLP;
4070    CU_ALLOC(timeDomAllocList->choice.setup->list.array, \
4071          timeDomAllocList->choice.setup->list.size);
4072    if(!timeDomAllocList->choice.setup->list.array)
4073    {
4074       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
4075       return RFAILED;
4076    }
4077
4078    for(idx = 0; idx < elementCnt; idx++)
4079    {
4080       timeDomAllocList->choice.setup->list.array[idx] = NULLP;
4081       CU_ALLOC(timeDomAllocList->choice.setup->list.array[idx],\
4082             sizeof(PUSCH_TimeDomainResourceAllocation_t));
4083       if(!timeDomAllocList->choice.setup->list.array[idx])
4084       {
4085          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
4086          return RFAILED;
4087       }
4088    }
4089
4090    idx = 0;
4091    timeDomAlloc = timeDomAllocList->choice.setup->list.array[idx];
4092    CU_ALLOC(timeDomAlloc->k2, sizeof(long));
4093    if(!timeDomAlloc->k2)
4094    {
4095       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
4096       return RFAILED;
4097    }
4098    *(timeDomAlloc->k2) = PUSCH_K2_CFG1;
4099    timeDomAlloc->mappingType = PUSCH_MAPPING_TYPE_A;
4100    timeDomAlloc->startSymbolAndLength = 66;
4101
4102    idx++;
4103    timeDomAlloc = timeDomAllocList->choice.setup->list.array[idx];
4104    CU_ALLOC(timeDomAlloc->k2, sizeof(long));
4105    if(!timeDomAlloc->k2)
4106    {
4107        DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
4108        return RFAILED;
4109    }
4110    *(timeDomAlloc->k2) = PUSCH_K2_CFG2;
4111    timeDomAlloc->mappingType = PUSCH_MAPPING_TYPE_A;
4112    timeDomAlloc->startSymbolAndLength = 66;
4113
4114    return ROK;
4115 }
4116
4117 /*******************************************************************
4118  *
4119  * @brief Builds BWP UL dedicated PUSCH Config
4120  *
4121  * @details
4122  *
4123  *    Function : BuildBWPUlDedPuschCfg
4124  *
4125  *    Functionality:
4126  *      Builds BWP UL dedicated PUSCH Config
4127  *
4128  * @params[in] : PUSCH_Config_t *puschCfg
4129  *
4130  * @return ROK     - success
4131  *         RFAILED - failure
4132  *
4133  * ****************************************************************/
4134 uint8_t BuildBWPUlDedPuschCfg(PUSCH_Config_t *puschCfg)
4135 {
4136    puschCfg->dataScramblingIdentityPUSCH = NULLP;
4137    CU_ALLOC(puschCfg->dataScramblingIdentityPUSCH, sizeof(long));
4138    if(!puschCfg->dataScramblingIdentityPUSCH)
4139    {
4140       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
4141       return RFAILED;
4142    }
4143    *(puschCfg->dataScramblingIdentityPUSCH) = SCRAMBLING_ID;
4144
4145    puschCfg->txConfig = NULLP;
4146    puschCfg->dmrs_UplinkForPUSCH_MappingTypeA = NULLP;
4147    CU_ALLOC(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA, \
4148          sizeof(struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA));
4149    if(!puschCfg->dmrs_UplinkForPUSCH_MappingTypeA)
4150    {
4151       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
4152       return RFAILED;
4153    }
4154
4155    if(BuildDMRSULPuschMapTypeA(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA) != ROK)
4156    {
4157       return RFAILED;
4158    }
4159
4160    puschCfg->dmrs_UplinkForPUSCH_MappingTypeB = NULLP;
4161    puschCfg->pusch_PowerControl = NULLP;
4162    puschCfg->frequencyHopping = NULLP;
4163    puschCfg->frequencyHoppingOffsetLists = NULLP;
4164    puschCfg->resourceAllocation = RES_ALLOC_TYPE;
4165
4166    puschCfg->pusch_TimeDomainAllocationList = NULLP;
4167    CU_ALLOC(puschCfg->pusch_TimeDomainAllocationList, \
4168          sizeof(struct PUSCH_Config__pusch_TimeDomainAllocationList));
4169    if(!puschCfg->pusch_TimeDomainAllocationList)
4170    {
4171       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
4172       return RFAILED;
4173    }
4174
4175    if(BuildPuschTimeDomAllocList(puschCfg->pusch_TimeDomainAllocationList) != ROK)
4176    {
4177       return RFAILED;
4178    }
4179
4180    puschCfg->pusch_AggregationFactor = NULLP;
4181    puschCfg->mcs_Table = NULLP;
4182    puschCfg->mcs_TableTransformPrecoder = NULLP;
4183    puschCfg->transformPrecoder = NULLP;
4184    CU_ALLOC(puschCfg->transformPrecoder, sizeof(long));
4185    if(!puschCfg->transformPrecoder)
4186    {
4187       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
4188       return RFAILED;
4189    }
4190    *(puschCfg->transformPrecoder) = PUSCH_TRANSFORM_PRECODER;
4191
4192    puschCfg->codebookSubset = NULLP;
4193    puschCfg->maxRank = NULLP;
4194    puschCfg->rbg_Size = NULLP;
4195    puschCfg->uci_OnPUSCH = NULLP;
4196    puschCfg->tp_pi2BPSK = NULLP;
4197
4198    return ROK;
4199 }
4200
4201 /*******************************************************************
4202  *
4203  * @brief Builds BWP UL dedicated PUCCH Config
4204  *
4205  * @details
4206  *
4207  *    Function : BuildBWPUlDedPucchCfg
4208  *
4209  *    Functionality:
4210  *      Builds BWP UL dedicated PUCCH Config
4211  *
4212  * @params[in] : PUCCH_Config_t *pucchCfg
4213  *
4214  * @return ROK     - success
4215  *         RFAILED - failure
4216  *
4217  * ****************************************************************/
4218 uint8_t BuildBWPUlDedPucchCfg(PUCCH_Config_t *pucchCfg)
4219 {
4220    uint8_t arrIdx, elementCnt;
4221    uint8_t rsrcIdx, rsrcSetIdx;
4222    PUCCH_ResourceSet_t *rsrcSet = NULLP;
4223    PUCCH_Resource_t *rsrc = NULLP;
4224
4225    //RESOURCE SET
4226    elementCnt = 1;
4227    CU_ALLOC(pucchCfg->resourceSetToAddModList, sizeof(struct PUCCH_Config__resourceSetToAddModList));
4228    pucchCfg->resourceSetToAddModList->list.count = elementCnt;
4229    pucchCfg->resourceSetToAddModList->list.size = elementCnt * sizeof(PUCCH_ResourceSet_t *);
4230    CU_ALLOC(pucchCfg->resourceSetToAddModList->list.array, pucchCfg->resourceSetToAddModList->list.size);
4231    for(rsrcSetIdx=0; rsrcSetIdx < pucchCfg->resourceSetToAddModList->list.count; rsrcSetIdx++)
4232    {
4233       CU_ALLOC(pucchCfg->resourceSetToAddModList->list.array[rsrcSetIdx], sizeof(PUCCH_ResourceSet_t));
4234    }
4235    rsrcSetIdx = 0;
4236    rsrcSet = pucchCfg->resourceSetToAddModList->list.array[rsrcSetIdx];
4237    rsrcSet->pucch_ResourceSetId = 1;
4238    elementCnt = 1;
4239    rsrcSet->resourceList.list.count = elementCnt;
4240    rsrcSet->resourceList.list.size = elementCnt * sizeof(PUCCH_ResourceId_t *);
4241    CU_ALLOC(rsrcSet->resourceList.list.array, rsrcSet->resourceList.list.size);
4242    for(rsrcIdx=0; rsrcIdx < rsrcSet->resourceList.list.count; rsrcIdx++)
4243    {
4244       CU_ALLOC(rsrcSet->resourceList.list.array[rsrcIdx], sizeof(PUCCH_ResourceId_t));
4245    }
4246    rsrcIdx = 0;
4247    *(rsrcSet->resourceList.list.array[rsrcIdx]) = 1;
4248
4249    //RESOURCE
4250    elementCnt = 1;
4251    CU_ALLOC(pucchCfg->resourceToAddModList, sizeof(struct PUCCH_Config__resourceToAddModList));
4252    pucchCfg->resourceToAddModList->list.count = elementCnt;
4253    pucchCfg->resourceToAddModList->list.size = elementCnt * sizeof(PUCCH_Resource_t *);
4254    CU_ALLOC(pucchCfg->resourceToAddModList->list.array, pucchCfg->resourceToAddModList->list.size);
4255    for(rsrcIdx=0; rsrcIdx < pucchCfg->resourceToAddModList->list.count; rsrcIdx++)
4256    {
4257       CU_ALLOC(pucchCfg->resourceToAddModList->list.array[rsrcIdx], sizeof(PUCCH_Resource_t));
4258    }
4259    rsrcIdx = 0;
4260    rsrc = pucchCfg->resourceToAddModList->list.array[rsrcIdx];
4261    rsrc->pucch_ResourceId = 1;
4262    rsrc->startingPRB = 0;
4263    rsrc->format.present = PUCCH_Resource__format_PR_format1;
4264    CU_ALLOC(rsrc->format.choice.format1, sizeof(PUCCH_format1_t));
4265    rsrc->format.choice.format1->initialCyclicShift = 0;
4266    rsrc->format.choice.format1->nrofSymbols = 4;
4267    rsrc->format.choice.format1->startingSymbolIndex = 0;
4268    rsrc->format.choice.format1->timeDomainOCC = 0;
4269
4270    //PUCCH Format 1
4271    CU_ALLOC(pucchCfg->format1, sizeof(struct PUCCH_Config__format1));
4272    pucchCfg->format1->present = PUCCH_Config__format1_PR_setup;
4273    CU_ALLOC(pucchCfg->format1->choice.setup, sizeof(PUCCH_FormatConfig_t));
4274    CU_ALLOC(pucchCfg->format1->choice.setup->nrofSlots, sizeof(long));
4275    *(pucchCfg->format1->choice.setup->nrofSlots) = PUCCH_FormatConfig__nrofSlots_n4;
4276
4277    //DL DATA TO UL ACK
4278    CU_ALLOC(pucchCfg->dl_DataToUL_ACK, sizeof(struct PUCCH_Config__dl_DataToUL_ACK));
4279    if(pucchCfg->dl_DataToUL_ACK == NULLP)
4280    {
4281       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
4282       return RFAILED;
4283    }
4284
4285    elementCnt = 2;
4286    pucchCfg->dl_DataToUL_ACK->list.count = elementCnt;
4287    pucchCfg->dl_DataToUL_ACK->list.size = elementCnt * sizeof(long *);
4288    CU_ALLOC(pucchCfg->dl_DataToUL_ACK->list.array, pucchCfg->dl_DataToUL_ACK->list.size);
4289    if(pucchCfg->dl_DataToUL_ACK->list.array == NULLP)
4290    {
4291       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
4292       return RFAILED;
4293    }
4294
4295    for(arrIdx = 0; arrIdx <  pucchCfg->dl_DataToUL_ACK->list.count; arrIdx++)
4296    {
4297       CU_ALLOC(pucchCfg->dl_DataToUL_ACK->list.array[arrIdx], sizeof(long));
4298       if(pucchCfg->dl_DataToUL_ACK->list.array[arrIdx] == NULLP)
4299       {
4300           DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
4301           return RFAILED;
4302       }
4303    }
4304
4305    arrIdx = 0;
4306    *(pucchCfg->dl_DataToUL_ACK->list.array[arrIdx++]) = 4;
4307    *(pucchCfg->dl_DataToUL_ACK->list.array[arrIdx]) = 5;
4308
4309    return ROK;
4310 }
4311
4312 /*******************************************************************
4313  *
4314  * @brief Fills SRS resource to add/modify list
4315  *
4316  * @details
4317  *
4318  *    Function : BuildSrsRsrcAddModList
4319  *
4320  *    Functionality: Fills SRS resource to add/modify list
4321  *
4322  * @params[in]
4323  * @return ROK     - success
4324  *         RFAILED - failure
4325  *
4326  * ****************************************************************/
4327 uint8_t BuildSrsRsrcAddModList(struct SRS_Config__srs_ResourceToAddModList *resourceList)
4328 {
4329    uint8_t   elementCnt;
4330    uint8_t   rsrcIdx;
4331
4332    elementCnt = 1;
4333    resourceList->list.count = elementCnt;
4334    resourceList->list.size = elementCnt * sizeof(SRS_Resource_t *);
4335    resourceList->list.array = NULLP;
4336    CU_ALLOC(resourceList->list.array, resourceList->list.size);
4337    if(!resourceList->list.array)
4338    {
4339       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed in BuildSrsRsrcAddModList");
4340       return RFAILED;
4341    }
4342
4343    for(rsrcIdx = 0; rsrcIdx < resourceList->list.count; rsrcIdx++)
4344    {
4345       CU_ALLOC(resourceList->list.array[rsrcIdx], sizeof(SRS_Resource_t));
4346       if(!resourceList->list.array[rsrcIdx])
4347       {
4348          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed in BuildSrsRsrcAddModList");
4349          return RFAILED;
4350       }
4351    }
4352
4353    rsrcIdx = 0;
4354    resourceList->list.array[rsrcIdx]->srs_ResourceId = SRS_RSRC_ID;
4355    resourceList->list.array[rsrcIdx]->nrofSRS_Ports = SRS_Resource__nrofSRS_Ports_port1;
4356    resourceList->list.array[rsrcIdx]->transmissionComb.present = SRS_Resource__transmissionComb_PR_n2;
4357
4358    resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2 = NULLP;
4359    CU_ALLOC(resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2, \
4360          sizeof(struct SRS_Resource__transmissionComb__n2));
4361    if(!resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2)
4362    {
4363       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed in BuildSrsRsrcAddModList");
4364       return RFAILED;
4365    }
4366    resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2->combOffset_n2\
4367       = SRS_COMB_OFFSET_N2;
4368    resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2->cyclicShift_n2\
4369       = SRS_CYCLIC_SHIFT_N2;
4370
4371    resourceList->list.array[rsrcIdx]->resourceMapping.startPosition = PUSCH_START_SYMBOL;
4372    resourceList->list.array[rsrcIdx]->resourceMapping.nrofSymbols =  \
4373                                                                      SRS_Resource__resourceMapping__nrofSymbols_n1;
4374    resourceList->list.array[rsrcIdx]->resourceMapping.repetitionFactor = \
4375                                                                          SRS_Resource__resourceMapping__repetitionFactor_n1;
4376
4377    resourceList->list.array[rsrcIdx]->freqDomainPosition = SRS_FREQ_DOM_POS;
4378    resourceList->list.array[rsrcIdx]->freqDomainShift = SRS_FREQ_DOM_SHIFT;
4379    resourceList->list.array[rsrcIdx]->freqHopping.c_SRS = C_SRS;
4380    resourceList->list.array[rsrcIdx]->freqHopping.b_SRS = B_SRS;
4381    resourceList->list.array[rsrcIdx]->freqHopping.b_hop = B_HOP;
4382    resourceList->list.array[rsrcIdx]->groupOrSequenceHopping = \
4383                                                                SRS_Resource__groupOrSequenceHopping_neither;
4384
4385    /* Setting resource type to aperiodic for intergration purposes */
4386    resourceList->list.array[rsrcIdx]->resourceType.present = \
4387                                                              SRS_Resource__resourceType_PR_aperiodic;
4388    resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic = NULLP;
4389    CU_ALLOC(resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic,
4390          sizeof(struct SRS_Resource__resourceType__aperiodic));
4391    if(!resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic)
4392    {
4393       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed in BuildSrsRsrcAddModList");
4394       return RFAILED;
4395    }
4396    resourceList->list.array[rsrcIdx]->sequenceId = SRS_SEQ_ID;
4397
4398    return ROK;
4399 }
4400
4401 /*******************************************************************
4402  *
4403  * @brief Build SRS resource set Add/mod list
4404  *
4405  * @details
4406  *
4407  *    Function : BuildSrsRsrcSetAddModList
4408  *
4409  *    Functionality: Build SRS resource set Add/mod list
4410  *
4411  * @params[in]
4412  * @return ROK     - success
4413  *         RFAILED - failure
4414  *
4415  * ****************************************************************/
4416    uint8_t BuildSrsRsrcSetAddModList
4417 (
4418  struct SRS_Config__srs_ResourceSetToAddModList *rsrcSetList
4419  )
4420 {
4421    uint8_t  elementCnt;
4422    uint8_t  rSetIdx;
4423    uint8_t  rsrcIdx;
4424    struct SRS_ResourceSet__srs_ResourceIdList *rsrcIdList;
4425
4426    elementCnt = 1;
4427    rsrcSetList->list.count = elementCnt;
4428    rsrcSetList->list.size = elementCnt * sizeof(SRS_ResourceSet_t *);
4429    rsrcSetList->list.array = NULLP;
4430    CU_ALLOC(rsrcSetList->list.array, rsrcSetList->list.size);
4431    if(!rsrcSetList->list.array)
4432    {
4433       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed in BuildSrsRsrcSetAddModList");
4434       return RFAILED;
4435    }
4436
4437    for(rSetIdx = 0; rSetIdx < rsrcSetList->list.count; rSetIdx++)
4438    {
4439       CU_ALLOC(rsrcSetList->list.array[rSetIdx], sizeof(SRS_ResourceSet_t));
4440       if(!rsrcSetList->list.array[rSetIdx])
4441       {
4442          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed in BuildSrsRsrcSetAddModList");
4443          return RFAILED;
4444       }
4445    }
4446
4447    rSetIdx = 0;
4448    rsrcSetList->list.array[rSetIdx]->srs_ResourceSetId = SRS_RSET_ID;
4449
4450    /* Fill Resource Id list in resource set */
4451    rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList = NULLP;
4452    CU_ALLOC(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList,\
4453          sizeof(struct SRS_ResourceSet__srs_ResourceIdList));
4454    if(!rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList)
4455    {
4456       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
4457       return RFAILED;
4458    }
4459
4460    elementCnt = 1;
4461    rsrcIdList = rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList;
4462    rsrcIdList->list.count = elementCnt;
4463    rsrcIdList->list.size = elementCnt * sizeof(SRS_ResourceId_t *);
4464    rsrcIdList->list.array = NULLP;
4465    CU_ALLOC(rsrcIdList->list.array, rsrcIdList->list.size);
4466    if(!rsrcIdList->list.array)
4467    {
4468       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed in BuildSrsRsrcSetAddModList");
4469       return RFAILED;
4470    }
4471
4472    for(rsrcIdx = 0; rsrcIdx < rsrcIdList->list.count; rsrcIdx++)
4473    {
4474       CU_ALLOC(rsrcIdList->list.array[rsrcIdx], sizeof(SRS_ResourceId_t));
4475       if(!rsrcIdList->list.array[rsrcIdx])
4476       {
4477          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed in BuildSrsRsrcSetAddModList");
4478          return RFAILED;
4479       }
4480    }
4481
4482    rsrcIdx = 0;
4483    *rsrcIdList->list.array[rsrcIdx] = SRS_RSRC_ID;
4484
4485    /* Fill resource type */
4486    rsrcSetList->list.array[rSetIdx]->resourceType.present = \
4487                                                             SRS_ResourceSet__resourceType_PR_aperiodic;
4488
4489    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic = NULLP;
4490    CU_ALLOC(rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic, \
4491          sizeof(struct SRS_ResourceSet__resourceType__aperiodic));
4492    if(!rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic)
4493    {
4494       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed in BuildSrsRsrcSetAddModList");
4495       return RFAILED;
4496    }
4497    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic->aperiodicSRS_ResourceTrigger \
4498       = APERIODIC_SRS_RESRC_TRIGGER;
4499
4500    /* TODO : Fill values for below IEs as expected by Viavi */
4501    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic->csi_RS = NULLP;
4502    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic->slotOffset = NULLP;
4503
4504
4505    rsrcSetList->list.array[rSetIdx]->usage = SRS_ResourceSet__usage_codebook;
4506    rsrcSetList->list.array[rSetIdx]->alpha = NULLP;
4507    rsrcSetList->list.array[rSetIdx]->p0 = NULLP;
4508    rsrcSetList->list.array[rSetIdx]->pathlossReferenceRS = NULLP;
4509    rsrcSetList->list.array[rSetIdx]->srs_PowerControlAdjustmentStates = NULLP;
4510
4511    return ROK;
4512 }
4513
4514 /*******************************************************************
4515  *
4516  * @brief Builds BWP UL dedicated SRS Config
4517  *
4518  * @details
4519  *
4520  *    Function : BuildBWPUlDedSrsCfg
4521  *
4522  *    Functionality: Builds BWP UL dedicated SRS Config
4523  *
4524  * @params[in] SRS Config
4525  * @return ROK     - success
4526  *         RFAILED - failure
4527  *
4528  * ****************************************************************/
4529 uint8_t BuildBWPUlDedSrsCfg(SRS_Config_t *srsCfg)
4530 {
4531    srsCfg->srs_ResourceSetToReleaseList = NULLP;
4532    srsCfg->srs_ResourceSetToAddModList = NULLP;
4533    CU_ALLOC(srsCfg->srs_ResourceSetToAddModList, \
4534          sizeof(struct SRS_Config__srs_ResourceSetToAddModList));
4535    if(!srsCfg->srs_ResourceSetToAddModList)
4536    {
4537       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed in BuildBWPUlDedSrsCfg");
4538       return RFAILED;
4539    }
4540    if(BuildSrsRsrcSetAddModList(srsCfg->srs_ResourceSetToAddModList) != ROK)
4541    {
4542       return RFAILED;
4543    }
4544
4545    srsCfg->srs_ResourceToReleaseList = NULLP;
4546
4547    /* Resource to Add/Modify list */
4548    srsCfg->srs_ResourceToAddModList = NULLP;
4549    CU_ALLOC(srsCfg->srs_ResourceToAddModList, \
4550          sizeof(struct SRS_Config__srs_ResourceToAddModList));
4551    if(!srsCfg->srs_ResourceToAddModList)
4552    {
4553       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed in BuildBWPUlDedSrsCfg");
4554       return RFAILED;
4555    }
4556
4557    if(BuildSrsRsrcAddModList(srsCfg->srs_ResourceToAddModList) != ROK)
4558    {
4559       return RFAILED;
4560    }
4561
4562    srsCfg->tpc_Accumulation = NULLP;
4563
4564    return ROK;
4565 }
4566
4567 /*******************************************************************
4568  *
4569  * @brief Builds inital UL BWP
4570  *
4571  * @details
4572  *
4573  *    Function : BuildInitialUlBWP
4574  *
4575  *    Functionality: Builds initial UL BWP
4576  *
4577  * @params[in] BWP_UplinkDedicated_t *ulBwp
4578  * @return ROK     - success
4579  *         RFAILED - failure
4580  *
4581  * ****************************************************************/
4582 uint8_t BuildInitialUlBWP(BWP_UplinkDedicated_t *ulBwp)
4583 {
4584    ulBwp->pucch_Config = NULLP;
4585    ulBwp->pucch_Config = NULLP;
4586    CU_ALLOC(ulBwp->pucch_Config, sizeof(struct BWP_UplinkDedicated__pucch_Config));
4587    if(!ulBwp->pucch_Config)
4588    {
4589       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
4590       return RFAILED;
4591    }
4592
4593    ulBwp->pucch_Config->present = BWP_UplinkDedicated__pucch_Config_PR_setup;
4594    ulBwp->pucch_Config->choice.setup = NULLP;
4595    CU_ALLOC(ulBwp->pucch_Config->choice.setup, sizeof(PUCCH_Config_t));
4596    if(!ulBwp->pucch_Config->choice.setup)
4597    {
4598       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
4599       return RFAILED;
4600    }
4601
4602    if(BuildBWPUlDedPucchCfg(ulBwp->pucch_Config->choice.setup) != ROK)
4603    {
4604       return RFAILED;
4605    }
4606
4607    /* Fill BWP UL dedicated PUSCH config */
4608    ulBwp->pusch_Config = NULLP;
4609    CU_ALLOC(ulBwp->pusch_Config, sizeof(struct BWP_UplinkDedicated__pusch_Config));
4610    if(!ulBwp->pusch_Config)
4611    {
4612       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
4613       return RFAILED;
4614    }
4615
4616    ulBwp->pusch_Config->present = BWP_UplinkDedicated__pusch_Config_PR_setup;
4617    ulBwp->pusch_Config->choice.setup = NULLP;
4618    CU_ALLOC(ulBwp->pusch_Config->choice.setup, sizeof(PUSCH_Config_t));
4619    if(!ulBwp->pusch_Config->choice.setup)
4620    {
4621       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
4622       return RFAILED;
4623    }
4624
4625    if(BuildBWPUlDedPuschCfg(ulBwp->pusch_Config->choice.setup) != ROK)
4626    {
4627       return RFAILED;
4628    }
4629
4630    ulBwp->configuredGrantConfig = NULLP;
4631
4632    /* Fill BPW UL dedicated SRS config */
4633    ulBwp->srs_Config = NULLP;
4634    CU_ALLOC(ulBwp->srs_Config, sizeof(struct BWP_UplinkDedicated__srs_Config));
4635    if(!ulBwp->srs_Config)
4636    {
4637       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
4638       return RFAILED;
4639    }
4640
4641    ulBwp->srs_Config->present = BWP_UplinkDedicated__srs_Config_PR_setup;
4642    ulBwp->srs_Config->choice.setup = NULLP;
4643    CU_ALLOC(ulBwp->srs_Config->choice.setup, sizeof(SRS_Config_t));
4644    if(!ulBwp->srs_Config->choice.setup)
4645    {
4646       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
4647       return RFAILED;
4648    }
4649
4650    if(BuildBWPUlDedSrsCfg(ulBwp->srs_Config->choice.setup) != ROK)
4651    {
4652       return RFAILED;
4653    }
4654
4655    ulBwp->beamFailureRecoveryConfig = NULLP;
4656
4657    return ROK;
4658 }
4659
4660 /*******************************************************************
4661  *
4662  * @brief Builds Pusch Serving cell Config
4663  *
4664  * @details
4665  *
4666  *    Function : BuildPuschSrvCellCfg
4667  *
4668  *    Functionality: Builds Pusch Serving cell Config
4669  *
4670  * @params[in] struct UplinkConfig__pusch_ServingCellConfig *puschCfg
4671  *
4672  * @return ROK     - success
4673  *         RFAILED - failure
4674  *
4675  * ****************************************************************/
4676 uint8_t BuildPuschSrvCellCfg(struct UplinkConfig__pusch_ServingCellConfig *puschCfg)
4677 {
4678    puschCfg->present = UplinkConfig__pusch_ServingCellConfig_PR_setup;
4679    puschCfg->choice.setup = NULLP;
4680    CU_ALLOC(puschCfg->choice.setup, sizeof(struct PUSCH_ServingCellConfig));
4681    if(!puschCfg->choice.setup)
4682    {
4683       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
4684       return RFAILED;
4685    }
4686
4687    puschCfg->choice.setup->codeBlockGroupTransmission = NULLP;
4688    puschCfg->choice.setup->rateMatching = NULLP;
4689    puschCfg->choice.setup->xOverhead = NULLP;
4690    puschCfg->choice.setup->ext1 = NULLP;
4691    CU_ALLOC(puschCfg->choice.setup->ext1, sizeof(struct PUSCH_ServingCellConfig__ext1));
4692    if(!puschCfg->choice.setup->ext1)
4693    {
4694       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
4695       return RFAILED;
4696    }
4697
4698    puschCfg->choice.setup->ext1->maxMIMO_Layers = NULLP;
4699    CU_ALLOC(puschCfg->choice.setup->ext1->maxMIMO_Layers, sizeof(long));
4700    if(!puschCfg->choice.setup->ext1->maxMIMO_Layers)
4701    {
4702       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
4703       return RFAILED;
4704    }
4705    *(puschCfg->choice.setup->ext1->maxMIMO_Layers) = PUSCH_MAX_MIMO_LAYERS;
4706
4707    puschCfg->choice.setup->ext1->processingType2Enabled= NULLP;
4708    CU_ALLOC(puschCfg->choice.setup->ext1->processingType2Enabled,sizeof(BOOLEAN_t));
4709    if(!puschCfg->choice.setup->ext1->processingType2Enabled)
4710    {
4711       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
4712       return RFAILED;
4713    }
4714    *(puschCfg->choice.setup->ext1->processingType2Enabled) = PUSCH_PROCESS_TYPE2_ENABLED;
4715    return ROK;
4716 }
4717
4718 /*******************************************************************
4719  *
4720  * @brief Builds UL config
4721  * @details
4722  *
4723  *    Function : BuildUlCfg
4724  *
4725  *    Functionality: Builds UL config in spCellCfgDed
4726  *
4727  * @params[in] UplinkConfig_t *ulCfg
4728  *
4729  * @return ROK     - success
4730  *         RFAILED - failure
4731  *
4732  * ****************************************************************/
4733 uint8_t BuildUlCfg(UplinkConfig_t *ulCfg)
4734 {
4735    ulCfg->initialUplinkBWP = NULLP;
4736    CU_ALLOC(ulCfg->initialUplinkBWP, sizeof(BWP_UplinkDedicated_t));
4737    if(!ulCfg->initialUplinkBWP)
4738    {
4739       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failed in BuildUlCfg");
4740       return RFAILED;
4741    }
4742
4743    if(BuildInitialUlBWP(ulCfg->initialUplinkBWP) != ROK)
4744    {
4745       return RFAILED;
4746    }
4747
4748    ulCfg->uplinkBWP_ToReleaseList = NULLP;
4749    ulCfg->uplinkBWP_ToAddModList = NULLP;
4750    ulCfg->firstActiveUplinkBWP_Id = NULLP;
4751    CU_ALLOC(ulCfg->firstActiveUplinkBWP_Id, sizeof(BWP_Id_t));
4752    if(!ulCfg->firstActiveUplinkBWP_Id)
4753    {
4754       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failed in BuildUlCfg");
4755       return RFAILED;
4756    }
4757    *(ulCfg->firstActiveUplinkBWP_Id) = ACTIVE_UL_BWP_ID;
4758
4759    ulCfg->pusch_ServingCellConfig = NULLP;
4760    CU_ALLOC(ulCfg->pusch_ServingCellConfig, \
4761          sizeof(struct UplinkConfig__pusch_ServingCellConfig));
4762    if(!ulCfg->pusch_ServingCellConfig)
4763    {
4764       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failed in BuildUlCfg");
4765       return RFAILED;
4766    }
4767
4768    if(BuildPuschSrvCellCfg(ulCfg->pusch_ServingCellConfig) != ROK)
4769    {
4770       return RFAILED;
4771    }
4772
4773    ulCfg->carrierSwitching = NULLP;
4774    ulCfg->ext1 = NULLP;
4775    return ROK;
4776 }
4777
4778 /*******************************************************************
4779  *
4780  * @brief Builds PDSCH serving cell config
4781  * @details
4782  *
4783  *    Function : BuildPdschSrvCellCfg
4784  *
4785  *    Functionality: Builds PDSCH serving cell config in spCellCfgDed
4786  *
4787  * @params[in] struct ServingCellConfig__pdsch_ServingCellConfig *pdschCfg
4788  *
4789  * @return ROK     - success
4790  *         RFAILED - failure
4791  *
4792  * ****************************************************************/
4793 uint8_t BuildPdschSrvCellCfg(struct ServingCellConfig__pdsch_ServingCellConfig *pdschCfg)
4794 {
4795    pdschCfg->present =  ServingCellConfig__pdsch_ServingCellConfig_PR_setup;
4796    pdschCfg->choice.setup = NULLP;
4797    CU_ALLOC(pdschCfg->choice.setup, sizeof( struct PDSCH_ServingCellConfig));
4798    if(!pdschCfg->choice.setup)
4799    {
4800       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschSrvCellCfg");
4801       return RFAILED;
4802    }
4803
4804    pdschCfg->choice.setup->codeBlockGroupTransmission = NULLP;
4805    pdschCfg->choice.setup->xOverhead = NULLP;
4806    pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH = NULLP;
4807    CU_ALLOC(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH, sizeof(long));
4808    if(!pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH)
4809    {
4810       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschSrvCellCfg");
4811       return RFAILED;
4812    }
4813    *(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH)= PDSCH_NUM_HARQ_PROC;
4814    pdschCfg->choice.setup->pucch_Cell = NULLP;
4815    pdschCfg->choice.setup->ext1 = NULLP;
4816
4817    return ROK;
4818 }
4819
4820 /*******************************************************************
4821  *
4822  * @brief Builds CSI Meas config
4823  * @details
4824  *
4825  *    Function : BuildCsiMeasCfg
4826  *
4827  *    Functionality: Builds CSI Meas config in spCellCfgDed
4828  *
4829  * @params[in] struct ServingCellConfig__csi_MeasConfig *csiMeasCfg
4830  *
4831  * @return ROK     - success
4832  *         RFAILED - failure
4833  *
4834  * ****************************************************************/
4835 uint8_t BuildCsiMeasCfg(struct ServingCellConfig__csi_MeasConfig *csiMeasCfg)
4836 {
4837
4838    return ROK;
4839 }
4840
4841 /*******************************************************************
4842  *
4843  * @brief Builds Spcell config dedicated
4844  * @details
4845  *
4846  *    Function : BuildSpCellCfgDed
4847  *
4848  *    Functionality: Builds sp cell config dedicated in spCellCfg
4849  *
4850  * @params[in] ServingCellConfig_t srvCellCfg
4851  *
4852  * @return ROK     - success
4853  *         RFAILED - failure
4854  *
4855  * ****************************************************************/
4856 uint8_t BuildSpCellCfgDed(ServingCellConfig_t *srvCellCfg)
4857 {
4858    srvCellCfg->tdd_UL_DL_ConfigurationDedicated = NULLP;
4859
4860    srvCellCfg->initialDownlinkBWP = NULLP;
4861    CU_ALLOC(srvCellCfg->initialDownlinkBWP, sizeof(BWP_DownlinkDedicated_t));
4862    if(!srvCellCfg->initialDownlinkBWP)
4863    {
4864       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
4865       return RFAILED;
4866    }
4867
4868    if(BuildInitialDlBWP(srvCellCfg->initialDownlinkBWP) != ROK)
4869    {
4870       DU_LOG("\nERROR  -->  F1AP : BuildInitialDlBWP failed");
4871       return RFAILED;
4872    }
4873    srvCellCfg->downlinkBWP_ToReleaseList = NULLP;
4874    srvCellCfg->downlinkBWP_ToAddModList = NULLP;
4875
4876    srvCellCfg->firstActiveDownlinkBWP_Id = NULLP;
4877    CU_ALLOC(srvCellCfg->firstActiveDownlinkBWP_Id, sizeof(long));
4878    if(!srvCellCfg->firstActiveDownlinkBWP_Id)
4879    {
4880       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
4881       return RFAILED;
4882    }
4883    *(srvCellCfg->firstActiveDownlinkBWP_Id) = ACTIVE_DL_BWP_ID;
4884
4885    srvCellCfg->bwp_InactivityTimer = NULLP;
4886
4887    srvCellCfg->defaultDownlinkBWP_Id = NULLP;
4888    CU_ALLOC(srvCellCfg->defaultDownlinkBWP_Id, sizeof(long));
4889    if(!srvCellCfg->defaultDownlinkBWP_Id)
4890    {
4891       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
4892       return RFAILED;
4893    }
4894    *(srvCellCfg->defaultDownlinkBWP_Id) = ACTIVE_DL_BWP_ID;
4895
4896    srvCellCfg->uplinkConfig = NULLP;
4897    CU_ALLOC(srvCellCfg->uplinkConfig, sizeof(UplinkConfig_t));
4898    if(!srvCellCfg->uplinkConfig)
4899    {
4900       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
4901       return RFAILED;
4902    }
4903
4904    if(BuildUlCfg(srvCellCfg->uplinkConfig) != ROK)
4905    {
4906       DU_LOG("\nERROR  -->  F1AP : BuildUlCfg failed");
4907       return RFAILED;
4908    }
4909    srvCellCfg->supplementaryUplink = NULLP;
4910    srvCellCfg->pdcch_ServingCellConfig = NULLP;
4911
4912    srvCellCfg->pdsch_ServingCellConfig = NULLP;
4913    CU_ALLOC(srvCellCfg->pdsch_ServingCellConfig, sizeof(struct  ServingCellConfig__pdsch_ServingCellConfig));
4914    if(!srvCellCfg->pdsch_ServingCellConfig)
4915    {
4916       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
4917       return RFAILED;
4918    }
4919
4920    if(BuildPdschSrvCellCfg(srvCellCfg->pdsch_ServingCellConfig) != ROK)
4921    {
4922       DU_LOG("\nERROR  -->  F1AP : BuildPdschSrvCellCfg failed");
4923       return RFAILED;
4924    }
4925
4926    srvCellCfg->csi_MeasConfig = NULLP;
4927 #if 0
4928    CU_ALLOC(srvCellCfg->csi_MeasConfig, sizeof(struct   ServingCellConfig__csi_MeasConfig))
4929       if(!srvCellCfg->csi_MeasConfig)
4930       {
4931          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
4932          return RFAILED;
4933       }
4934
4935    if(BuildCsiMeasCfg(srvCellCfg->csi_MeasConfig) != ROK)
4936    {
4937       DU_LOG("\nF1AP : BuildCsiMeasCfg failed");
4938       return RFAILED;
4939    }
4940 #endif
4941    srvCellCfg->sCellDeactivationTimer = NULLP;
4942    srvCellCfg->crossCarrierSchedulingConfig = NULLP;
4943    srvCellCfg->tag_Id = TAG_ID;
4944    srvCellCfg->dummy = NULLP;
4945    srvCellCfg->pathlossReferenceLinking = NULLP;
4946    srvCellCfg->servingCellMO = NULLP;
4947    srvCellCfg->ext1 = NULLP;
4948
4949    return ROK;
4950 }
4951 /*******************************************************************
4952  *
4953  * @brief Builds Spcell config
4954  *
4955  * @details
4956  *
4957  *    Function : BuildSpCellCfg
4958  *
4959  *    Functionality: Builds sp cell config in DuToCuRrcContainer
4960  *
4961  * @params[in] SpCellConfig_t spCellCfg
4962  *
4963  * @return ROK     - success
4964  *         RFAILED - failure
4965  *
4966  * ****************************************************************/
4967 uint8_t BuildSpCellCfg(SpCellConfig_t *spCellCfg)
4968 {
4969
4970    spCellCfg->servCellIndex = NULLP;
4971    CU_ALLOC(spCellCfg->servCellIndex, sizeof(long));
4972    if(!spCellCfg->servCellIndex)
4973    {
4974       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfg");
4975       return RFAILED;
4976    }
4977    *(spCellCfg->servCellIndex) = SERV_CELL_IDX;
4978
4979    spCellCfg->reconfigurationWithSync = NULLP;
4980    spCellCfg->rlf_TimersAndConstants = NULLP;
4981    spCellCfg->rlmInSyncOutOfSyncThreshold = NULLP;
4982    CU_ALLOC(spCellCfg->rlmInSyncOutOfSyncThreshold, sizeof(long));
4983    if(!spCellCfg->rlmInSyncOutOfSyncThreshold)
4984    {
4985       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfg");
4986       return RFAILED;
4987    }
4988    *(spCellCfg->rlmInSyncOutOfSyncThreshold) = RLM_SYNC_OUT_SYNC_THRESHOLD;
4989
4990    spCellCfg->spCellConfigDedicated = NULLP;
4991    CU_ALLOC(spCellCfg->spCellConfigDedicated, sizeof(ServingCellConfig_t));
4992    if(!spCellCfg->spCellConfigDedicated)
4993    {
4994       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfg");
4995       return RFAILED;
4996    }
4997    if(BuildSpCellCfgDed(spCellCfg->spCellConfigDedicated) != ROK)
4998    {
4999       DU_LOG("\nERROR  -->  F1AP : BuildSpCellCfgDed failed");
5000       return RFAILED;
5001    }
5002    return ROK;
5003 }
5004 /*******************************************************************
5005  *
5006  * @brief Builds Phy cell group config
5007  *
5008  * @details
5009  *
5010  *    Function : BuildPhyCellGrpCfg
5011  *
5012  *    Functionality: Builds Phy cell group config in DuToCuRrcContainer
5013  *
5014  * @params[in] PhysicalCellGroupConfig_t *phyCellGrpCfg
5015  *
5016  * @return ROK     - success
5017  *         RFAILED - failure
5018  *
5019  * ****************************************************************/
5020 uint8_t BuildPhyCellGrpCfg(PhysicalCellGroupConfig_t *phyCellGrpCfg)
5021 {
5022    phyCellGrpCfg->harq_ACK_SpatialBundlingPUCCH = NULLP;
5023    phyCellGrpCfg->harq_ACK_SpatialBundlingPUSCH = NULLP;
5024
5025    phyCellGrpCfg->p_NR_FR1 = NULLP;
5026    CU_ALLOC(phyCellGrpCfg->p_NR_FR1, sizeof(long));
5027    if(!phyCellGrpCfg->p_NR_FR1)
5028    {
5029       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildPhyCellGrpCfg");
5030       return RFAILED;
5031    }
5032    *(phyCellGrpCfg->p_NR_FR1)             = P_NR_FR1;
5033    phyCellGrpCfg->pdsch_HARQ_ACK_Codebook = PDSCH_HARQ_ACK_CODEBOOK;
5034    phyCellGrpCfg->tpc_SRS_RNTI = NULLP;
5035    phyCellGrpCfg->tpc_PUCCH_RNTI = NULLP;
5036    phyCellGrpCfg->tpc_PUSCH_RNTI = NULLP;
5037    phyCellGrpCfg->sp_CSI_RNTI = NULLP;
5038    phyCellGrpCfg->cs_RNTI = NULLP;
5039    phyCellGrpCfg->ext1 = NULLP;
5040    phyCellGrpCfg->ext2 = NULLP;
5041
5042    return ROK;
5043 }
5044
5045 /*******************************************************************
5046  *
5047  * @brief Builds tag config
5048  *
5049  * @details
5050  *
5051  *    Function : BuildTagConfig
5052  *
5053  *    Functionality: Builds tag config in MacCellGroupConfig
5054  *
5055  * @params[in] TAG_Config *tag_Config
5056  *
5057  * @return ROK     - success
5058  *         RFAILED - failure
5059  *
5060  * ****************************************************************/
5061 uint8_t BuildTagConfig(struct TAG_Config *tagConfig)
5062 {
5063    struct TAG_Config__tag_ToAddModList *tagList;
5064    uint8_t                     idx, elementCnt;
5065
5066    tagConfig->tag_ToReleaseList = NULLP;
5067    tagConfig->tag_ToAddModList = NULLP;
5068    CU_ALLOC(tagConfig->tag_ToAddModList, sizeof(struct TAG_Config__tag_ToAddModList));
5069    if(!tagConfig->tag_ToAddModList)
5070    {
5071       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildTagConfig");
5072       return RFAILED;
5073    }
5074
5075    elementCnt = 1; //ODU_VALUE_ONE;
5076    tagList = tagConfig->tag_ToAddModList;
5077    tagList->list.count = elementCnt;
5078    tagList->list.size  =  elementCnt * sizeof(struct TAG *);
5079
5080    tagList->list.array = NULLP;
5081    CU_ALLOC(tagList->list.array, tagList->list.size);
5082    if(!tagList->list.array)
5083    {
5084       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildTagConfig");
5085       return RFAILED;
5086    }
5087
5088    for(idx=0; idx<tagList->list.count; idx++)
5089    {
5090       tagList->list.array[idx] = NULLP;
5091       CU_ALLOC(tagList->list.array[idx], sizeof(struct TAG));
5092       if(!tagList->list.array[idx])
5093       {
5094          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildTagConfig");
5095          return RFAILED;
5096       }
5097    }
5098
5099    idx = 0;
5100    tagList->list.array[idx]->tag_Id = TAG_ID;
5101    tagList->list.array[idx]->timeAlignmentTimer = TIME_ALIGNMENT_TMR;
5102
5103    return ROK;
5104 }
5105
5106 /*******************************************************************
5107  *
5108  * @brief Builds PHR Config
5109  *
5110  * @details
5111  *
5112  *    Function : BuildPhrConfig
5113  *
5114  *    Functionality: Builds phrConfig in MacCellGroupConfig
5115  *
5116  * @params[in] PHR Config *
5117  *
5118  * @return ROK     - success
5119  *         RFAILED - failure
5120  *
5121  * ****************************************************************/
5122 uint8_t BuildPhrConfig(struct MAC_CellGroupConfig__phr_Config *phrConfig)
5123 {
5124
5125    phrConfig->present = MAC_CellGroupConfig__phr_Config_PR_setup;
5126    phrConfig->choice.setup = NULLP;
5127    CU_ALLOC(phrConfig->choice.setup, sizeof(struct PHR_Config));
5128    if(!phrConfig->choice.setup)
5129    {
5130       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildPhrConfig");
5131       return RFAILED;
5132    }
5133
5134    phrConfig->choice.setup->phr_PeriodicTimer        = PHR_PERIODIC_TMR;
5135    phrConfig->choice.setup->phr_ProhibitTimer        = PHR_PROHIBHIT_TMR;
5136    phrConfig->choice.setup->phr_Tx_PowerFactorChange = PHR_PWR_FACTOR_CHANGE;
5137    phrConfig->choice.setup->multiplePHR              = false;
5138    phrConfig->choice.setup->dummy                    = false;
5139    phrConfig->choice.setup->phr_Type2OtherCell       = false;
5140    phrConfig->choice.setup->phr_ModeOtherCG          = PHR_MODE_OTHER_CG;
5141
5142    return ROK;
5143 }
5144
5145 /*******************************************************************
5146  *
5147  * @brief Builds BSR Config
5148  *
5149  * @details
5150  *
5151  *    Function : BuildBsrConfig
5152  *
5153  *    Functionality: Builds BuildBsrConfig in MacCellGroupConfig
5154  *
5155  * @params[in] BSR_Config *bsrConfig
5156  *
5157  * @return ROK     - success
5158  *         RFAILED - failure
5159  *
5160  * ****************************************************************/
5161 uint8_t BuildBsrConfig(struct BSR_Config *bsrConfig)
5162 {
5163    bsrConfig->periodicBSR_Timer = PERIODIC_BSR_TMR;
5164    bsrConfig->retxBSR_Timer     = RETX_BSR_TMR;
5165    bsrConfig->logicalChannelSR_DelayTimer = NULLP;
5166
5167    return ROK;
5168 }
5169
5170 /*******************************************************************
5171  *
5172  * @brief Builds scheduling request config
5173  *
5174  * @details
5175  *
5176  *    Function : BuildSchedulingReqConfig
5177  *
5178  *    Functionality: Builds BuildSchedulingReqConfig in MacCellGroupConfig
5179  *
5180  * @params[in] SchedulingRequestConfig *schedulingRequestConfig
5181  *
5182  * @return ROK     - success
5183  *         RFAILED - failure
5184  *
5185  * ****************************************************************/
5186 uint8_t BuildSchedulingReqConfig(struct SchedulingRequestConfig *schedulingRequestConfig)
5187 {
5188    struct SchedulingRequestConfig__schedulingRequestToAddModList *schReqList;
5189    uint8_t                     idx, elementCnt;
5190
5191    schedulingRequestConfig->schedulingRequestToAddModList = NULLP;
5192    CU_ALLOC(schedulingRequestConfig->schedulingRequestToAddModList,
5193          sizeof(struct SchedulingRequestConfig__schedulingRequestToAddModList));
5194    if(!schedulingRequestConfig->schedulingRequestToAddModList)
5195    {
5196       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSchedulingReqConfig");
5197       return RFAILED;
5198    }
5199
5200    elementCnt = 1; //ODU_VALUE_ONE;
5201    schReqList = schedulingRequestConfig->schedulingRequestToAddModList;
5202    schReqList->list.count = elementCnt;
5203    schReqList->list.size  = elementCnt * sizeof(struct SchedulingRequestToAddMod *);
5204
5205    schReqList->list.array = NULLP;
5206    CU_ALLOC(schReqList->list.array, schReqList->list.size);
5207    if(!schReqList->list.array)
5208    {
5209       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSchedulingReqConfig");
5210       return RFAILED;
5211    }
5212
5213    for(idx=0;idx<schReqList->list.count; idx++)
5214    {
5215       schReqList->list.array[idx] = NULLP;
5216       CU_ALLOC(schReqList->list.array[idx], sizeof(struct SchedulingRequestToAddMod));
5217       if(!schReqList->list.array[idx])
5218       {
5219          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSchedulingReqConfig");
5220          return RFAILED;
5221       }
5222    }
5223
5224    idx = 0;
5225    schReqList->list.array[idx]->schedulingRequestId = SCH_REQ_ID;
5226
5227    schReqList->list.array[idx]->sr_ProhibitTimer = NULLP;
5228    CU_ALLOC(schReqList->list.array[idx]->sr_ProhibitTimer, sizeof(long));
5229    if(!schReqList->list.array[idx]->sr_ProhibitTimer)
5230    {
5231       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSchedulingReqConfig");
5232       return RFAILED;
5233    }
5234    *(schReqList->list.array[idx]->sr_ProhibitTimer) = SR_PROHIBIT_TMR;
5235    schReqList->list.array[idx]->sr_TransMax = SR_TRANS_MAX;
5236    schedulingRequestConfig->schedulingRequestToReleaseList = NULLP;
5237
5238    return ROK;
5239 }
5240 /*******************************************************************
5241  *
5242  * @brief Builds Mac cell group config
5243  *
5244  * @details
5245  *
5246  *    Function : BuildMacCellGrpCfg
5247  *
5248  *    Functionality: Builds Mac cell group config in DuToCuRrcContainer
5249  *
5250  * @params[in] MAC_CellGroupConfig_t *macCellGrpCfg
5251  *
5252  * @return ROK     - success
5253  *         RFAILED - failure
5254  *
5255  * ****************************************************************/
5256 uint8_t BuildMacCellGrpCfg(MAC_CellGroupConfig_t *macCellGrpCfg)
5257 {
5258    macCellGrpCfg->drx_Config = NULLP;
5259    macCellGrpCfg->schedulingRequestConfig = NULLP;
5260    CU_ALLOC(macCellGrpCfg->schedulingRequestConfig, sizeof(struct SchedulingRequestConfig));
5261    if(!macCellGrpCfg->schedulingRequestConfig)
5262    {
5263       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacCellGrpCfg");
5264       return RFAILED;
5265    }
5266
5267    if(BuildSchedulingReqConfig(macCellGrpCfg->schedulingRequestConfig) != ROK)
5268    {
5269       DU_LOG("\nERROR  -->  F1AP : BuildSchedulingReqConfig failed");
5270       return RFAILED;
5271    }
5272
5273    macCellGrpCfg->bsr_Config = NULLP;
5274    CU_ALLOC(macCellGrpCfg->bsr_Config, sizeof(struct BSR_Config));
5275    if(!macCellGrpCfg->bsr_Config)
5276    {
5277       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacCellGrpCfg");
5278       return RFAILED;
5279    }
5280
5281    if(BuildBsrConfig(macCellGrpCfg->bsr_Config) != ROK)
5282    {
5283       DU_LOG("\nERROR  -->  F1AP : BuildBsrConfig failed");
5284       return RFAILED;
5285    }
5286
5287    macCellGrpCfg->tag_Config = NULLP;
5288    CU_ALLOC(macCellGrpCfg->tag_Config, sizeof(struct TAG_Config));
5289    if(!macCellGrpCfg->tag_Config)
5290    {
5291       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacCellGrpCfg");
5292       return RFAILED;
5293    }
5294
5295    if(BuildTagConfig(macCellGrpCfg->tag_Config) != ROK)
5296    {
5297       DU_LOG("\nERROR  -->  F1AP : BuildTagConfig failed");
5298       return RFAILED;
5299    }
5300
5301    macCellGrpCfg->phr_Config = NULLP;
5302    CU_ALLOC(macCellGrpCfg->phr_Config, sizeof(struct MAC_CellGroupConfig__phr_Config));
5303    if(!macCellGrpCfg->phr_Config)
5304    {
5305       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacCellGrpCfg");
5306       return RFAILED;
5307    }
5308
5309    if(BuildPhrConfig(macCellGrpCfg->phr_Config) != ROK)
5310    {
5311       DU_LOG("\nERROR  -->  F1AP : BuildPhrConfig failed");
5312       return RFAILED;
5313    }
5314
5315    macCellGrpCfg->skipUplinkTxDynamic = false;
5316    macCellGrpCfg->ext1 = NULLP;
5317
5318    return ROK;
5319 }
5320 /*******************************************************************
5321  *
5322  * @brief Frees memeory allocated for SearchSpcToAddModList
5323  *
5324  * @details
5325  *
5326  *    Function : FreeSearchSpcToAddModList
5327  *
5328  *    Functionality: Deallocating memory of SearchSpcToAddModList
5329  *
5330  * @params[in] struct PDCCH_Config__searchSpacesToAddModList *searchSpcList
5331  *
5332  * @return void
5333  *
5334  4221 * ****************************************************************/
5335 void FreeSearchSpcToAddModList(struct PDCCH_Config__searchSpacesToAddModList *searchSpcList)
5336 {
5337    uint8_t idx1=0;
5338    uint8_t idx2=0;
5339    struct  SearchSpace *searchSpc=NULLP;
5340
5341    if(searchSpcList->list.array)
5342    {
5343       if(searchSpcList->list.array[idx2])
5344       {
5345          searchSpc = searchSpcList->list.array[idx2];
5346          if(searchSpc->controlResourceSetId)
5347          {
5348             if(searchSpc->monitoringSlotPeriodicityAndOffset)
5349             {
5350                if(searchSpc->monitoringSymbolsWithinSlot)
5351                {
5352                   if(searchSpc->monitoringSymbolsWithinSlot->buf)
5353                   {
5354                      if(searchSpc->nrofCandidates)
5355                      {
5356                         if(searchSpc->searchSpaceType)
5357                         {
5358                            CU_FREE(searchSpc->searchSpaceType->choice.ue_Specific,\
5359                                  sizeof(struct SearchSpace__searchSpaceType__ue_Specific));
5360                            CU_FREE(searchSpc->searchSpaceType, sizeof(struct
5361                                     SearchSpace__searchSpaceType));
5362                         }
5363                         CU_FREE(searchSpc->nrofCandidates,
5364                               sizeof(struct SearchSpace__nrofCandidates));
5365                      }
5366                      CU_FREE(searchSpc->monitoringSymbolsWithinSlot->buf, \
5367                            searchSpc->monitoringSymbolsWithinSlot->size);
5368                   }
5369                   CU_FREE(searchSpc->monitoringSymbolsWithinSlot,
5370                         sizeof(BIT_STRING_t));
5371                }
5372                CU_FREE(searchSpc->monitoringSlotPeriodicityAndOffset, \
5373                      sizeof(struct SearchSpace__monitoringSlotPeriodicityAndOffset));
5374             }
5375             CU_FREE(searchSpc->controlResourceSetId,
5376                   sizeof(ControlResourceSetId_t));
5377          }
5378       }
5379       for(idx1 = 0; idx1 < searchSpcList->list.count; idx1++)
5380       {
5381          CU_FREE(searchSpcList->list.array[idx1],
5382                sizeof(struct SearchSpace));
5383       }
5384       CU_FREE(searchSpcList->list.array,searchSpcList->list.size);
5385    }
5386 }
5387 /*******************************************************************
5388  *
5389  * @brief Frees memory allocated for PdschTimeDomAllocList
5390  *
5391  * @details
5392  *
5393  *    Function : FreePdschTimeDomAllocList
5394  *
5395  *    Functionality: Deallocating memory of PdschTimeDomAllocList
5396  *
5397  * @params[in] struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList
5398  *
5399  * @return void
5400  *
5401  4221 * ****************************************************************/
5402 void FreePdschTimeDomAllocList( struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList)
5403 {
5404    uint8_t idx1=0;
5405
5406    if(timeDomAllocList->choice.setup)
5407    {
5408       if(timeDomAllocList->choice.setup->list.array)
5409       {
5410          for(idx1 = 0; idx1 <timeDomAllocList->choice.setup->list.count ; idx1++)
5411          {
5412             CU_FREE(timeDomAllocList->choice.setup->list.array[idx1],
5413                   sizeof(struct PDSCH_TimeDomainResourceAllocation));
5414          }
5415          CU_FREE(timeDomAllocList->choice.setup->list.array, \
5416                timeDomAllocList->choice.setup->list.size);
5417       }
5418       CU_FREE(timeDomAllocList->choice.setup,\
5419             sizeof(struct PDSCH_TimeDomainResourceAllocationList));
5420    }
5421 }
5422 /*******************************************************************
5423  *
5424  * @brief Frees memory allocated for PuschTimeDomAllocList
5425  *
5426  *@details
5427  *
5428  *    Function : FreePuschTimeDomAllocList
5429  *
5430  *    Functionality: Deallocating memory of PuschTimeDomAllocList
5431  *
5432  * @params[in] PUSCH_Config_t *puschCfg
5433  *
5434  * @return void
5435  *
5436  ***********************************************************************/
5437 void FreePuschTimeDomAllocList(PUSCH_Config_t *puschCfg)
5438 {
5439    uint8_t idx1=0;
5440    uint8_t idx2=0;
5441    struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList_t=NULLP;
5442
5443    if(puschCfg->pusch_TimeDomainAllocationList)
5444    {
5445       timeDomAllocList_t=puschCfg->pusch_TimeDomainAllocationList;
5446       if(timeDomAllocList_t->choice.setup)
5447       {
5448          if(timeDomAllocList_t->choice.setup->list.array)
5449          {
5450             CU_FREE(timeDomAllocList_t->choice.setup->list.array[idx2]->k2, sizeof(long));
5451             for(idx1 = 0; idx1<timeDomAllocList_t->choice.setup->list.count; idx1++)
5452             {
5453                CU_FREE(timeDomAllocList_t->choice.setup->list.array[idx1],\
5454                      sizeof(PUSCH_TimeDomainResourceAllocation_t));
5455             }
5456             CU_FREE(timeDomAllocList_t->choice.setup->list.array, \
5457                   timeDomAllocList_t->choice.setup->list.size);
5458          }
5459          CU_FREE(timeDomAllocList_t->choice.setup, \
5460                sizeof(struct PUSCH_TimeDomainResourceAllocationList));
5461       }
5462       CU_FREE(puschCfg->transformPrecoder, sizeof(long));
5463       CU_FREE(puschCfg->pusch_TimeDomainAllocationList, \
5464             sizeof(struct PUSCH_Config__pusch_TimeDomainAllocationList));
5465    }
5466
5467 }
5468
5469 /*******************************************************************
5470  *
5471  * @brief Frees memory allocated for Dedicated PUCCH config
5472  *
5473  * @details
5474  *
5475  *    Function : FreeBWPUlDedPucchCfg
5476  *
5477  *    Functionality: Deallocating memory of Dedicated PUCCH cfg
5478  *
5479  * @params[in] BWP_UplinkDedicated__pucch_Config *ulBwpPucchCfg
5480  *
5481  * @return void
5482  *
5483  * ****************************************************************/
5484 void FreeBWPUlDedPucchCfg(struct BWP_UplinkDedicated__pucch_Config *ulBwpPucchCfg)
5485 {
5486    uint8_t arrIdx, rsrcIdx, rsrcSetIdx;
5487    PUCCH_Config_t *pucchCfg = NULLP;
5488    PUCCH_ResourceSet_t *rsrcSet = NULLP;
5489    PUCCH_Resource_t *rsrc = NULLP;
5490
5491    if(ulBwpPucchCfg)
5492    {
5493       if(ulBwpPucchCfg->choice.setup)
5494       {
5495          pucchCfg = ulBwpPucchCfg->choice.setup;
5496
5497          //Free resource set list
5498          if(pucchCfg->resourceSetToAddModList)
5499          {
5500             if(pucchCfg->resourceSetToAddModList->list.array)
5501             {
5502                for(rsrcSetIdx=0; rsrcSetIdx < pucchCfg->resourceSetToAddModList->list.count; rsrcSetIdx++)
5503                {
5504                   rsrcSet = pucchCfg->resourceSetToAddModList->list.array[rsrcSetIdx];
5505                   if(rsrcSet->resourceList.list.array)
5506                   {
5507                      for(rsrcIdx=0; rsrcIdx < rsrcSet->resourceList.list.count; rsrcIdx++)
5508                      {
5509                         CU_FREE(rsrcSet->resourceList.list.array[rsrcIdx], sizeof(PUCCH_ResourceId_t));
5510                      }
5511                      CU_FREE(rsrcSet->resourceList.list.array, rsrcSet->resourceList.list.size);
5512                   }
5513                   CU_FREE(pucchCfg->resourceSetToAddModList->list.array[rsrcSetIdx], sizeof(PUCCH_ResourceSet_t));
5514                }
5515                CU_FREE(pucchCfg->resourceSetToAddModList->list.array, pucchCfg->resourceSetToAddModList->list.size);
5516             }
5517             CU_FREE(pucchCfg->resourceSetToAddModList, sizeof(struct PUCCH_Config__resourceSetToAddModList));
5518          }
5519
5520          //Free resource list
5521          if(pucchCfg->resourceToAddModList)
5522          {
5523             if(pucchCfg->resourceToAddModList->list.array)
5524             {
5525                for(rsrcIdx=0; rsrcIdx < pucchCfg->resourceToAddModList->list.count; rsrcIdx++)
5526                {
5527                   rsrc = pucchCfg->resourceToAddModList->list.array[rsrcIdx];
5528                   CU_FREE(rsrc->format.choice.format1, sizeof(PUCCH_format1_t));
5529                   CU_FREE(pucchCfg->resourceToAddModList->list.array[rsrcIdx], sizeof(PUCCH_Resource_t));
5530                }
5531                CU_FREE(pucchCfg->resourceToAddModList->list.array, pucchCfg->resourceToAddModList->list.size);
5532             }
5533             CU_FREE(pucchCfg->resourceToAddModList, sizeof(struct PUCCH_Config__resourceToAddModList));
5534          }
5535
5536          //PUCCH Format 1
5537          if(pucchCfg->format1)
5538          {
5539             if(pucchCfg->format1->choice.setup)
5540             {
5541                CU_FREE(pucchCfg->format1->choice.setup->nrofSlots, sizeof(long));
5542                CU_FREE(pucchCfg->format1->choice.setup, sizeof(PUCCH_FormatConfig_t));
5543             }
5544             CU_FREE(pucchCfg->format1, sizeof(struct PUCCH_Config__format1));
5545          }
5546
5547          //DL DATA TO UL ACK
5548          if(pucchCfg->dl_DataToUL_ACK)
5549          {
5550             if(pucchCfg->dl_DataToUL_ACK->list.array)
5551             {
5552                for(arrIdx = 0; arrIdx <  pucchCfg->dl_DataToUL_ACK->list.count; arrIdx++)
5553                {
5554                   CU_FREE(pucchCfg->dl_DataToUL_ACK->list.array[arrIdx], sizeof(long));
5555                }
5556                CU_FREE(pucchCfg->dl_DataToUL_ACK->list.array, pucchCfg->dl_DataToUL_ACK->list.size);
5557             }
5558             CU_FREE(pucchCfg->dl_DataToUL_ACK, sizeof(struct PUCCH_Config__dl_DataToUL_ACK));
5559          }
5560
5561          CU_FREE(ulBwpPucchCfg->choice.setup, sizeof(PUCCH_Config_t));
5562       }
5563       CU_FREE(ulBwpPucchCfg, sizeof(struct BWP_UplinkDedicated__pucch_Config));
5564    }
5565 }
5566
5567 /*******************************************************************
5568  *
5569  * @brief Frees memory allocated for InitialUlBWP
5570  *
5571  * @details
5572  *
5573  *    Function : FreeInitialUlBWP
5574  *
5575  *    Functionality: Deallocating memory of InitialUlBWP
5576  *
5577  * @params[in] BWP_UplinkDedicated_t *ulBwp
5578  *
5579  * @return void
5580  *
5581  * ****************************************************************/
5582 void FreeInitialUlBWP(BWP_UplinkDedicated_t *ulBwp)
5583 {
5584    uint8_t  rSetIdx, rsrcIdx;
5585    SRS_Config_t   *srsCfg = NULLP;
5586    PUSCH_Config_t *puschCfg = NULLP;
5587    struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA *dmrsUlCfg = NULLP;
5588    struct SRS_Config__srs_ResourceSetToAddModList *rsrcSetList = NULLP;
5589    struct SRS_ResourceSet__srs_ResourceIdList *rsrcIdList = NULLP;
5590    struct SRS_Config__srs_ResourceToAddModList *resourceList = NULLP;
5591
5592    FreeBWPUlDedPucchCfg(ulBwp->pucch_Config);
5593
5594    if(ulBwp->pusch_Config)
5595    {
5596       if(ulBwp->pusch_Config->choice.setup)
5597       {
5598          puschCfg=ulBwp->pusch_Config->choice.setup;
5599          if(puschCfg->dataScramblingIdentityPUSCH)
5600          {
5601             if(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA)
5602             {
5603                FreePuschTimeDomAllocList(puschCfg);
5604                dmrsUlCfg=puschCfg->dmrs_UplinkForPUSCH_MappingTypeA;
5605                if(dmrsUlCfg->choice.setup)
5606                {
5607                   if(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition)
5608                   {
5609                      if(dmrsUlCfg->choice.setup->transformPrecodingDisabled)
5610                      {
5611                         CU_FREE(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0,\
5612                               sizeof(long));
5613                         CU_FREE(dmrsUlCfg->choice.setup->transformPrecodingDisabled,
5614                               sizeof(struct DMRS_UplinkConfig__transformPrecodingDisabled));
5615                      }
5616                      CU_FREE(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition,
5617                            sizeof(long));
5618                   }
5619                   CU_FREE(dmrsUlCfg->choice.setup,sizeof(DMRS_UplinkConfig_t));
5620                }
5621                CU_FREE(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA, \
5622                      sizeof(struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA));
5623             }
5624             CU_FREE(puschCfg->dataScramblingIdentityPUSCH, sizeof(long));
5625          }
5626          CU_FREE(ulBwp->pusch_Config->choice.setup, sizeof(PUSCH_Config_t));
5627       }
5628       CU_FREE(ulBwp->pusch_Config, sizeof(struct BWP_UplinkDedicated__pusch_Config));
5629
5630       /* Free SRS-Config */
5631       if(ulBwp->srs_Config)
5632       {
5633          if(ulBwp->srs_Config->choice.setup)
5634          {
5635             srsCfg = ulBwp->srs_Config->choice.setup;
5636
5637             /* Free Resource Set to add/mod list */
5638             if(srsCfg->srs_ResourceSetToAddModList)
5639             {
5640                rsrcSetList = srsCfg->srs_ResourceSetToAddModList;
5641                if(rsrcSetList->list.array)
5642                {
5643                   rSetIdx = 0;
5644
5645                   /* Free SRS resource Id list in this SRS resource set */
5646                   if(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList)
5647                   {
5648                      rsrcIdList = rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList;
5649
5650                      if(rsrcIdList->list.array)
5651                      {
5652                         for(rsrcIdx = 0; rsrcIdx < rsrcIdList->list.count; rsrcIdx++)
5653                         {
5654                            CU_FREE(rsrcIdList->list.array[rsrcIdx], sizeof(SRS_ResourceId_t));
5655                         }
5656                         CU_FREE(rsrcIdList->list.array, rsrcIdList->list.size);
5657                      }
5658                      CU_FREE(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList,\
5659                            sizeof(struct SRS_ResourceSet__srs_ResourceIdList));
5660                   }
5661
5662                   /* Free resource type info for this SRS resource set */
5663                   CU_FREE(rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic, \
5664                         sizeof(struct SRS_ResourceSet__resourceType__aperiodic));
5665
5666                   /* Free memory for each resource set */
5667                   for(rSetIdx = 0; rSetIdx < rsrcSetList->list.count; rSetIdx++)
5668                   {
5669                      CU_FREE(rsrcSetList->list.array[rSetIdx], sizeof(SRS_ResourceSet_t));
5670                   }
5671                   CU_FREE(rsrcSetList->list.array, rsrcSetList->list.size);
5672                }
5673                CU_FREE(srsCfg->srs_ResourceSetToAddModList, \
5674                      sizeof(struct SRS_Config__srs_ResourceSetToAddModList));
5675             }
5676
5677             /* Free resource to add/modd list */
5678             if(srsCfg->srs_ResourceToAddModList)
5679             {
5680                resourceList = srsCfg->srs_ResourceToAddModList;
5681                if(resourceList->list.array)
5682                {
5683                   rsrcIdx = 0;
5684                   CU_FREE(resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2,\
5685                         sizeof(struct SRS_Resource__transmissionComb__n2));
5686                   CU_FREE(resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic,\
5687                         sizeof(struct SRS_Resource__resourceType__aperiodic));
5688
5689                   for(rsrcIdx = 0; rsrcIdx < resourceList->list.count; rsrcIdx++)
5690                   {
5691                      CU_FREE(resourceList->list.array[rsrcIdx], sizeof(SRS_Resource_t));
5692                   }
5693                   CU_FREE(resourceList->list.array, resourceList->list.size);
5694                }
5695                CU_FREE(srsCfg->srs_ResourceToAddModList, \
5696                      sizeof(struct SRS_Config__srs_ResourceToAddModList));
5697             }
5698
5699             CU_FREE(ulBwp->srs_Config->choice.setup, sizeof(SRS_Config_t));
5700          }
5701          CU_FREE(ulBwp->srs_Config, sizeof(struct BWP_UplinkDedicated__srs_Config));
5702       }
5703    }
5704 }
5705 /*******************************************************************
5706  *
5707  * @brief Frees memory allocated for initialUplinkBWP
5708  *
5709  * @details
5710  *
5711  *    Function : FreeinitialUplinkBWP
5712  *
5713  *    Functionality: Deallocating memory of initialUplinkBWP
5714  *
5715  * @params[in] UplinkConfig_t *ulCfg
5716  *
5717  * @return void
5718  *
5719  *
5720  * ****************************************************************/
5721 void FreeinitialUplinkBWP(UplinkConfig_t *ulCfg)
5722 {
5723    BWP_UplinkDedicated_t *ulBwp=NULLP;
5724    struct UplinkConfig__pusch_ServingCellConfig *puschCfg=NULLP;
5725
5726    if(ulCfg->initialUplinkBWP)
5727    {
5728       ulBwp=ulCfg->initialUplinkBWP;
5729       if(ulCfg->firstActiveUplinkBWP_Id)
5730       {
5731          if(ulCfg->pusch_ServingCellConfig)
5732          {
5733             puschCfg=ulCfg->pusch_ServingCellConfig;
5734             if(puschCfg->choice.setup)
5735             {
5736                if(puschCfg->choice.setup->ext1)
5737                {
5738                   CU_FREE(puschCfg->choice.setup->ext1->\
5739                         processingType2Enabled,sizeof(BOOLEAN_t));
5740                   CU_FREE(puschCfg->choice.setup->ext1->\
5741                         maxMIMO_Layers,sizeof(long));
5742                   CU_FREE(puschCfg->choice.setup->ext1, \
5743                         sizeof(struct PUSCH_ServingCellConfig__ext1));
5744                }
5745                CU_FREE(puschCfg->choice.setup, sizeof(struct PUSCH_ServingCellConfig));
5746             }
5747             CU_FREE(ulCfg->pusch_ServingCellConfig, sizeof(struct UplinkConfig__pusch_ServingCellConfig));
5748          }
5749          CU_FREE(ulCfg->firstActiveUplinkBWP_Id, sizeof(BWP_Id_t));
5750       }
5751       FreeInitialUlBWP(ulBwp);
5752       CU_FREE(ulCfg->initialUplinkBWP, sizeof(BWP_UplinkDedicated_t));
5753    }
5754 }
5755 /*******************************************************************
5756  *
5757  * @brief Frees emmory allocated for BWPDlDedPdschCfg
5758  *
5759  * @details
5760  *
5761  *    Function : FreeBWPDlDedPdschCfg
5762  *
5763  *    Functionality: Deallocating memory of BWPDlDedPdschCfg
5764  *
5765  * @params[in] BWP_DownlinkDedicated_t *dlBwp
5766  *
5767  * @return void
5768  *
5769  *
5770  * ****************************************************************/
5771 void FreeBWPDlDedPdschCfg(BWP_DownlinkDedicated_t *dlBwp)
5772 {
5773    struct PDSCH_Config *pdschCfg=NULLP;
5774    struct PDSCH_Config__prb_BundlingType *prbBndlType=NULLP;
5775    struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList=NULLP;
5776    struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA *dmrsDlCfg=NULLP;
5777
5778    if(dlBwp->pdsch_Config->choice.setup)
5779    {
5780       pdschCfg=dlBwp->pdsch_Config->choice.setup;
5781       if(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA)
5782       {
5783          if(pdschCfg->pdsch_TimeDomainAllocationList)
5784          {
5785             timeDomAllocList=pdschCfg->pdsch_TimeDomainAllocationList;
5786             if(pdschCfg->maxNrofCodeWordsScheduledByDCI)
5787             {
5788                prbBndlType=&pdschCfg->prb_BundlingType;
5789                CU_FREE(prbBndlType->choice.staticBundling,\
5790                      sizeof(struct PDSCH_Config__prb_BundlingType__staticBundling));
5791                CU_FREE(pdschCfg->maxNrofCodeWordsScheduledByDCI, sizeof(long));
5792             }
5793             FreePdschTimeDomAllocList(timeDomAllocList);
5794             CU_FREE(pdschCfg->pdsch_TimeDomainAllocationList, \
5795                   sizeof(struct PDSCH_Config__pdsch_TimeDomainAllocationList));
5796          }
5797          dmrsDlCfg=pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA;
5798          if(dmrsDlCfg->choice.setup)
5799          {
5800             CU_FREE(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition,
5801                   sizeof(long));
5802             CU_FREE(dmrsDlCfg->choice.setup, sizeof(struct DMRS_DownlinkConfig));
5803          }
5804          CU_FREE(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA, \
5805                sizeof(struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA));
5806       }
5807       CU_FREE(dlBwp->pdsch_Config->choice.setup, sizeof(struct PDSCH_Config));
5808    }
5809 }
5810 /*******************************************************************
5811  *
5812  * @brief Frees emmory allocated for BWPDlDedPdcchCfg
5813  *
5814  * @details
5815  *
5816  *    Function : FreeBWPDlDedPdcchCfg
5817  *
5818  *    Functionality: Deallocating memory of BWPDlDedPdcchCfg
5819  *
5820  * @params[in] BWP_DownlinkDedicated_t *dlBwp
5821  *
5822  * @return void
5823  *
5824  *
5825  * ****************************************************************/
5826 void FreeBWPDlDedPdcchCfg(BWP_DownlinkDedicated_t *dlBwp)
5827 {
5828    uint8_t idx1=0;
5829    uint8_t idx2=0;
5830    struct PDCCH_Config *pdcchCfg=NULLP;
5831    struct ControlResourceSet *controlRSet=NULLP;
5832    struct PDCCH_Config__controlResourceSetToAddModList *controlRSetList=NULLP;
5833
5834    if(dlBwp->pdcch_Config->choice.setup)
5835    {
5836       pdcchCfg=dlBwp->pdcch_Config->choice.setup;
5837       if(pdcchCfg->controlResourceSetToAddModList)
5838       {
5839          controlRSetList = pdcchCfg->controlResourceSetToAddModList;
5840          if(controlRSetList->list.array)
5841          {
5842             controlRSet = controlRSetList->list.array[idx2];
5843             if(controlRSet)
5844             {
5845                if(controlRSet->frequencyDomainResources.buf)
5846                {
5847                   if(controlRSet->pdcch_DMRS_ScramblingID)
5848                   {
5849                      if(pdcchCfg->searchSpacesToAddModList)
5850                      {
5851                         FreeSearchSpcToAddModList(pdcchCfg->searchSpacesToAddModList);
5852                         CU_FREE(pdcchCfg->searchSpacesToAddModList, \
5853                               sizeof(struct PDCCH_Config__searchSpacesToAddModList));
5854                      }
5855                      CU_FREE(controlRSet->pdcch_DMRS_ScramblingID, sizeof(long));
5856                   }
5857                   CU_FREE(controlRSet->frequencyDomainResources.buf, \
5858                         controlRSet->frequencyDomainResources.size);
5859                }
5860             }
5861             for(idx1 = 0; idx1 <controlRSetList->list.count; idx1++)
5862             {
5863                CU_FREE(controlRSetList->list.array[idx1], sizeof(struct ControlResourceSet));
5864             }
5865             CU_FREE(controlRSetList->list.array, controlRSetList->list.size);
5866          }
5867          CU_FREE(pdcchCfg->controlResourceSetToAddModList, \
5868                sizeof(struct PDCCH_Config__controlResourceSetToAddModList));
5869       }
5870       CU_FREE(dlBwp->pdcch_Config->choice.setup, sizeof(struct PDCCH_Config));
5871    }
5872 }
5873 /*******************************************************************
5874  *
5875  * @brief Builds RLC Config
5876  *
5877  * @details
5878  *
5879  *    Function : BuildRlcConfig
5880  *
5881  *    Functionality: Builds RLC Config in BuildRlcBearerToAddModList
5882  *
5883  * @params[in] RLC_Config *rlcConfig
5884  *
5885  * @return ROK     - success
5886  *         RFAILED - failure
5887  *
5888  * ****************************************************************/
5889 uint8_t BuildRlcConfig(RlcLcCfg rlcLcCfgDb, struct RLC_Config *rlcConfig)
5890 {
5891    rlcConfig->present = rlcLcCfgDb.rlcMode;
5892
5893    switch(rlcConfig->present)
5894    {
5895       case RLC_Config_PR_am:
5896          {
5897             rlcConfig->choice.am = NULLP;
5898             CU_ALLOC(rlcConfig->choice.am, sizeof(struct RLC_Config__am));
5899             if(!rlcConfig->choice.am)
5900             {
5901                DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfig");
5902                return RFAILED;
5903             }
5904
5905             /* UL */
5906             rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength = NULLP;
5907             CU_ALLOC(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
5908             if(!rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength)
5909             {
5910                DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfig");
5911                return RFAILED;
5912             }
5913             *(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength) = rlcLcCfgDb.u.amCfg.ulAmCfg.snLenUl;
5914             rlcConfig->choice.am->ul_AM_RLC.t_PollRetransmit  = rlcLcCfgDb.u.amCfg.ulAmCfg.pollRetxTmr;
5915             rlcConfig->choice.am->ul_AM_RLC.pollPDU           = rlcLcCfgDb.u.amCfg.ulAmCfg.pollPdu;
5916             rlcConfig->choice.am->ul_AM_RLC.pollByte          = rlcLcCfgDb.u.amCfg.ulAmCfg.pollByte;
5917             rlcConfig->choice.am->ul_AM_RLC.maxRetxThreshold  = rlcLcCfgDb.u.amCfg.ulAmCfg.maxRetxTh;
5918
5919             /* DL */
5920             rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength = NULLP;
5921             CU_ALLOC(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
5922             if(!rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength)
5923             {
5924                DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfig");
5925                return RFAILED;
5926             }
5927             *(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength) = rlcLcCfgDb.u.amCfg.dlAmCfg.snLenDl;
5928             rlcConfig->choice.am->dl_AM_RLC.t_Reassembly      = rlcLcCfgDb.u.amCfg.dlAmCfg.reAssemTmr;
5929             rlcConfig->choice.am->dl_AM_RLC.t_StatusProhibit  = rlcLcCfgDb.u.amCfg.dlAmCfg.statProhTmr;
5930
5931             break;
5932          }
5933
5934       case RLC_Config_PR_um_Bi_Directional:
5935          {
5936             rlcConfig->choice.um_Bi_Directional = NULLP;
5937             CU_ALLOC(rlcConfig->choice.um_Bi_Directional, sizeof(struct RLC_Config__um_Bi_Directional));
5938             if(!rlcConfig->choice.um_Bi_Directional)
5939             {
5940                DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfig");
5941                return RFAILED;
5942             }
5943
5944             /* UL */
5945             rlcConfig->choice.um_Bi_Directional->ul_UM_RLC.sn_FieldLength = NULLP;
5946             CU_ALLOC(rlcConfig->choice.um_Bi_Directional->ul_UM_RLC.sn_FieldLength, sizeof(SN_FieldLengthUM_t));
5947             if(!rlcConfig->choice.um_Bi_Directional->ul_UM_RLC.sn_FieldLength)
5948             {
5949                DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfig");
5950                return RFAILED;
5951             }
5952             *(rlcConfig->choice.um_Bi_Directional->ul_UM_RLC.sn_FieldLength) = rlcLcCfgDb.u.umBiDirCfg.ulUmCfg.snLenUlUm;
5953
5954             /* DL */
5955             rlcConfig->choice.um_Bi_Directional->dl_UM_RLC.sn_FieldLength = NULLP;
5956             CU_ALLOC(rlcConfig->choice.um_Bi_Directional->dl_UM_RLC.sn_FieldLength, sizeof(SN_FieldLengthUM_t));
5957             if(!rlcConfig->choice.um_Bi_Directional->dl_UM_RLC.sn_FieldLength)
5958             {
5959                DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfig");
5960                return RFAILED;
5961             }
5962             *(rlcConfig->choice.um_Bi_Directional->dl_UM_RLC.sn_FieldLength) = rlcLcCfgDb.u.umBiDirCfg.dlUmCfg.snLenDlUm;
5963             rlcConfig->choice.um_Bi_Directional->dl_UM_RLC.t_Reassembly = rlcLcCfgDb.u.umBiDirCfg.dlUmCfg.reAssemTmr;
5964             break;
5965          }
5966    }
5967    return ROK;
5968 }
5969
5970 /*******************************************************************
5971  *
5972  * @brief Builds MAC LC Config
5973  *
5974  * @details
5975  *
5976  *    Function : BuildMacLCConfig
5977  *
5978  *    Functionality: Builds MAC LC Config in BuildRlcBearerToAddModList
5979  *
5980  * @params[in] struct LogicalChannelConfig macLcConfig
5981  *
5982  * @return ROK     - success
5983  *         RFAILED - failure
5984  *
5985  * ****************************************************************/
5986 uint8_t BuildMacLCConfig(MacLcCfg macLcCfgDb, struct LogicalChannelConfig *macLcConfig)
5987 {
5988
5989    macLcConfig->ul_SpecificParameters = NULLP;
5990    CU_ALLOC(macLcConfig->ul_SpecificParameters, sizeof(struct LogicalChannelConfig__ul_SpecificParameters));
5991    if(!macLcConfig->ul_SpecificParameters)
5992    {
5993       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacLCConfig");
5994       return RFAILED;
5995    }
5996
5997    macLcConfig->ul_SpecificParameters->priority = macLcCfgDb.priority;
5998    macLcConfig->ul_SpecificParameters->prioritisedBitRate =     macLcCfgDb.pbr;
5999    macLcConfig->ul_SpecificParameters->bucketSizeDuration =     macLcCfgDb.bsd;
6000    macLcConfig->ul_SpecificParameters->allowedServingCells = NULLP;
6001    macLcConfig->ul_SpecificParameters->allowedSCS_List = NULLP;
6002    macLcConfig->ul_SpecificParameters->maxPUSCH_Duration = NULLP;
6003    macLcConfig->ul_SpecificParameters->configuredGrantType1Allowed = NULLP;
6004
6005    macLcConfig->ul_SpecificParameters->logicalChannelGroup = NULLP;
6006    CU_ALLOC(macLcConfig->ul_SpecificParameters->logicalChannelGroup,    sizeof(long));
6007    if(!macLcConfig->ul_SpecificParameters->logicalChannelGroup)
6008    {
6009       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacLCConfig");
6010       return RFAILED;
6011    }
6012    *(macLcConfig->ul_SpecificParameters->logicalChannelGroup) = macLcCfgDb.lcGroup;
6013
6014    macLcConfig->ul_SpecificParameters->schedulingRequestID = NULLP;
6015    CU_ALLOC(macLcConfig->ul_SpecificParameters->schedulingRequestID,    sizeof(SchedulingRequestId_t));
6016    if(!macLcConfig->ul_SpecificParameters->schedulingRequestID)
6017    {
6018       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacLCConfig");
6019       return RFAILED;
6020    }
6021    *(macLcConfig->ul_SpecificParameters->schedulingRequestID) = macLcCfgDb.schReqId;
6022
6023    macLcConfig->ul_SpecificParameters->logicalChannelSR_Mask = false;
6024    macLcConfig->ul_SpecificParameters->logicalChannelSR_DelayTimerApplied = false;
6025    macLcConfig->ul_SpecificParameters->bitRateQueryProhibitTimer = NULLP;
6026
6027    return ROK;
6028 }
6029 /*******************************************************************
6030  *
6031  * @brief Builds RLC Bearer to Add/Mod list
6032  *
6033  * @details
6034  *
6035  *    Function :BuildRlcBearerToAddModList
6036  *
6037  *    Functionality: Builds RLC Bearer to Add/Mod list in DuToCuRrcContainer
6038  *
6039  * @params[in] rlc_BearerToAddModList
6040  *
6041  * @return ROK     - success
6042  *         RFAILED - failure
6043  *
6044  * ****************************************************************/
6045 uint8_t BuildRlcBearerToAddModList(CuUeCb *ueCb, struct CellGroupConfigRrc__rlc_BearerToAddModList *rlcBearerList, bool updateAllRbCfg)
6046 {
6047    uint8_t idx, srbIdx = 0, drbIdx = 0, elementCnt=0;
6048
6049    if(updateAllRbCfg)
6050       elementCnt = ueCb->numSrb + ueCb->numDrb;
6051    else
6052    {
6053       for(srbIdx = 0; srbIdx< ueCb->numSrb; srbIdx++)
6054       {
6055          if(ueCb->srbList[srbIdx].cfgSentToUe == false)
6056             elementCnt++;
6057       }
6058
6059       for(drbIdx = 0; drbIdx< ueCb->numDrb; drbIdx++)
6060       {
6061          if(ueCb->drbList[drbIdx].cfgSentToUe == false)
6062             elementCnt++;
6063       }
6064    }
6065
6066    rlcBearerList->list.count = elementCnt;
6067    rlcBearerList->list.size  = elementCnt * sizeof(struct RLC_BearerConfig *);
6068
6069    rlcBearerList->list.array = NULLP;
6070    CU_ALLOC(rlcBearerList->list.array, rlcBearerList->list.size);
6071    if(!rlcBearerList->list.array)
6072    {
6073       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
6074       return RFAILED;
6075    }
6076
6077    for(idx=0; idx<rlcBearerList->list.count; idx++)
6078    {
6079       rlcBearerList->list.array[idx] = NULLP;
6080       CU_ALLOC(rlcBearerList->list.array[idx], sizeof(struct RLC_BearerConfig));
6081       if(!rlcBearerList->list.array[idx])
6082       {
6083          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
6084          return RFAILED;
6085       }
6086    }
6087
6088    idx = 0;
6089
6090    for(srbIdx=0; srbIdx < ueCb->numSrb; srbIdx++)
6091    {
6092       if(!updateAllRbCfg && ueCb->srbList[srbIdx].cfgSentToUe)
6093          continue;
6094
6095       rlcBearerList->list.array[idx]->logicalChannelIdentity = ueCb->srbList[srbIdx].lcId;
6096
6097       CU_ALLOC(rlcBearerList->list.array[idx]->servedRadioBearer, sizeof(struct RLC_BearerConfig__servedRadioBearer));
6098       if(!rlcBearerList->list.array[idx]->servedRadioBearer)
6099       {
6100          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
6101          return RFAILED;
6102       }
6103
6104       rlcBearerList->list.array[idx]->servedRadioBearer->present = RLC_BearerConfig__servedRadioBearer_PR_srb_Identity;
6105       rlcBearerList->list.array[idx]->servedRadioBearer->choice.srb_Identity = ueCb->srbList[srbIdx].srbId;
6106
6107       rlcBearerList->list.array[idx]->reestablishRLC = NULLP;
6108       rlcBearerList->list.array[idx]->rlc_Config = NULLP;
6109       CU_ALLOC(rlcBearerList->list.array[idx]->rlc_Config, sizeof(struct RLC_Config));
6110       if(!rlcBearerList->list.array[idx]->rlc_Config)
6111       {
6112          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
6113          return RFAILED;
6114       }
6115
6116       if(BuildRlcConfig(ueCb->srbList[srbIdx].rlcLcCfg, rlcBearerList->list.array[idx]->rlc_Config) != ROK)
6117       {
6118          DU_LOG("\nERROR  -->  F1AP : BuildRlcConfig failed");
6119          return RFAILED;
6120       }
6121
6122       rlcBearerList->list.array[idx]->mac_LogicalChannelConfig = NULLP;
6123       CU_ALLOC(rlcBearerList->list.array[idx]->mac_LogicalChannelConfig, sizeof(struct LogicalChannelConfig));
6124       if(!rlcBearerList->list.array[idx]->mac_LogicalChannelConfig)
6125       {
6126          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
6127          return RFAILED;
6128       }
6129
6130       if(BuildMacLCConfig(ueCb->srbList[srbIdx].macLcCfg, rlcBearerList->list.array[idx]->mac_LogicalChannelConfig) != ROK)
6131       {
6132          DU_LOG("\nERROR  -->  F1AP : BuildMacLCConfig failed");
6133          return RFAILED;
6134       }
6135       idx++;
6136    }
6137
6138    for(drbIdx=0; drbIdx < ueCb->numDrb; drbIdx++)
6139    {
6140       if(!updateAllRbCfg && ueCb->srbList[srbIdx].cfgSentToUe)
6141          continue;
6142
6143       rlcBearerList->list.array[idx]->logicalChannelIdentity = ueCb->drbList[drbIdx].lcId;
6144
6145       CU_ALLOC(rlcBearerList->list.array[idx]->servedRadioBearer, sizeof(struct RLC_BearerConfig__servedRadioBearer));
6146       if(!rlcBearerList->list.array[idx]->servedRadioBearer)
6147       {
6148          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
6149          return RFAILED;
6150       }
6151
6152       rlcBearerList->list.array[idx]->servedRadioBearer->present = RLC_BearerConfig__servedRadioBearer_PR_drb_Identity;
6153       rlcBearerList->list.array[idx]->servedRadioBearer->choice.drb_Identity = ueCb->drbList[drbIdx].drbId;
6154
6155       rlcBearerList->list.array[idx]->reestablishRLC = NULLP;
6156       rlcBearerList->list.array[idx]->rlc_Config = NULLP;
6157       CU_ALLOC(rlcBearerList->list.array[idx]->rlc_Config, sizeof(struct RLC_Config));
6158       if(!rlcBearerList->list.array[idx]->rlc_Config)
6159       {
6160          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
6161          return RFAILED;
6162       }
6163
6164       if(BuildRlcConfig(ueCb->drbList[drbIdx].rlcLcCfg, rlcBearerList->list.array[idx]->rlc_Config) != ROK)
6165       {
6166          DU_LOG("\nERROR  -->  F1AP : BuildRlcConfig failed");
6167          return RFAILED;
6168       }
6169
6170       rlcBearerList->list.array[idx]->mac_LogicalChannelConfig = NULLP;
6171       CU_ALLOC(rlcBearerList->list.array[idx]->mac_LogicalChannelConfig, sizeof(struct LogicalChannelConfig));
6172       if(!rlcBearerList->list.array[idx]->mac_LogicalChannelConfig)
6173       {
6174          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
6175          return RFAILED;
6176       }
6177
6178       if(BuildMacLCConfig(ueCb->drbList[drbIdx].macLcCfg, rlcBearerList->list.array[idx]->mac_LogicalChannelConfig) != ROK)
6179       {
6180          DU_LOG("\nERROR  -->  F1AP : BuildMacLCConfig failed");
6181          return RFAILED;
6182       }
6183       idx++;
6184    }
6185    return ROK;
6186 }
6187
6188 /*******************************************************************
6189  *
6190  * @brief Free memory allocated for CellGroupConfig
6191  *
6192  * @details
6193  *
6194  *    Function : FreeMemCellGrpCfg
6195  *
6196  *    Functionality: Deallocating memory of CellGroupConfig
6197  *
6198  * @params[in] pointer to CellGroupConfigRrc_t
6199  *
6200  * @return ROK     - success
6201  *         RFAILED - failure
6202  *
6203  ******************************************************************/
6204 uint8_t FreeMemCellGrpCfg(CellGroupConfigRrc_t *cellGrpCfg)
6205 {
6206    uint8_t idx=0;
6207    SpCellConfig_t *spCellCfg=NULLP;
6208    ServingCellConfig_t *srvCellCfg=NULLP;
6209    BWP_DownlinkDedicated_t *dlBwp=NULLP;
6210    MAC_CellGroupConfig_t *macCellGrpCfg=NULLP;
6211    PhysicalCellGroupConfig_t *phyCellGrpCfg=NULLP;
6212    struct CellGroupConfigRrc__rlc_BearerToAddModList *rlcBearerList=NULLP;
6213    struct RLC_Config *rlcConfig=NULLP;
6214    struct LogicalChannelConfig *macLcConfig=NULLP;
6215    struct SchedulingRequestConfig *schedulingRequestConfig=NULLP;
6216    struct SchedulingRequestConfig__schedulingRequestToAddModList *schReqList=NULLP;
6217    struct TAG_Config *tagConfig=NULLP;
6218    struct TAG_Config__tag_ToAddModList *tagList=NULLP;
6219    struct MAC_CellGroupConfig__phr_Config *phrConfig=NULLP;
6220    struct ServingCellConfig__pdsch_ServingCellConfig *pdschCfg=NULLP;
6221
6222    rlcBearerList = cellGrpCfg->rlc_BearerToAddModList;
6223    if(rlcBearerList)
6224    {
6225       if(rlcBearerList->list.array)
6226       {
6227          for(idx=0; idx<rlcBearerList->list.count; idx++)
6228          {
6229             if(rlcBearerList->list.array[idx])
6230             {
6231                rlcConfig   = rlcBearerList->list.array[idx]->rlc_Config;
6232                macLcConfig = rlcBearerList->list.array[idx]->mac_LogicalChannelConfig;
6233                if(rlcConfig)
6234                {
6235                   if(rlcConfig->choice.am)
6236                   {
6237                      CU_FREE(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
6238                      CU_FREE(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
6239                      CU_FREE(rlcConfig->choice.am, sizeof(struct RLC_Config__am));
6240                   }
6241                   CU_FREE(rlcConfig, sizeof(struct RLC_Config));
6242                }
6243                CU_FREE(rlcBearerList->list.array[idx]->servedRadioBearer, sizeof(struct RLC_BearerConfig__servedRadioBearer));
6244                if(macLcConfig)
6245                {
6246                   if(macLcConfig->ul_SpecificParameters)
6247                   {
6248                      CU_FREE(macLcConfig->ul_SpecificParameters->schedulingRequestID,   sizeof(SchedulingRequestId_t));
6249                      CU_FREE(macLcConfig->ul_SpecificParameters->logicalChannelGroup,   sizeof(long));
6250                      CU_FREE(macLcConfig->ul_SpecificParameters, sizeof(struct LogicalChannelConfig__ul_SpecificParameters));
6251                   }
6252                   CU_FREE(rlcBearerList->list.array[idx]->mac_LogicalChannelConfig, sizeof(struct LogicalChannelConfig));
6253                }
6254                CU_FREE(rlcBearerList->list.array[idx], sizeof(struct RLC_BearerConfig));
6255             }
6256          }
6257          CU_FREE(rlcBearerList->list.array, rlcBearerList->list.size);
6258       }
6259       CU_FREE(cellGrpCfg->rlc_BearerToAddModList, sizeof(struct CellGroupConfigRrc__rlc_BearerToAddModList));
6260    }
6261
6262    macCellGrpCfg = cellGrpCfg->mac_CellGroupConfig;
6263    if(macCellGrpCfg)
6264    {
6265       schedulingRequestConfig = macCellGrpCfg->schedulingRequestConfig;
6266       if(schedulingRequestConfig)
6267       {
6268          schReqList = schedulingRequestConfig->schedulingRequestToAddModList;
6269          if(schReqList)
6270          {
6271             if(schReqList->list.array)
6272             {
6273                for(idx=0;idx<schReqList->list.count; idx++)
6274                {
6275                   if(schReqList->list.array[idx])
6276                   {
6277                      CU_FREE(schReqList->list.array[idx]->sr_ProhibitTimer, sizeof(long));
6278                      CU_FREE(schReqList->list.array[idx], sizeof(struct SchedulingRequestToAddMod));
6279                   }
6280                }
6281                CU_FREE(schReqList->list.array, schReqList->list.size);
6282             }
6283             CU_FREE(schedulingRequestConfig->schedulingRequestToAddModList,\
6284                   sizeof(struct SchedulingRequestConfig__schedulingRequestToAddModList));    }
6285             CU_FREE(macCellGrpCfg->schedulingRequestConfig, sizeof(struct SchedulingRequestConfig));
6286       }
6287       if(macCellGrpCfg->bsr_Config)
6288       {
6289          CU_FREE(macCellGrpCfg->bsr_Config, sizeof(struct BSR_Config));
6290       }
6291       tagConfig = macCellGrpCfg->tag_Config;
6292       if(tagConfig)
6293       {
6294          tagList = tagConfig->tag_ToAddModList;
6295          if(tagList)
6296          {
6297             if(tagList->list.array)
6298             {
6299                for(idx=0; idx<tagList->list.count; idx++)
6300                {
6301                   CU_FREE(tagList->list.array[idx], sizeof(struct TAG));
6302                }
6303                CU_FREE(tagList->list.array, tagList->list.size);
6304             }
6305             CU_FREE(tagConfig->tag_ToAddModList, sizeof(struct TAG_Config__tag_ToAddModList));
6306          }
6307          CU_FREE(tagConfig, sizeof(struct TAG_Config));
6308       }
6309
6310       phrConfig = macCellGrpCfg->phr_Config;
6311       if(phrConfig)
6312       {
6313          CU_FREE(phrConfig->choice.setup, sizeof(struct PHR_Config));
6314          CU_FREE(phrConfig, sizeof(struct MAC_CellGroupConfig__phr_Config));
6315       }
6316
6317       CU_FREE(macCellGrpCfg, sizeof(MAC_CellGroupConfig_t));
6318    }
6319
6320    phyCellGrpCfg = cellGrpCfg->physicalCellGroupConfig;
6321    if(phyCellGrpCfg)
6322    {
6323       CU_FREE(phyCellGrpCfg->p_NR_FR1, sizeof(long));
6324       CU_FREE(phyCellGrpCfg, sizeof(PhysicalCellGroupConfig_t));
6325    }
6326
6327    spCellCfg = cellGrpCfg->spCellConfig;
6328    if(spCellCfg)
6329    {
6330       if(spCellCfg->servCellIndex)
6331       {
6332          if(spCellCfg->rlmInSyncOutOfSyncThreshold)
6333          {
6334             if(spCellCfg->spCellConfigDedicated)
6335             {
6336                srvCellCfg = spCellCfg->spCellConfigDedicated;
6337                if(srvCellCfg->initialDownlinkBWP)
6338                {
6339                   dlBwp = srvCellCfg->initialDownlinkBWP;
6340                   if(srvCellCfg->firstActiveDownlinkBWP_Id)
6341                   {
6342                      if(srvCellCfg->defaultDownlinkBWP_Id)
6343                      {
6344                         if(srvCellCfg->uplinkConfig)
6345                         {
6346                            if(srvCellCfg->pdsch_ServingCellConfig)
6347                            {
6348                               pdschCfg= srvCellCfg->pdsch_ServingCellConfig;
6349                               if(pdschCfg->choice.setup)
6350                               {
6351                                  CU_FREE(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH,sizeof(long));
6352                                  CU_FREE(pdschCfg->choice.setup, sizeof( struct PDSCH_ServingCellConfig));
6353                               }
6354                               CU_FREE(srvCellCfg->pdsch_ServingCellConfig, sizeof(struct
6355                                        ServingCellConfig__pdsch_ServingCellConfig));
6356                            }
6357                            FreeinitialUplinkBWP(srvCellCfg->uplinkConfig);
6358                            CU_FREE(srvCellCfg->uplinkConfig, sizeof(UplinkConfig_t));
6359                         }
6360                         CU_FREE(srvCellCfg->defaultDownlinkBWP_Id, sizeof(long));
6361                      }
6362                      CU_FREE(srvCellCfg->firstActiveDownlinkBWP_Id, sizeof(long));
6363                   }
6364                   if(dlBwp->pdcch_Config)
6365                   {
6366                      if(dlBwp->pdsch_Config)
6367                      {
6368                         FreeBWPDlDedPdschCfg(dlBwp);
6369                         CU_FREE(dlBwp->pdsch_Config, sizeof(struct BWP_DownlinkDedicated__pdsch_Config));
6370                      }
6371                      FreeBWPDlDedPdcchCfg(dlBwp);
6372                      CU_FREE(dlBwp->pdcch_Config, sizeof(struct BWP_DownlinkDedicated__pdcch_Config));
6373                   }
6374                   CU_FREE(srvCellCfg->initialDownlinkBWP, sizeof(BWP_DownlinkDedicated_t));
6375                }
6376                CU_FREE(spCellCfg->spCellConfigDedicated, sizeof(ServingCellConfig_t));
6377             }
6378             CU_FREE(spCellCfg->rlmInSyncOutOfSyncThreshold, sizeof(long));
6379          }
6380          CU_FREE(spCellCfg->servCellIndex, sizeof(long));
6381       }
6382       CU_FREE(spCellCfg,sizeof(SpCellConfig_t));
6383    }
6384    return ROK;
6385 }
6386
6387 /*******************************************************************
6388  *
6389  * @brief Fills CellGroupConfig
6390  *
6391  * @details
6392  *
6393  *    Function : fillCellGrpCfg
6394  *
6395  *    Functionality: Fills CellGroupConfig
6396  *
6397  * @params[in] pointer to CellGroupConfigRrc_t
6398  *
6399  * @return ROK     - success
6400  *         RFAILED - failure
6401  *
6402  ******************************************************************/
6403
6404 uint8_t fillCellGrpCfg(CuUeCb *ueCb, OCTET_STRING_t *cellGrp, bool updateAllRbCfg)
6405 {
6406    uint8_t               ret = RFAILED;
6407    CellGroupConfigRrc_t  cellGrpCfg;
6408    asn_enc_rval_t        encRetVal;
6409
6410    while(true)
6411    {
6412       cellGrpCfg.cellGroupId = CELL_GRP_ID;
6413
6414       cellGrpCfg.rlc_BearerToAddModList = NULLP;
6415       CU_ALLOC(cellGrpCfg.rlc_BearerToAddModList, sizeof(struct CellGroupConfigRrc__rlc_BearerToAddModList));
6416       if(!cellGrpCfg.rlc_BearerToAddModList)
6417       {
6418          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in CellGrpConfig");
6419          break;
6420       }
6421       if(BuildRlcBearerToAddModList(ueCb, cellGrpCfg.rlc_BearerToAddModList, updateAllRbCfg) != ROK)
6422       {
6423          DU_LOG("\nERROR  -->  F1AP : fillCellGrpCfg failed");
6424          break;
6425       }
6426
6427       cellGrpCfg.rlc_BearerToReleaseList = NULLP;
6428       cellGrpCfg.mac_CellGroupConfig = NULLP;
6429       CU_ALLOC(cellGrpCfg.mac_CellGroupConfig, sizeof(MAC_CellGroupConfig_t));
6430       if(!cellGrpCfg.mac_CellGroupConfig)
6431       {
6432          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in fillCellGrpCfg");
6433          break;
6434       }
6435       if(BuildMacCellGrpCfg(cellGrpCfg.mac_CellGroupConfig) != ROK)
6436       {
6437          DU_LOG("\nERROR  -->  F1AP : BuildMacCellGrpCfg failed");
6438          break;
6439       }
6440
6441       cellGrpCfg.physicalCellGroupConfig = NULLP;
6442       CU_ALLOC(cellGrpCfg.physicalCellGroupConfig, sizeof(PhysicalCellGroupConfig_t));
6443       if(!cellGrpCfg.physicalCellGroupConfig)
6444       {
6445          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildDuToCuRrcContainer");
6446          break;
6447       }
6448       if(BuildPhyCellGrpCfg(cellGrpCfg.physicalCellGroupConfig) != ROK)
6449       {
6450          DU_LOG("\nERROR  -->  F1AP : BuildPhyCellGrpCfg failed");
6451          break;
6452       }
6453
6454       cellGrpCfg.spCellConfig = NULLP;
6455       CU_ALLOC(cellGrpCfg.spCellConfig, sizeof(SpCellConfig_t));
6456       if(!cellGrpCfg.spCellConfig)
6457       {
6458          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildDuToCuRrcContainer");
6459          break;
6460       }
6461       if(BuildSpCellCfg(cellGrpCfg.spCellConfig) != ROK)
6462       {
6463          DU_LOG("\nERROR  -->  F1AP : BuildSpCellCfg failed");
6464          break;
6465       }
6466
6467       cellGrpCfg.sCellToAddModList = NULLP;
6468       cellGrpCfg.sCellToReleaseList = NULLP;
6469       cellGrpCfg.ext1 = NULLP;
6470
6471       /* encode cellGrpCfg into duToCuRrcContainer */
6472       xer_fprint(stdout, &asn_DEF_CellGroupConfigRrc, &cellGrpCfg);
6473       cmMemset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
6474       encBufSize = 0;
6475       encRetVal = aper_encode(&asn_DEF_CellGroupConfigRrc, 0, &cellGrpCfg, PrepFinalEncBuf, encBuf);
6476       /* Encode results */
6477       if(encRetVal.encoded == ENCODE_FAIL)
6478       {
6479          DU_LOG( "\nERROR  -->  F1AP : Could not encode DuToCuRrcContainer (at %s)\n",\
6480                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
6481          break;
6482       }
6483       else
6484       {
6485          DU_LOG("\nDEBUG  -->  F1AP : Created APER encodedbuffer for DuToCuRrcContainer\n");
6486          for(int i=0; i< encBufSize; i++)
6487          {
6488             DU_LOG("%x",encBuf[i]);
6489          }
6490       }
6491
6492       cellGrp->size = encBufSize;
6493       CU_ALLOC(cellGrp->buf, cellGrp->size);
6494       if(!cellGrp->buf)
6495       {
6496          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDuToCuRrcContainer");
6497          break;
6498       }
6499       memcpy(cellGrp->buf, encBuf, cellGrp->size);
6500       ret = ROK;
6501       break;
6502    }
6503    FreeMemCellGrpCfg(&cellGrpCfg);
6504    return ret;
6505 }
6506
6507 /*******************************************************************
6508  *
6509  * @brief Free UE Capability RAT container
6510  *
6511  * @details
6512  *
6513  *    Function : freeUeCapRatCont
6514  *
6515  *    Functionality:
6516  *       Free UE Capability RAT conatiner
6517  *
6518  * @params[in]
6519  * @return ROK     - success
6520  *         RFAILED - failure
6521  *
6522  * ****************************************************************/
6523 void freeUeCapRatCont(UE_NR_Capability_t *ueNrCap)
6524 {
6525    uint8_t idx;
6526    FeatureSets_t *featureSets;
6527
6528    if(ueNrCap->rf_Parameters.supportedBandListNR.list.array)
6529    {
6530       for(idx = 0; idx < ueNrCap->rf_Parameters.supportedBandListNR.list.count; idx++)
6531       {
6532          if(ueNrCap->rf_Parameters.supportedBandListNR.list.array[idx])
6533             CU_FREE(ueNrCap->rf_Parameters.supportedBandListNR.list.array[idx], sizeof(struct BandNR));
6534       }
6535       CU_FREE(ueNrCap->rf_Parameters.supportedBandListNR.list.array, ueNrCap->rf_Parameters.supportedBandListNR.list.size);
6536    }
6537
6538    if(ueNrCap->featureSets)
6539    {
6540       featureSets = ueNrCap->featureSets;
6541       if(featureSets->featureSetsDownlinkPerCC)
6542       {
6543          if(featureSets->featureSetsDownlinkPerCC->list.array)
6544          {
6545             for(idx = 0; idx < featureSets->featureSetsDownlinkPerCC->list.count; idx++)
6546             {
6547                   if(featureSets->featureSetsDownlinkPerCC->list.array[idx]->supportedModulationOrderDL)
6548                      CU_FREE(featureSets->featureSetsDownlinkPerCC->list.array[idx]->supportedModulationOrderDL, \
6549                         sizeof(ModulationOrder_t));
6550                   CU_FREE(featureSets->featureSetsDownlinkPerCC->list.array[idx], sizeof(struct FeatureSetDownlinkPerCC));
6551             }
6552             CU_FREE(featureSets->featureSetsDownlinkPerCC->list.array, featureSets->featureSetsDownlinkPerCC->list.size);
6553          }
6554          CU_FREE(featureSets->featureSetsDownlinkPerCC, sizeof(struct FeatureSets__featureSetsDownlinkPerCC));
6555       }
6556
6557       if(featureSets->featureSetsUplinkPerCC)
6558       {
6559          if(featureSets->featureSetsUplinkPerCC->list.array)
6560          {
6561             for(idx = 0; idx < featureSets->featureSetsUplinkPerCC->list.count; idx++)
6562             {
6563                if(featureSets->featureSetsUplinkPerCC->list.array[idx])
6564                {
6565                   if(featureSets->featureSetsUplinkPerCC->list.array[idx]->supportedModulationOrderUL)
6566                      CU_FREE(featureSets->featureSetsUplinkPerCC->list.array[idx]->supportedModulationOrderUL,\
6567                          sizeof(ModulationOrder_t));
6568                   CU_FREE(featureSets->featureSetsUplinkPerCC->list.array[idx], sizeof(struct FeatureSetUplinkPerCC));
6569                }
6570             }
6571             CU_FREE(featureSets->featureSetsUplinkPerCC->list.array,  featureSets->featureSetsUplinkPerCC->list.size);
6572          }
6573          CU_FREE(featureSets->featureSetsUplinkPerCC, sizeof(struct FeatureSets__featureSetsUplinkPerCC));
6574       }
6575       CU_FREE(ueNrCap->featureSets, sizeof(struct FeatureSets));
6576    }
6577 }
6578
6579 /*******************************************************************
6580  *
6581  * @brief Free UE capability RAT container list
6582  *
6583  * @details
6584  *
6585  *    Function : freeUeCapRatContList
6586  *
6587  *    Functionality: Free UE capability RAT container list
6588  *
6589  * @params[in]
6590  * @return ROK     - success
6591  *         RFAILED - failure
6592  *
6593  * ****************************************************************/
6594 void freeUeCapRatContList(UE_CapabilityRAT_ContainerListRRC_t *ueCapablityList)
6595 {
6596    uint8_t idx;
6597    if(ueCapablityList->list.array)
6598    {
6599       for(idx = 0; idx < ueCapablityList->list.count; idx++)
6600       {
6601          if(ueCapablityList->list.array[idx])
6602             CU_FREE(ueCapablityList->list.array[idx], sizeof(UE_CapabilityRAT_Container_t));
6603       }
6604       CU_FREE(ueCapablityList->list.array, ueCapablityList->list.size);
6605    }
6606 }
6607
6608 /*******************************************************************
6609  *
6610  * @brief Free Handover preparation information
6611  *
6612  * @details
6613  *
6614  *    Function : freeHOPreparationInfo
6615  *
6616  *    Functionality: Free Handover preparation information
6617  *
6618  * @params[in]
6619  * @return ROK     - success
6620  *         RFAILED - failure
6621  *
6622  * ****************************************************************/
6623 void freeHOPreparationInfo(HandoverPreparationInformationRrc_t *hoPrep)
6624 {
6625    HandoverPreparationInformationRrc_IEs_t *hoPrepInfoIe;
6626
6627    if(hoPrep->criticalExtensions.choice.c1)
6628    {
6629       if(hoPrep->criticalExtensions.choice.c1->choice.handoverPreparationInformation)
6630       {
6631          hoPrepInfoIe = hoPrep->criticalExtensions.choice.c1->choice.handoverPreparationInformation;
6632          freeUeCapRatContList(&hoPrepInfoIe->ue_CapabilityRAT_List);
6633          CU_FREE(hoPrep->criticalExtensions.choice.c1->choice.handoverPreparationInformation , \
6634                sizeof(HandoverPreparationInformationRrc_IEs_t));
6635       }
6636       CU_FREE(hoPrep->criticalExtensions.choice.c1, sizeof(struct HandoverPreparationInformationRrc__criticalExtensions__c1));
6637    }
6638 }
6639
6640 /*******************************************************************
6641  *
6642  * @brief Fill feature sets
6643  *
6644  * @details
6645  *
6646  *    Function : fillFeatureSets
6647  *
6648  *    Functionality: Fill feature sets
6649  *
6650  * @params[in]
6651  * @return ROK     - success
6652  *         RFAILED - failure
6653  *
6654  * ****************************************************************/
6655 uint8_t fillFeatureSets(FeatureSets_t *featureSets)
6656 {
6657    uint8_t idx, elementCnt;
6658
6659    featureSets->featureSetsDownlink = NULLP;
6660    CU_ALLOC(featureSets->featureSetsDownlinkPerCC, sizeof(struct FeatureSets__featureSetsDownlinkPerCC));
6661    if(!featureSets->featureSetsDownlinkPerCC)
6662    {
6663       DU_LOG("\nERROR  --> F1AP : Memory allocation failed in fillFeatureSets");
6664       return RFAILED;
6665    }
6666
6667    elementCnt = 1;
6668    featureSets->featureSetsDownlinkPerCC->list.count = elementCnt;
6669    featureSets->featureSetsDownlinkPerCC->list.size = elementCnt * sizeof(struct FeatureSetDownlinkPerCC *);
6670    CU_ALLOC(featureSets->featureSetsDownlinkPerCC->list.array, featureSets->featureSetsDownlinkPerCC->list.size);
6671    if(!featureSets->featureSetsDownlinkPerCC->list.array)
6672    {
6673       DU_LOG("\nERROR  --> F1AP : Memory allocation failed in fillFeatureSets");
6674       return RFAILED;
6675    }
6676
6677    for(idx = 0; idx < elementCnt; idx++)
6678    {
6679       CU_ALLOC(featureSets->featureSetsDownlinkPerCC->list.array[idx], sizeof(struct FeatureSetDownlinkPerCC));
6680       if(!featureSets->featureSetsDownlinkPerCC->list.array[idx])
6681       {
6682          DU_LOG("\nERROR  --> F1AP : Memory allocation failed in fillFeatureSets");
6683          return RFAILED;
6684       }
6685    }
6686
6687    idx = 0;
6688    featureSets->featureSetsDownlinkPerCC->list.array[idx]->supportedSubcarrierSpacingDL = SubcarrierSpacing_kHz15;
6689    featureSets->featureSetsDownlinkPerCC->list.array[idx]->supportedBandwidthDL.present = SupportedBandwidth_PR_fr1;
6690    featureSets->featureSetsDownlinkPerCC->list.array[idx]->supportedBandwidthDL.choice.fr1 = SupportedBandwidth__fr1_mhz20;
6691    featureSets->featureSetsDownlinkPerCC->list.array[idx]->channelBW_90mhz = NULLP;
6692    featureSets->featureSetsDownlinkPerCC->list.array[idx]->maxNumberMIMO_LayersPDSCH = NULLP;
6693
6694    CU_ALLOC(featureSets->featureSetsDownlinkPerCC->list.array[idx]->supportedModulationOrderDL, sizeof(ModulationOrder_t));
6695    if(!featureSets->featureSetsDownlinkPerCC->list.array[idx]->supportedModulationOrderDL)
6696    {
6697       DU_LOG("\nERROR  --> F1AP : Memory allocation failed in fillFeatureSets");
6698       return RFAILED;
6699    }
6700    *(featureSets->featureSetsDownlinkPerCC->list.array[idx]->supportedModulationOrderDL) = ModulationOrder_qam64;
6701
6702    featureSets->featureSetsUplink = NULLP;
6703    CU_ALLOC(featureSets->featureSetsUplinkPerCC, sizeof(struct FeatureSets__featureSetsUplinkPerCC));
6704    if(!featureSets->featureSetsUplinkPerCC)
6705    {
6706       DU_LOG("\nERROR  --> F1AP : Memory allocation failed in fillFeatureSets");
6707       return RFAILED;
6708    }
6709
6710    elementCnt = 1;
6711    featureSets->featureSetsUplinkPerCC->list.count = elementCnt;
6712    featureSets->featureSetsUplinkPerCC->list.size = elementCnt * sizeof(struct FeatureSetUplinkPerCC *);
6713    CU_ALLOC(featureSets->featureSetsUplinkPerCC->list.array, featureSets->featureSetsUplinkPerCC->list.size);
6714    if(!featureSets->featureSetsUplinkPerCC->list.array)
6715    {
6716       DU_LOG("\nERROR  --> F1AP : Memory allocation failed in fillFeatureSets");
6717       return RFAILED;
6718    }
6719
6720    for(idx = 0; idx < elementCnt; idx++)
6721    {
6722       CU_ALLOC(featureSets->featureSetsUplinkPerCC->list.array[idx], sizeof(struct FeatureSetUplinkPerCC));
6723       if(!featureSets->featureSetsUplinkPerCC->list.array[idx])
6724       {
6725          DU_LOG("\nERROR  --> F1AP : Memory allocation failed in fillFeatureSets");
6726          return RFAILED;
6727       }
6728    }
6729
6730    idx = 0;
6731    featureSets->featureSetsUplinkPerCC->list.array[idx]->supportedSubcarrierSpacingUL = SubcarrierSpacing_kHz15;
6732    featureSets->featureSetsUplinkPerCC->list.array[idx]->supportedBandwidthUL.present = SupportedBandwidth_PR_fr1;
6733    featureSets->featureSetsUplinkPerCC->list.array[idx]->supportedBandwidthUL.choice.fr1 = SupportedBandwidth__fr1_mhz20;
6734    featureSets->featureSetsUplinkPerCC->list.array[idx]->channelBW_90mhz = NULLP;
6735    featureSets->featureSetsUplinkPerCC->list.array[idx]->mimo_CB_PUSCH = NULLP;
6736    featureSets->featureSetsUplinkPerCC->list.array[idx]->maxNumberMIMO_LayersNonCB_PUSCH = NULLP;
6737
6738    CU_ALLOC(featureSets->featureSetsUplinkPerCC->list.array[idx]->supportedModulationOrderUL, sizeof(ModulationOrder_t));
6739    if(!featureSets->featureSetsUplinkPerCC->list.array[idx]->supportedModulationOrderUL)
6740    {
6741       DU_LOG("\nERROR  --> F1AP : Memory allocation failed in fillFeatureSets");
6742       return RFAILED;
6743    }
6744    *(featureSets->featureSetsUplinkPerCC->list.array[idx]->supportedModulationOrderUL) = ModulationOrder_qam16;
6745
6746    return ROK;
6747 }
6748
6749 /*******************************************************************
6750  *
6751  * @brief Fill UE capability RAT container
6752  *
6753  * @details
6754  *
6755  *    Function : fillUeCapRatCont
6756  *
6757  *    Functionality: Fill UE capability RAT container
6758  *
6759  * @params[in] UE Capability RAT container buffer
6760  * @return ROK     - success
6761  *         RFAILED - failure
6762  *
6763  * ****************************************************************/
6764 uint8_t fillUeCapRatCont(OCTET_STRING_t *ueCapRatContBuf)
6765 {
6766    uint8_t             ret = ROK;
6767    uint8_t             idx, elementCnt;
6768    asn_enc_rval_t      encRetVal;
6769    UE_NR_Capability_t  ueNrCap;
6770
6771    while(true)
6772    {
6773       ueNrCap.accessStratumRelease = AccessStratumRelease_rel15;
6774
6775       /* Filling PDCP parameters */
6776       ueNrCap.pdcp_Parameters.supportedROHC_Profiles.profile0x0000 = false;
6777       ueNrCap.pdcp_Parameters.supportedROHC_Profiles.profile0x0001 = false;
6778       ueNrCap.pdcp_Parameters.supportedROHC_Profiles.profile0x0002 = false;
6779       ueNrCap.pdcp_Parameters.supportedROHC_Profiles.profile0x0003 = false;
6780       ueNrCap.pdcp_Parameters.supportedROHC_Profiles.profile0x0004 = false;
6781       ueNrCap.pdcp_Parameters.supportedROHC_Profiles.profile0x0006 = false;
6782       ueNrCap.pdcp_Parameters.supportedROHC_Profiles.profile0x0101 = false;
6783       ueNrCap.pdcp_Parameters.supportedROHC_Profiles.profile0x0102 = false;
6784       ueNrCap.pdcp_Parameters.supportedROHC_Profiles.profile0x0103 = false;
6785       ueNrCap.pdcp_Parameters.supportedROHC_Profiles.profile0x0104 = false;
6786       ueNrCap.pdcp_Parameters.maxNumberROHC_ContextSessions = PDCP_Parameters__maxNumberROHC_ContextSessions_cs2;
6787       ueNrCap.pdcp_Parameters.uplinkOnlyROHC_Profiles = NULLP;
6788       ueNrCap.pdcp_Parameters.continueROHC_Context = NULLP;
6789       ueNrCap.pdcp_Parameters.outOfOrderDelivery = NULLP;
6790       ueNrCap.pdcp_Parameters.shortSN = NULLP;
6791       ueNrCap.pdcp_Parameters.pdcp_DuplicationSRB = NULLP;
6792       ueNrCap.pdcp_Parameters.pdcp_DuplicationMCG_OrSCG_DRB = NULLP;
6793
6794       ueNrCap.rlc_Parameters = NULLP;
6795       ueNrCap.mac_Parameters = NULLP;
6796
6797       /* Filling PHY parameters */
6798       ueNrCap.phy_Parameters.phy_ParametersCommon = NULLP;
6799       ueNrCap.phy_Parameters.phy_ParametersXDD_Diff = NULLP;
6800       ueNrCap.phy_Parameters.phy_ParametersFRX_Diff = NULLP;
6801       ueNrCap.phy_Parameters.phy_ParametersFR1 = NULLP;
6802       ueNrCap.phy_Parameters.phy_ParametersFR2 = NULLP;
6803
6804       /* Filling RF parameters */
6805       elementCnt = 1;
6806       ueNrCap.rf_Parameters.supportedBandListNR.list.count = elementCnt;
6807       ueNrCap.rf_Parameters.supportedBandListNR.list.size = elementCnt * sizeof(struct BandNR *);
6808       CU_ALLOC(ueNrCap.rf_Parameters.supportedBandListNR.list.array, ueNrCap.rf_Parameters.supportedBandListNR.list.size);
6809       if(!ueNrCap.rf_Parameters.supportedBandListNR.list.array)
6810       {
6811          DU_LOG("\nERROR  --> F1AP : Memory allocation failed in fillUeCapRatCont");
6812          ret = RFAILED;
6813          break;
6814       }
6815
6816       for(idx = 0; idx < elementCnt; idx++)
6817       {
6818          CU_ALLOC(ueNrCap.rf_Parameters.supportedBandListNR.list.array[idx], sizeof(struct BandNR));
6819          if(!ueNrCap.rf_Parameters.supportedBandListNR.list.array[idx])
6820          {
6821             ret = RFAILED;
6822             break;
6823          }
6824       }
6825       if(ret == RFAILED)
6826          break;
6827
6828       idx = 0;
6829       ueNrCap.rf_Parameters.supportedBandListNR.list.array[idx]->bandNR = 1;
6830       ueNrCap.rf_Parameters.supportedBandCombinationList = NULLP;
6831       ueNrCap.rf_Parameters.appliedFreqBandListFilter = NULLP;
6832
6833       ueNrCap.measAndMobParameters = NULLP;
6834       ueNrCap.fdd_Add_UE_NR_Capabilities = NULLP;
6835       ueNrCap.tdd_Add_UE_NR_Capabilities = NULLP;
6836       ueNrCap.fr1_Add_UE_NR_Capabilities = NULLP;
6837       ueNrCap.fr2_Add_UE_NR_Capabilities = NULLP;
6838       ueNrCap.featureSets = NULLP;
6839
6840       CU_ALLOC(ueNrCap.featureSets, sizeof(struct FeatureSets));
6841       if(!ueNrCap.featureSets)
6842       {
6843          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in fillUeCapRatCont");
6844          ret = RFAILED;
6845          break;
6846       }
6847
6848       if(fillFeatureSets(ueNrCap.featureSets) != ROK)
6849       {
6850          DU_LOG("\nERROR  -->  fillDLFeatureSets() failed ");
6851          ret = RFAILED;
6852          break;
6853       }
6854
6855       ueNrCap.featureSetCombinations = NULLP;
6856       ueNrCap.lateNonCriticalExtension = NULLP;
6857       ueNrCap.nonCriticalExtension = NULLP;
6858
6859       /* encode UE Capability RAT Container List into duToCuRrcContainer */
6860       xer_fprint(stdout, &asn_DEF_UE_NR_Capability, &ueNrCap);
6861       cmMemset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
6862       encBufSize = 0;
6863       encRetVal = aper_encode(&asn_DEF_UE_NR_Capability, 0, &ueNrCap, PrepFinalEncBuf, encBuf);
6864
6865       /* Encode results */
6866       if(encRetVal.encoded == ENCODE_FAIL)
6867       {
6868          DU_LOG( "\nERROR  -->  F1AP : Could not encode UE Capability RAT Container (at %s)\n",\
6869             encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
6870          break;
6871       }
6872       else
6873       {
6874          DU_LOG("\nDEBUG  -->  F1AP : Created APER encodedbuffer for UE Capability RAT Container\n");
6875          for(int i=0; i< encBufSize; i++)
6876          {
6877             DU_LOG("%x",encBuf[i]);
6878          }
6879       }
6880
6881       ueCapRatContBuf->size = encBufSize;
6882       CU_ALLOC(ueCapRatContBuf->buf, ueCapRatContBuf->size);
6883       if(!ueCapRatContBuf->buf)
6884       {
6885          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in fillUeCapabilityContainer");
6886          break;
6887       }
6888       memcpy(ueCapRatContBuf->buf, encBuf, ueCapRatContBuf->size);
6889       ret = ROK;
6890       break;
6891    }
6892    freeUeCapRatCont(&ueNrCap);
6893    return ROK;
6894 }
6895
6896 /*******************************************************************
6897  *
6898  * @brief Fill UE Capability RAT container list
6899  *
6900  * @details
6901  *
6902  *    Function : fillUeCapRatContList
6903  *
6904  *    Functionality: Fill UE Capability RAT container list
6905
6906  *
6907  * @params[in] UE capability RAT container list
6908  * @return ROK     - success
6909  *         RFAILED - failure
6910  *
6911  * ****************************************************************/
6912 uint8_t fillUeCapRatContList(UE_CapabilityRAT_ContainerListRRC_t  *ueCapablityList)
6913 {
6914     uint8_t          ret = RFAILED;
6915     uint8_t          idx, elementCnt;
6916
6917     while(true)
6918     {
6919        elementCnt = 1;
6920        ueCapablityList->list.count = elementCnt;
6921        ueCapablityList->list.size = elementCnt * sizeof(UE_CapabilityRAT_Container_t *);
6922
6923        CU_ALLOC(ueCapablityList->list.array, ueCapablityList->list.size);
6924        if(!ueCapablityList->list.array)
6925        {
6926           DU_LOG("\nERROR  -->  Memory allocation failed in fillUeCapRatContList");
6927           ret = RFAILED;
6928           break;
6929        }
6930
6931        for(idx=0; idx<elementCnt; idx++)
6932        {
6933           CU_ALLOC(ueCapablityList->list.array[idx], sizeof(UE_CapabilityRAT_Container_t));
6934           if(ueCapablityList->list.array[idx] == NULLP)
6935           {
6936              DU_LOG("\nERROR  -->  Memory allocation failed in fillUeCapRatContList");
6937              ret = RFAILED;
6938              break;
6939           }
6940        }
6941        idx = 0;
6942        ueCapablityList->list.array[idx]->rat_Type = RAT_Type_nr;
6943        if(fillUeCapRatCont(&ueCapablityList->list.array[idx]->ue_CapabilityRAT_Container) != ROK)
6944        {
6945           DU_LOG("\nERROR  -->  F1AP : Failed to fill UE capability RAT Conatiner");
6946           ret = RFAILED;
6947           break;
6948        }
6949
6950        ret = ROK;
6951        break;
6952     }
6953     return ret;
6954 }
6955
6956 /*******************************************************************
6957  *
6958  * @brief Fill UE Capability RAT container list octet string
6959  *
6960  * @details
6961  *
6962  *    Function : fillUeCapRatContListBuf
6963  *
6964  *    Functionality: Fill UE Capability RAT container list octet string
6965
6966  *
6967  * @params[in] UE capability RAT container list buffer
6968  * @return ROK     - success
6969  *         RFAILED - failure
6970  *
6971  * ****************************************************************/
6972 uint8_t fillUeCapRatContListBuf(UE_CapabilityRAT_ContainerList_t *ueCapablityListBuf)
6973 {
6974    uint8_t          ret = RFAILED;
6975    asn_enc_rval_t   encRetVal;
6976    UE_CapabilityRAT_ContainerListRRC_t  ueCapablityList;
6977
6978    while(true)
6979    {
6980       ret = fillUeCapRatContList(&ueCapablityList);
6981       if(ret != ROK)
6982       {
6983          DU_LOG( "\nERROR  -->  F1AP : Failed to fill UE Capability RAT container list");
6984          break;
6985       }
6986
6987       /* encode UE Capability RAT Container List into duToCuRrcContainer */
6988       xer_fprint(stdout, &asn_DEF_UE_CapabilityRAT_ContainerListRRC, &ueCapablityList);
6989       cmMemset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
6990       encBufSize = 0;
6991       encRetVal = aper_encode(&asn_DEF_UE_CapabilityRAT_ContainerListRRC, 0, \
6992             &ueCapablityList, PrepFinalEncBuf, encBuf);
6993
6994       /* Encode results */
6995       if(encRetVal.encoded == ENCODE_FAIL)
6996       {
6997          DU_LOG( "\nERROR  -->  F1AP : Could not encode UE Capability RAT Container (at %s)\n",\
6998                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
6999          break;
7000       }
7001       else
7002       {
7003          DU_LOG("\nDEBUG  -->  F1AP : Created APER encodedbuffer for UE Capability RAT Container\n");
7004          for(int i=0; i< encBufSize; i++)
7005          {
7006             DU_LOG("%x",encBuf[i]);
7007          }
7008       }
7009
7010       ueCapablityListBuf->size = encBufSize;
7011       CU_ALLOC(ueCapablityListBuf->buf, ueCapablityListBuf->size);
7012       if(!ueCapablityListBuf->buf)
7013       {
7014          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in fillUeCapabilityContainer");
7015          break;
7016       }
7017       memcpy(ueCapablityListBuf->buf, encBuf, ueCapablityListBuf->size);
7018       ret = ROK;
7019       break;
7020    }
7021    freeUeCapRatContList(&ueCapablityList);
7022    return ret;
7023 }
7024
7025 /*******************************************************************
7026  *
7027  * @brief Free Measurement Timing Configuration
7028  *
7029  * @details
7030  *
7031  *    Function : freeMeasuementTimingConfig
7032  *
7033  *    Functionality: Free Measurement Timing Configuration
7034  *
7035  * @params[in] MeasurementTimingConfiguration_IEs_t measTimingCfg
7036  * @return void
7037  *
7038  * ****************************************************************/
7039 void freeMeasuementTimingConfig(MeasurementTimingConfigurationRrc_t measTimingConfig)
7040 {
7041    uint8_t measCfgIdx;
7042    MeasurementTimingConfigurationRrc_IEs_t *measTimingCfg = NULLP;
7043    MeasTiming_t *measTiming = NULLP;
7044
7045    if(measTimingConfig.criticalExtensions.choice.c1)
7046    {
7047       if(measTimingConfig.criticalExtensions.choice.c1->choice.measTimingConf)
7048       {
7049          measTimingCfg = measTimingConfig.criticalExtensions.choice.c1->choice.measTimingConf;
7050          if(measTimingCfg->measTiming)
7051          {
7052             if(measTimingCfg->measTiming->list.array)
7053             {
7054                for(measCfgIdx = 0; measCfgIdx < measTimingCfg->measTiming->list.count; measCfgIdx++)
7055                {
7056                   measTiming = measTimingCfg->measTiming->list.array[measCfgIdx];
7057                   CU_FREE(measTiming->frequencyAndTiming, sizeof(struct MeasTiming__frequencyAndTiming));
7058                   CU_FREE(measTimingCfg->measTiming->list.array[measCfgIdx], sizeof(MeasTiming_t));
7059                }
7060                CU_FREE(measTimingCfg->measTiming->list.array, measTimingCfg->measTiming->list.size);
7061             }
7062             CU_FREE(measTimingCfg->measTiming, sizeof(MeasTimingList_t));
7063          }
7064          CU_FREE(measTimingConfig.criticalExtensions.choice.c1->choice.measTimingConf, sizeof(struct MeasurementTimingConfigurationRrc_IEs));
7065       }
7066       CU_FREE(measTimingConfig.criticalExtensions.choice.c1, sizeof(struct MeasurementTimingConfigurationRrc__criticalExtensions__c1));
7067    }
7068 }
7069
7070 /*******************************************************************
7071  *
7072  * @brief Fill Measurement Timing Configuration
7073  *
7074  * @details
7075  *
7076  *    Function : fillMeasTimingCfg
7077  *
7078  *    Functionality: Fill Measurement Timing Configuration
7079  *
7080  * @params[in] MeasurementTimingConfiguration_IEs_t measTimingCfg
7081  * @return ROK     - success
7082  *         RFAILED - failure
7083  *
7084  * ****************************************************************/
7085 uint8_t fillMeasTimingCfg(MeasurementTimingConfigurationRrc_IEs_t *measTimingCfg)
7086 {
7087    uint8_t elementCnt = 0;
7088    uint8_t measCfgIdx = 0;
7089    MeasTiming_t *measTiming;
7090    SSB_MTC_t *smtc;
7091
7092    CU_ALLOC(measTimingCfg->measTiming, sizeof(MeasTimingList_t));
7093    if(!measTimingCfg->measTiming)
7094    {
7095       DU_LOG( "\nERROR  -->  F1AP : Failed to allocated memory  for measTiming in fillMeasTimingCfg");
7096       return RFAILED;
7097    }
7098
7099    elementCnt = 1;
7100    measTimingCfg->measTiming->list.count = elementCnt;
7101    measTimingCfg->measTiming->list.size = measTimingCfg->measTiming->list.count * sizeof(MeasTiming_t *);
7102    CU_ALLOC(measTimingCfg->measTiming->list.array, measTimingCfg->measTiming->list.size);
7103    if(!measTimingCfg->measTiming->list.array)
7104    {
7105       DU_LOG( "\nERROR  -->  F1AP : Failed to allocated memory for measTiming array in fillMeasTimingCfg");
7106       return RFAILED;
7107    }
7108
7109    for(measCfgIdx = 0; measCfgIdx < measTimingCfg->measTiming->list.count; measCfgIdx++)
7110    {
7111       CU_ALLOC(measTimingCfg->measTiming->list.array[measCfgIdx], sizeof(MeasTiming_t));
7112       if(!measTimingCfg->measTiming->list.array[measCfgIdx])
7113       {
7114          DU_LOG( "\nERROR  -->  F1AP : Failed to allocated memory for measTiming array element in fillMeasTimingCfg");
7115          return RFAILED;
7116       }
7117    }
7118
7119    measCfgIdx = 0;
7120    measTiming = measTimingCfg->measTiming->list.array[measCfgIdx];
7121    CU_ALLOC(measTiming->frequencyAndTiming, sizeof(struct MeasTiming__frequencyAndTiming));
7122    if(!measTiming->frequencyAndTiming)
7123    {
7124       DU_LOG( "\nERROR  -->  F1AP : Failed to allocated memory for frequency and timing IE in fillMeasTimingCfg");
7125       return RFAILED;
7126    }
7127
7128    measTiming->frequencyAndTiming->carrierFreq =  623800; /* This is a randomly chosen value since ARFCN configured in DU is 623400 */
7129    measTiming->frequencyAndTiming->ssbSubcarrierSpacing = SubcarrierSpacing_kHz15;
7130
7131    smtc = &measTiming->frequencyAndTiming->ssb_MeasurementTimingConfiguration;
7132    smtc->periodicityAndOffset.present = SSB_MTC__periodicityAndOffset_PR_sf20;
7133    smtc->periodicityAndOffset.choice.sf20 = 0;
7134    smtc->duration = SSB_MTC__duration_sf1;
7135    return ROK;
7136 }
7137
7138 /*******************************************************************
7139  *
7140  * @brief Fill Measurement Timing Configuration Octet string
7141  *
7142  * @details
7143  *
7144  *    Function : fillMeasConfigBuf
7145  *
7146  *    Functionality: Fill Measurement Timing Configuration Octet string
7147
7148  *
7149  * @params[in] MeasConfig_t *measConfgBuf
7150  * @return ROK     - success
7151  *         RFAILED - failure
7152  *
7153  * ****************************************************************/
7154 uint8_t fillMeasTimingConfigBuf(MeasConfig_t *measTimingConfigBuf)
7155 {
7156    uint8_t          ret = RFAILED;
7157    asn_enc_rval_t   encRetVal;
7158    MeasurementTimingConfigurationRrc_t measTimingConfig;
7159
7160    while(true)
7161    {
7162       measTimingConfig.criticalExtensions.present = MeasurementTimingConfigurationRrc__criticalExtensions_PR_c1;
7163       CU_ALLOC(measTimingConfig.criticalExtensions.choice.c1, sizeof(struct MeasurementTimingConfigurationRrc__criticalExtensions__c1));
7164       if(!measTimingConfig.criticalExtensions.choice.c1)
7165       {
7166          DU_LOG( "\nERROR  -->  F1AP : Failed to allocated memory for measurement configuration extension");
7167          return RFAILED;
7168       }
7169       measTimingConfig.criticalExtensions.choice.c1->present = MeasurementTimingConfigurationRrc__criticalExtensions__c1_PR_measTimingConf;
7170
7171       CU_ALLOC(measTimingConfig.criticalExtensions.choice.c1->choice.measTimingConf, sizeof(struct MeasurementTimingConfigurationRrc_IEs));
7172       if(!measTimingConfig.criticalExtensions.choice.c1->choice.measTimingConf)
7173       {
7174          DU_LOG( "\nERROR  -->  F1AP : Failed to allocated memory for measurement timing configuration IE");
7175          return RFAILED;
7176       }
7177
7178       ret = fillMeasTimingCfg(measTimingConfig.criticalExtensions.choice.c1->choice.measTimingConf);
7179       if(ret != ROK)
7180       {
7181          DU_LOG( "\nERROR  -->  F1AP : Failed to fill measurement timing configuration IE");
7182          break;
7183       }
7184
7185       /* Encode measurement timing configuration into octet string */
7186       xer_fprint(stdout, &asn_DEF_MeasurementTimingConfigurationRrc, &measTimingConfig);
7187       cmMemset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
7188       encBufSize = 0;
7189       encRetVal = aper_encode(&asn_DEF_MeasurementTimingConfigurationRrc, 0, &measTimingConfig, PrepFinalEncBuf, encBuf);
7190
7191       /* Encode results */
7192       if(encRetVal.encoded == ENCODE_FAIL)
7193       {
7194          DU_LOG( "\nERROR  -->  F1AP : Could not encode Measurement Timing Configuration (at %s)\n",\
7195                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
7196          break;
7197       }
7198       else
7199       {
7200          DU_LOG("\nDEBUG  -->  F1AP : Created APER encodedbuffer for Measurement timing configuration\n");
7201          for(int i=0; i< encBufSize; i++)
7202          {
7203             DU_LOG("%x",encBuf[i]);
7204          }
7205       }
7206
7207       measTimingConfigBuf->size = encBufSize;
7208       CU_ALLOC(measTimingConfigBuf->buf, measTimingConfigBuf->size);
7209       if(!measTimingConfigBuf->buf)
7210       {
7211          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed fillMeasTimingConfigBuf");
7212          break;
7213       }
7214       memcpy(measTimingConfigBuf->buf, encBuf, measTimingConfigBuf->size);
7215       ret = ROK;
7216       break;
7217    }
7218    freeMeasuementTimingConfig(measTimingConfig);
7219    return ret;
7220 }
7221
7222 /******************************************************************
7223  *
7224  * @brief Free RRC reconfiguration non-critical extension
7225  *
7226  * @details
7227  *
7228  *    Function : freeRrcReconfigNonCriticalExt
7229  *
7230  *    Functionality: Free RRC reconfiguration non-critical extension
7231  *
7232  * @params[in] RRC reconfiguration IE
7233  * @return void
7234  *
7235  * ****************************************************************/
7236 void freeRrcReconfigNonCriticalExt(RRCReconfiguration_v1530_IEs_t *rrcRecfg)
7237 {
7238    if(rrcRecfg->masterCellGroup)
7239    {
7240       CU_FREE(rrcRecfg->masterCellGroup, sizeof(OCTET_STRING_t));
7241    }
7242 }
7243
7244 /******************************************************************
7245  *
7246  * @brief Free measurement object addmod list
7247  *
7248  * @details
7249  *
7250  *    Function : freeMeasObjToAddModList
7251  *
7252  *    Functionality: Free measurement object add mod list
7253  *
7254  * @params[in] Measurement object add/mod list
7255  * @return void
7256  *
7257  * ****************************************************************/
7258 void freeMeasObjToAddModList(MeasObjectToAddModList_t *measObjList)
7259 {
7260    uint8_t objIdx;
7261    MeasObjectNR_t *measObject;
7262
7263    if(measObjList->list.array)
7264    {
7265       for(objIdx = 0; objIdx < measObjList->list.size; objIdx++)
7266       {
7267          if(measObjList->list.array[objIdx])
7268          {
7269             if(measObjList->list.array[objIdx]->measObject.choice.measObjectNR)
7270             {
7271                measObject = measObjList->list.array[objIdx]->measObject.choice.measObjectNR;
7272                CU_FREE(measObject->ssbFrequency, sizeof(ARFCN_ValueNR_t));
7273                CU_FREE(measObject->ssbSubcarrierSpacing, sizeof(SubcarrierSpacing_t));
7274                CU_FREE(measObject->smtc1 , sizeof(SSB_MTC_t));
7275                if(measObject->absThreshSS_BlocksConsolidation)
7276                {
7277                   CU_FREE(measObject->absThreshSS_BlocksConsolidation->thresholdRSRP, sizeof(RSRP_Range_t));
7278                   CU_FREE(measObject->absThreshSS_BlocksConsolidation->thresholdRSRQ, sizeof(RSRQ_Range_t));
7279                   CU_FREE(measObject->absThreshSS_BlocksConsolidation->thresholdSINR, sizeof(SINR_Range_t));
7280                   CU_FREE(measObject->absThreshSS_BlocksConsolidation, sizeof(ThresholdNR_t));
7281                }
7282                CU_FREE(measObject->nrofSS_BlocksToAverage, sizeof(long));
7283                CU_FREE(measObject->offsetMO.rsrpOffsetSSB, sizeof(Q_OffsetRange_t));
7284                CU_FREE(measObject->offsetMO.rsrqOffsetSSB, sizeof(Q_OffsetRange_t));
7285                CU_FREE(measObject->offsetMO.sinrOffsetSSB, sizeof(Q_OffsetRange_t));
7286                CU_FREE(measObjList->list.array[objIdx]->measObject.choice.measObjectNR, sizeof(MeasObjectNR_t));
7287             }
7288             CU_FREE(measObjList->list.array[objIdx], sizeof(MeasObjectToAddMod_t));
7289          }
7290       }
7291       CU_FREE(measObjList->list.array, measObjList->list.size);
7292    }
7293 }
7294
7295 /******************************************************************
7296  *
7297  * @brief Free report config add mod list
7298  *
7299  * @details
7300  *
7301  *    Function : freeReportCfgToAddModList
7302  *
7303  *    Functionality: Free report config add mod list
7304  *
7305  * @params[in] Report config list
7306  * @return void
7307  *
7308  * ****************************************************************/
7309 void freeReportCfgToAddModList(ReportConfigToAddModList_t *reportCfgList)
7310 {
7311    uint8_t reportCfgIdx;
7312    ReportConfigToAddMod_t *reportCfg;
7313    ReportConfigNR_t *reportCfgNr;
7314    EventTriggerConfig_t *eventTriggCfg;
7315
7316    if(reportCfgList->list.array)
7317    {
7318       for(reportCfgIdx=0; reportCfgIdx < reportCfgList->list.count; reportCfgIdx++)
7319       {
7320          if(reportCfgList->list.array[reportCfgIdx])
7321          {
7322             reportCfg = reportCfgList->list.array[reportCfgIdx];
7323             if(reportCfg->reportConfig.choice.reportConfigNR)
7324             {
7325                reportCfgNr = reportCfg->reportConfig.choice.reportConfigNR;
7326                if(reportCfgNr->reportType.choice.eventTriggered)
7327                {
7328                   eventTriggCfg = reportCfgNr->reportType.choice.eventTriggered;
7329                   CU_FREE(eventTriggCfg->eventId.choice.eventA3, sizeof(struct EventTriggerConfig__eventId__eventA3));
7330                   CU_FREE(eventTriggCfg->reportQuantityRS_Indexes, sizeof(MeasReportQuantity_t));
7331                   CU_FREE(eventTriggCfg->maxNrofRS_IndexesToReport, sizeof(long));
7332                   CU_FREE(reportCfgNr->reportType.choice.eventTriggered, sizeof(EventTriggerConfig_t));
7333                }
7334             }
7335          }
7336          CU_FREE(reportCfgList->list.array[reportCfgIdx], sizeof(ReportConfigToAddMod_t));
7337       }
7338       CU_FREE(reportCfgList->list.array, reportCfgList->list.size);
7339    }
7340 }
7341
7342 /******************************************************************
7343  *
7344  * @brief Free measurement id to add mod list
7345  *
7346  * @details
7347  *
7348  *    Function : freeMeasIdToAddModList
7349  *
7350  *    Functionality: Free measurement id to add mod list
7351  *
7352  * @params[in] Measurement id to add mod list
7353  * @return void
7354  *
7355  * ****************************************************************/
7356 void freeMeasIdToAddModList(MeasIdToAddModList_t *measIdList)
7357 {
7358    uint8_t measIdIdx;
7359    if(measIdList->list.array)
7360    {
7361       for(measIdIdx=0; measIdIdx < measIdList->list.count; measIdIdx++)
7362       {
7363          CU_FREE(measIdList->list.array[measIdIdx], sizeof(MeasIdToAddMod_t));
7364       }
7365       CU_FREE(measIdList->list.array, measIdList->list.size);
7366    }
7367 }
7368
7369 /*******************************************************************
7370  *
7371  * @brief Free quantity config
7372  *
7373  * @details
7374  *
7375  *    Function : freeQunatityConfig
7376  *
7377  *    Functionality: Free quantity config
7378  *
7379  * @params[in] Quantity Config
7380  * @return void
7381  *
7382  * ****************************************************************/
7383 uint8_t freeQuantityConfig(QuantityConfig_t *quantityCfg)
7384 {
7385    uint8_t quanCfgIdx;
7386    QuantityConfigNR_t *quantityCfgNr;
7387
7388    if(quantityCfg->quantityConfigNR_List)
7389    {
7390       if(quantityCfg->quantityConfigNR_List->list.array)
7391       {
7392          for(quanCfgIdx = 0; quanCfgIdx < quantityCfg->quantityConfigNR_List->list.count; quanCfgIdx++)
7393          {
7394             if(quantityCfg->quantityConfigNR_List->list.array[quanCfgIdx])
7395             {
7396                quantityCfgNr = quantityCfg->quantityConfigNR_List->list.array[quanCfgIdx];
7397                CU_FREE(quantityCfgNr->quantityConfigCell.ssb_FilterConfig.filterCoefficientRSRP, sizeof(FilterCoefficient_t));
7398                CU_FREE(quantityCfgNr->quantityConfigCell.ssb_FilterConfig.filterCoefficientRSRQ, sizeof(FilterCoefficient_t));
7399                CU_FREE(quantityCfgNr->quantityConfigCell.ssb_FilterConfig.filterCoefficientRS_SINR, sizeof(FilterCoefficient_t));
7400                if(quantityCfgNr->quantityConfigRS_Index)
7401                {
7402                   CU_FREE(quantityCfgNr->quantityConfigRS_Index->ssb_FilterConfig.filterCoefficientRSRP, sizeof(FilterCoefficient_t));
7403                   CU_FREE(quantityCfgNr->quantityConfigRS_Index->ssb_FilterConfig.filterCoefficientRSRQ, sizeof(FilterCoefficient_t));
7404                   CU_FREE(quantityCfgNr->quantityConfigRS_Index->ssb_FilterConfig.filterCoefficientRS_SINR, sizeof(FilterCoefficient_t));
7405                   CU_FREE(quantityCfgNr->quantityConfigRS_Index, sizeof(QuantityConfigRS_t));
7406                }
7407                CU_FREE(quantityCfg->quantityConfigNR_List->list.array[quanCfgIdx], sizeof(QuantityConfigNR_t));
7408             }
7409          }
7410          CU_FREE(quantityCfg->quantityConfigNR_List->list.array, quantityCfg->quantityConfigNR_List->list.size);
7411       }
7412       CU_FREE(quantityCfg->quantityConfigNR_List, sizeof(struct QuantityConfig__quantityConfigNR_List));
7413    }
7414 }
7415
7416 /******************************************************************
7417  *
7418  * @brief Free measurement Config
7419  *
7420  * @details
7421  *
7422  *    Function : freeMeasConfig
7423  *
7424  *    Functionality: Free measurement config
7425  *
7426  * @params[in] Measurement config
7427  * @return void
7428  *
7429  * ****************************************************************/
7430 void freeMeasConfig(MeasConfigRrc_t *measConfig)
7431 {
7432    if(measConfig->measObjectToAddModList)
7433    {
7434       freeMeasObjToAddModList(measConfig->measObjectToAddModList);
7435       CU_FREE(measConfig->measObjectToAddModList, sizeof(MeasObjectToAddModList_t));
7436    }
7437    if(measConfig->reportConfigToAddModList)
7438    {
7439       freeReportCfgToAddModList(measConfig->reportConfigToAddModList);
7440       CU_FREE(measConfig->reportConfigToAddModList, sizeof(ReportConfigToAddModList_t));
7441    }
7442    if(measConfig->measIdToAddModList)
7443    {
7444       freeMeasIdToAddModList(measConfig->measIdToAddModList);
7445       CU_FREE(measConfig->measIdToAddModList, sizeof(MeasIdToAddModList_t));
7446    }
7447    if(measConfig->s_MeasureConfig)
7448    {
7449       CU_FREE(measConfig->s_MeasureConfig, sizeof(struct MeasConfigRrc__s_MeasureConfig));
7450    }
7451    if(measConfig->quantityConfig)
7452    {
7453       freeQuantityConfig(measConfig->quantityConfig);
7454       CU_FREE(measConfig->quantityConfig, sizeof(QuantityConfig_t));
7455    }
7456 }
7457 /******************************************************************
7458  *
7459  * @brief Free DRB to AddMod List
7460  *
7461  * @details
7462  *
7463  *    Function : freeDrbToAddModList
7464  *
7465  *    Functionality: Free SRB to AddMod List
7466  *
7467  * @params[in] SBR to add/mod list
7468  * @return void
7469  *
7470  * ****************************************************************/
7471 void freeDrbToAddModList(DRB_ToAddModList_t *drbToAddList)
7472 {
7473    uint8_t drbIdx;
7474    if(drbToAddList->list.array)
7475    {
7476       for(drbIdx = 0; drbIdx < drbToAddList->list.count; drbIdx++)
7477       {
7478          if(drbToAddList->list.array[drbIdx]->pdcp_Config)
7479          {
7480             if(drbToAddList->list.array[drbIdx]->pdcp_Config->drb)
7481             {
7482                CU_FREE(drbToAddList->list.array[drbIdx]->pdcp_Config->drb->discardTimer, sizeof(long));
7483                CU_FREE(drbToAddList->list.array[drbIdx]->pdcp_Config->drb->pdcp_SN_SizeUL, sizeof(long));
7484                CU_FREE(drbToAddList->list.array[drbIdx]->pdcp_Config->drb->pdcp_SN_SizeDL, sizeof(long));
7485                CU_FREE(drbToAddList->list.array[drbIdx]->pdcp_Config->drb, sizeof(struct PDCP_Config__drb));
7486             }
7487             CU_FREE(drbToAddList->list.array[drbIdx]->pdcp_Config->t_Reordering, sizeof(long));
7488             CU_FREE(drbToAddList->list.array[drbIdx]->pdcp_Config, sizeof(PDCP_Config_t));
7489          }
7490          CU_FREE(drbToAddList->list.array[drbIdx], sizeof(DRB_ToAddMod_t));
7491       }
7492       CU_FREE(drbToAddList->list.array, drbToAddList->list.size);
7493    }
7494 }
7495
7496 /******************************************************************
7497  *
7498  * @brief Free SRB to AddMod List
7499  *
7500  * @details
7501  *
7502  *    Function : freeSrbToAddModList
7503  *
7504  *    Functionality: Free SRB to AddMod List
7505  *
7506  * @params[in] SBR to add/mod list
7507  * @return void
7508  *
7509  * ****************************************************************/
7510 void freeSrbToAddModList(SRB_ToAddModList_t *srbToAddList)
7511 {
7512    uint8_t srbIdx;
7513    if(srbToAddList->list.array)
7514    {
7515       for(srbIdx = 0; srbIdx < srbToAddList->list.count; srbIdx++)
7516       {
7517          CU_FREE(srbToAddList->list.array[srbIdx]->reestablishPDCP, sizeof(long));
7518          if(srbToAddList->list.array[srbIdx]->pdcp_Config)
7519          {
7520             CU_FREE(srbToAddList->list.array[srbIdx]->pdcp_Config->t_Reordering, sizeof(long));
7521             CU_FREE(srbToAddList->list.array[srbIdx]->pdcp_Config, sizeof(PDCP_Config_t));
7522          }
7523
7524          CU_FREE(srbToAddList->list.array[srbIdx], sizeof(SRB_ToAddMod_t));
7525       }
7526       CU_FREE(srbToAddList->list.array, srbToAddList->list.size);
7527    }
7528 }
7529
7530 /******************************************************************
7531  *
7532  * @brief Free Radio Bearer Config
7533  *
7534  * @details
7535  *
7536  *    Function : fillRadioBearerConfig
7537  *
7538  *    Functionality: Free Radio Bearer config
7539  *
7540  * @params[in] Radio bearer config
7541  * @return void
7542  *
7543  * ****************************************************************/
7544 void freeRadioBearerConfig(RadioBearerConfig_t *radioBearerConfig)
7545 {
7546    if(radioBearerConfig->srb_ToAddModList)
7547    {
7548       freeSrbToAddModList(radioBearerConfig->srb_ToAddModList);
7549       CU_FREE(radioBearerConfig->srb_ToAddModList, sizeof(SRB_ToAddModList_t));
7550    }
7551    if(radioBearerConfig->drb_ToAddModList)
7552    {
7553       freeDrbToAddModList(radioBearerConfig->drb_ToAddModList);
7554       CU_FREE(radioBearerConfig->drb_ToAddModList, sizeof(DRB_ToAddModList_t));
7555    }
7556 }
7557
7558 /******************************************************************
7559  *
7560  * @brief Free reconfiguration message
7561  *
7562  * @details
7563  *
7564  *    Function : freeRrcReconfig
7565  *
7566  *    Functionality: Free reconfiguration message
7567  *
7568  * @params[in] RRC Reconfiguration message
7569  * @return void
7570  *
7571  * ****************************************************************/
7572 void freeRrcReconfig(RRCReconfiguration_t *rrcReconfig)
7573 {
7574    if(rrcReconfig->criticalExtensions.choice.rrcReconfiguration)
7575    {
7576       if(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->radioBearerConfig)
7577       {
7578          freeRadioBearerConfig(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->radioBearerConfig);
7579          CU_FREE(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->radioBearerConfig, sizeof(RadioBearerConfig_t));
7580       }
7581       if(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->measConfig)
7582       {
7583          freeMeasConfig(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->measConfig);
7584          CU_FREE(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->measConfig, sizeof(MeasConfigRrc_t));
7585       }
7586       if(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->nonCriticalExtension)
7587       {
7588          freeRrcReconfigNonCriticalExt(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->nonCriticalExtension);
7589          CU_FREE(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->nonCriticalExtension, sizeof(struct RRCReconfiguration_v1530_IEs));
7590       }
7591       CU_FREE(rrcReconfig->criticalExtensions.choice.rrcReconfiguration, sizeof(RRCReconfiguration_IEs_t));
7592    }
7593 }
7594
7595 /******************************************************************
7596  *
7597  * @brief Fill SRB To Add Mod list
7598  *
7599  * @details
7600  *
7601  *    Function : fillSrbToAddModList
7602  *
7603  *    Functionality: fill SRB to Add Mod list
7604  *
7605  * @params[in] UE control block
7606  *             SRB to Add/Mod list
7607  * @return ROK     - success
7608  *         RFAILED - failure
7609  *
7610  * ****************************************************************/
7611 uint8_t fillSrbToAddModList(CuUeCb *ueCb, SRB_ToAddModList_t *srbToAddList, bool updateAllRbCfg)
7612 {
7613    uint8_t srbIdx, srbDbIdx;
7614
7615    if(updateAllRbCfg)
7616       srbToAddList->list.count = ueCb->numSrb;
7617    else
7618    {
7619       srbToAddList->list.count = 0;
7620       for(srbDbIdx=0; srbDbIdx < ueCb->numSrb; srbDbIdx++)
7621       {
7622          if(ueCb->srbList[srbDbIdx].cfgSentToUe == false)
7623             srbToAddList->list.count++;
7624       }
7625    }
7626    srbToAddList->list.size = srbToAddList->list.count * sizeof(SRB_ToAddMod_t *);
7627
7628    CU_ALLOC(srbToAddList->list.array, srbToAddList->list.size);
7629    if(!srbToAddList->list.array)
7630    {
7631       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for SRB to AddMod list array in fillSrbToAddModList");
7632       return RFAILED;
7633    }
7634
7635    srbIdx = 0;
7636    for(srbDbIdx = 0; srbDbIdx < ueCb->numSrb; srbDbIdx++)
7637    {
7638       if(!updateAllRbCfg && ueCb->srbList[srbDbIdx].cfgSentToUe)
7639          continue;
7640
7641       CU_ALLOC(srbToAddList->list.array[srbIdx], sizeof(SRB_ToAddMod_t));
7642       if(!srbToAddList->list.array[srbIdx])
7643       {
7644          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for SRB to AddMod list element in fillSrbToAddModList");
7645          return RFAILED;
7646       }
7647
7648       srbToAddList->list.array[srbIdx]->srb_Identity = ueCb->srbList[srbDbIdx].srbId;
7649
7650       /* Reestablish PDCP */
7651       CU_ALLOC(srbToAddList->list.array[srbIdx]->reestablishPDCP, sizeof(long));
7652       if(!srbToAddList->list.array[srbIdx]->reestablishPDCP)
7653       {
7654          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for reestablish PDCP IE in fillSrbToAddModList");
7655          return RFAILED;
7656       }
7657       *(srbToAddList->list.array[srbIdx]->reestablishPDCP) = SRB_ToAddMod__reestablishPDCP_true;
7658
7659       /* PDCP configuration */
7660       CU_ALLOC(srbToAddList->list.array[srbIdx]->pdcp_Config, sizeof(PDCP_Config_t));
7661       if(!srbToAddList->list.array[srbIdx]->pdcp_Config)
7662       {
7663          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for PDCP config IE in fillSrbToAddModList");
7664          return RFAILED;
7665       }
7666
7667       /* Reordering timer */
7668       CU_ALLOC(srbToAddList->list.array[srbIdx]->pdcp_Config->t_Reordering, sizeof(long));
7669       if(!srbToAddList->list.array[srbIdx]->pdcp_Config->t_Reordering)
7670       {
7671          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for reordering timer in fillSrbToAddModList");
7672          return RFAILED;
7673       }
7674       *(srbToAddList->list.array[srbIdx]->pdcp_Config->t_Reordering) = PDCP_Config__t_Reordering_ms40;
7675
7676       srbIdx++;
7677    }
7678    return ROK;
7679 }
7680
7681 /******************************************************************
7682  *
7683  * @biief Fill DRBeTo Add Mod list
7684  *
7685  * @details
7686  *
7687  *    Function : fillDrbToAddModList
7688  *
7689  *    Functionality: fill DRB to Add Mod list
7690  *
7691  * @params[in] UE control block
7692  *             DRB to Add/Mod list
7693  * @return ROK     - success
7694  *         RFAILED - failure
7695  *
7696  * ****************************************************************/
7697 uint8_t fillDrbToAddModList(CuUeCb *ueCb, DRB_ToAddModList_t *drbToAddList, bool updateAllRbCfg)
7698 {
7699    uint8_t drbIdx, drbDbIdx;
7700
7701    if(updateAllRbCfg)
7702       drbToAddList->list.count = ueCb->numDrb;
7703    else
7704    {
7705       drbToAddList->list.count = 0;
7706       for(drbDbIdx=0; drbDbIdx < ueCb->numDrb; drbDbIdx++)
7707       {
7708          if(ueCb->drbList[drbDbIdx].cfgSentToUe == false)
7709             drbToAddList->list.count++;
7710       }
7711    }
7712    drbToAddList->list.size = drbToAddList->list.count * sizeof(DRB_ToAddMod_t *);
7713
7714    CU_ALLOC(drbToAddList->list.array, drbToAddList->list.size);
7715    if(!drbToAddList->list.array)
7716    {
7717       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for DRB to AddMod list array in fillDrbToAddModList");
7718       return RFAILED;
7719    }
7720
7721    drbIdx = 0;
7722    for(drbDbIdx=0; drbDbIdx < ueCb->numDrb; drbDbIdx++)
7723    {
7724       if(!updateAllRbCfg && ueCb->drbList[drbDbIdx].cfgSentToUe)
7725          continue;
7726
7727       CU_ALLOC(drbToAddList->list.array[drbIdx], sizeof(DRB_ToAddMod_t));
7728       if(!drbToAddList->list.array[drbIdx])
7729       {
7730          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for DRB to AddMod list elements in fillDrbToAddModList");
7731          return RFAILED;
7732       }
7733
7734       /* DRB Id */
7735       drbToAddList->list.array[drbIdx]->drb_Identity = ueCb->drbList[drbDbIdx].drbId;
7736
7737       /* PDCP Config */
7738       CU_ALLOC(drbToAddList->list.array[drbIdx]->pdcp_Config, sizeof(PDCP_Config_t));
7739       if(!drbToAddList->list.array[drbIdx]->pdcp_Config)
7740       {
7741          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for PDCP config IE in fillDrbToAddModList");
7742          return RFAILED;
7743       }
7744
7745       /* PDCP Config -> DRB */
7746       CU_ALLOC(drbToAddList->list.array[drbIdx]->pdcp_Config->drb, sizeof(struct PDCP_Config__drb));
7747       if(!drbToAddList->list.array[drbIdx]->pdcp_Config->drb)
7748       {
7749          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for PDCP config drb in fillDrbToAddModList");
7750          return RFAILED;
7751       }
7752
7753       /* DRB -> Discard Timer */
7754       CU_ALLOC(drbToAddList->list.array[drbIdx]->pdcp_Config->drb->discardTimer, sizeof(long));
7755       if(!drbToAddList->list.array[drbIdx]->pdcp_Config->drb->discardTimer)
7756       {
7757          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for DRB discard timer in fillDrbToAddModList");
7758          return RFAILED;
7759       }
7760       *(drbToAddList->list.array[drbIdx]->pdcp_Config->drb->discardTimer) = PDCP_Config__drb__discardTimer_infinity;
7761
7762       /* UL PDCP SN length */
7763       CU_ALLOC(drbToAddList->list.array[drbIdx]->pdcp_Config->drb->pdcp_SN_SizeUL, sizeof(long));
7764       if(!drbToAddList->list.array[drbIdx]->pdcp_Config->drb->pdcp_SN_SizeUL)
7765       {
7766          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for UL SN length in fillDrbToAddModList");
7767          return RFAILED;
7768       }
7769       *(drbToAddList->list.array[drbIdx]->pdcp_Config->drb->pdcp_SN_SizeUL) = PDCP_Config__drb__pdcp_SN_SizeUL_len12bits;
7770
7771       /* DL PDCP SN length */
7772       CU_ALLOC(drbToAddList->list.array[drbIdx]->pdcp_Config->drb->pdcp_SN_SizeDL, sizeof(long));
7773       if(!drbToAddList->list.array[drbIdx]->pdcp_Config->drb->pdcp_SN_SizeDL)
7774       {
7775          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for DL SN length in fillDrbToAddModList");
7776          return RFAILED;
7777       }
7778       *(drbToAddList->list.array[drbIdx]->pdcp_Config->drb->pdcp_SN_SizeDL) = PDCP_Config__drb__pdcp_SN_SizeDL_len12bits;
7779
7780       /* Header Compression */
7781       drbToAddList->list.array[drbIdx]->pdcp_Config->drb->headerCompression.present = PDCP_Config__drb__headerCompression_PR_notUsed;
7782        drbToAddList->list.array[drbIdx]->pdcp_Config->drb->headerCompression.choice.notUsed = NULLP;
7783
7784       /* Reordering timer */
7785       CU_ALLOC(drbToAddList->list.array[drbIdx]->pdcp_Config->t_Reordering, sizeof(long));
7786       if(!drbToAddList->list.array[drbIdx]->pdcp_Config->t_Reordering)
7787       {
7788          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for reordering timer in fillDrbToAddModList");
7789          return RFAILED;
7790       }
7791       *(drbToAddList->list.array[drbIdx]->pdcp_Config->t_Reordering) = PDCP_Config__t_Reordering_ms40;
7792
7793       drbIdx++;
7794    }
7795
7796    return ROK;
7797 }
7798
7799 /******************************************************************
7800  *
7801  * @brief Fill Radio bearer configuration
7802  *
7803  * @details
7804  *
7805  *    Function : fillRadioBearerConfig
7806  *
7807  *    Functionality: Fill Radio bearer configuration
7808  *
7809  * @params[in] UE control block
7810  *             Radio bearer config pointer
7811  * @return ROK     - success
7812  *         RFAILED - failure
7813  *
7814  * ****************************************************************/
7815 uint8_t fillRadioBearerConfig(CuUeCb *ueCb, RadioBearerConfig_t *radioBearerConfig, bool updateAllRbCfg)
7816 {
7817    /* SRB To Add/Mod List */
7818    CU_ALLOC(radioBearerConfig->srb_ToAddModList, sizeof(SRB_ToAddModList_t));
7819    if(!radioBearerConfig->srb_ToAddModList)
7820    {
7821       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for SRB to AddMod List in fillRadioBearerConfig");
7822       return RFAILED;
7823    }
7824    if(fillSrbToAddModList(ueCb, radioBearerConfig->srb_ToAddModList, updateAllRbCfg) != ROK)
7825    {
7826       return RFAILED;
7827    }
7828
7829    /* DRB To Add/Mod List */
7830    CU_ALLOC(radioBearerConfig->drb_ToAddModList, sizeof(DRB_ToAddModList_t));
7831    if(!radioBearerConfig->drb_ToAddModList)
7832    {
7833       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for DRB to AddMod List in fillRadioBearerConfig");
7834       return RFAILED;
7835    }
7836    if(fillDrbToAddModList(ueCb, radioBearerConfig->drb_ToAddModList, updateAllRbCfg) != ROK)
7837    {
7838       return RFAILED;
7839    }
7840
7841    return ROK;
7842 }
7843
7844 /*******************************************************************
7845  *
7846  * @brief Fill measurement object to add/mod list
7847  *
7848  * @details
7849  *
7850  *    Function : fillMeasObjToAddModList
7851  *
7852  *    Functionality: Fill measurement object to add/mod list
7853  *
7854  * @params[in] Measurement object to add/mod list
7855  * @return ROK     - success
7856  *         RFAILED - failure
7857  *
7858  * ****************************************************************/
7859 uint8_t fillMeasObjToAddModList(MeasObjectToAddModList_t *measObjList)
7860 {
7861    uint8_t elementCnt, objIdx;
7862    MeasObjectNR_t *measObject;
7863
7864    elementCnt = 1;
7865    measObjList->list.count = elementCnt;
7866    measObjList->list.size = measObjList->list.count * sizeof(MeasObjectToAddMod_t *);
7867
7868    CU_ALLOC(measObjList->list.array, measObjList->list.size);
7869    if(!measObjList->list.array)
7870    {
7871       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for measurement object list's array");
7872       return RFAILED;
7873    }
7874
7875    for(objIdx = 0; objIdx < measObjList->list.size; objIdx++)
7876    {
7877       CU_ALLOC(measObjList->list.array[objIdx], sizeof(MeasObjectToAddMod_t));
7878       if(!measObjList->list.array[objIdx])
7879       {
7880          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for measurement object list's array element");
7881          return RFAILED;
7882       }
7883    }
7884
7885    objIdx = 0;
7886    measObjList->list.array[objIdx]->measObjectId = 1;
7887    measObjList->list.array[objIdx]->measObject.present = MeasObjectToAddMod__measObject_PR_measObjectNR;
7888    CU_ALLOC(measObjList->list.array[objIdx]->measObject.choice.measObjectNR, sizeof(MeasObjectNR_t));
7889    if(!measObjList->list.array[objIdx]->measObject.choice.measObjectNR)
7890    {
7891       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for mesurement object NR");
7892       return RFAILED;
7893    }
7894
7895    measObject = measObjList->list.array[objIdx]->measObject.choice.measObjectNR;
7896
7897    /* SSB frequency */
7898    CU_ALLOC(measObject->ssbFrequency, sizeof(ARFCN_ValueNR_t));
7899    if(!measObject->ssbFrequency)
7900    {
7901       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for SSB frequency in fillMeasObjToAddModList");
7902       return RFAILED;
7903    }
7904    *(measObject->ssbFrequency) = 620736; /* Value picked from reference PCAP logs */
7905
7906    /* Subcarrier spacing */
7907    CU_ALLOC(measObject->ssbSubcarrierSpacing, sizeof(SubcarrierSpacing_t));
7908    if(!measObject->ssbSubcarrierSpacing)
7909    {
7910       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for SSB subcarrier spacing in fillMeasObjToAddModList");
7911       return RFAILED;
7912    }
7913    *(measObject->ssbSubcarrierSpacing) = SubcarrierSpacing_kHz15;
7914
7915    /* SMTC1 */
7916    CU_ALLOC(measObject->smtc1 , sizeof(SSB_MTC_t));
7917    if(!measObject->smtc1)
7918    {
7919       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for SMTC1 in fillMeasObjToAddModList");
7920       return RFAILED;
7921    }
7922    measObject->smtc1->duration = SSB_MTC__duration_sf1;
7923    measObject->smtc1->periodicityAndOffset.present = SSB_MTC__periodicityAndOffset_PR_sf20;
7924    measObject->smtc1->periodicityAndOffset.choice.sf20 = 0;
7925
7926    /* Absoulute threshold SSB consolidation */
7927    CU_ALLOC(measObject->absThreshSS_BlocksConsolidation, sizeof(ThresholdNR_t));
7928    if(!measObject->absThreshSS_BlocksConsolidation)
7929    {
7930       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for absolute threshold SSB consolidation in fillMeasObjToAddModList");
7931       return RFAILED;
7932    }
7933
7934    /* RSRP threshold */
7935    CU_ALLOC(measObject->absThreshSS_BlocksConsolidation->thresholdRSRP, sizeof(RSRP_Range_t));
7936    if(!measObject->absThreshSS_BlocksConsolidation->thresholdRSRP)
7937    {
7938       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for threshold RSRP in fillMeasObjToAddModList");
7939       return RFAILED;
7940    }
7941    *(measObject->absThreshSS_BlocksConsolidation->thresholdRSRP) = 1;
7942
7943    /* RSRQ threshold */
7944    CU_ALLOC(measObject->absThreshSS_BlocksConsolidation->thresholdRSRQ, sizeof(RSRQ_Range_t));
7945    if(!measObject->absThreshSS_BlocksConsolidation->thresholdRSRQ)
7946    {
7947       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for threshold RSRQ in fillMeasObjToAddModList");
7948       return RFAILED;
7949    }
7950    *(measObject->absThreshSS_BlocksConsolidation->thresholdRSRQ) = 1;
7951
7952    /* SINR threshold */
7953    CU_ALLOC(measObject->absThreshSS_BlocksConsolidation->thresholdSINR, sizeof(SINR_Range_t));
7954    if(!measObject->absThreshSS_BlocksConsolidation->thresholdSINR)
7955    {
7956       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for threshold SINR in fillMeasObjToAddModList");
7957       return RFAILED;
7958    }
7959    *(measObject->absThreshSS_BlocksConsolidation->thresholdSINR) = 1;
7960
7961    /* Number of SSBs to average */
7962    CU_ALLOC(measObject->nrofSS_BlocksToAverage, sizeof(long));
7963    if(!measObject->nrofSS_BlocksToAverage)
7964    {
7965       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for number of SSB to average in fillMeasObjToAddModList");
7966       return RFAILED;
7967    }
7968    *(measObject->nrofSS_BlocksToAverage) = 2;
7969
7970    /* Quantity Config index */
7971    measObject->quantityConfigIndex = 1;
7972
7973    /* Offset MO */
7974    /* RSRP offset for SSB */
7975    CU_ALLOC(measObject->offsetMO.rsrpOffsetSSB, sizeof(Q_OffsetRange_t));
7976    if(!measObject->offsetMO.rsrpOffsetSSB)
7977    {
7978       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for SSB RSRP offset in fillMeasObjToAddModList");
7979       return RFAILED;
7980    }
7981    *(measObject->offsetMO.rsrpOffsetSSB) = Q_OffsetRange_dB0;
7982
7983    /* RSRQ offset for SSB */
7984    CU_ALLOC(measObject->offsetMO.rsrqOffsetSSB, sizeof(Q_OffsetRange_t));
7985    if(!measObject->offsetMO.rsrpOffsetSSB)
7986    {
7987       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for SSB RSRQ offset in fillMeasObjToAddModList");
7988       return RFAILED;
7989    }
7990    *(measObject->offsetMO.rsrqOffsetSSB) = Q_OffsetRange_dB0;
7991
7992    /* SINR offset for SSB */
7993    CU_ALLOC(measObject->offsetMO.sinrOffsetSSB, sizeof(Q_OffsetRange_t));
7994    if(!measObject->offsetMO.sinrOffsetSSB)
7995    {
7996       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for SSB SINR offset in fillMeasObjToAddModList");
7997       return RFAILED;
7998    }
7999    *(measObject->offsetMO.sinrOffsetSSB) = Q_OffsetRange_dB0;
8000
8001    return ROK;
8002 }
8003
8004 /*******************************************************************
8005  *
8006  * @brief Fill Report configuration to Add/mod list
8007  *
8008  * @details
8009  *
8010  *    Function : fillReportCfgToAddModList
8011  *
8012  *    Functionality: Fill Report configuration to Add/mod list
8013  *
8014  * @params[in] Report Config To Add/Mod List
8015  * @return ROK     - success
8016  *         RFAILED - failure
8017  *
8018  * ****************************************************************/
8019 uint8_t fillReportCfgToAddModList(ReportConfigToAddModList_t *reportCfgList)
8020 {
8021    uint8_t elementCnt;
8022    uint8_t reportCfgIdx;
8023    ReportConfigToAddMod_t *reportCfg;
8024    ReportConfigNR_t *reportCfgNr;
8025    EventTriggerConfig_t *eventTriggCfg;
8026
8027    elementCnt = 1;
8028    reportCfgList->list.count = elementCnt;
8029    reportCfgList->list.size = reportCfgList->list.count * sizeof(ReportConfigToAddMod_t *);
8030
8031    CU_ALLOC(reportCfgList->list.array, reportCfgList->list.size);
8032    if(!reportCfgList->list.array)
8033    {
8034       DU_LOG("\nERROR  -->  F1AP: fillReportCfgToAddModList() :Memory allocation failed for report config list's array");
8035       return RFAILED;
8036    }
8037
8038    for(reportCfgIdx=0; reportCfgIdx < reportCfgList->list.count; reportCfgIdx++)
8039    {
8040       CU_ALLOC(reportCfgList->list.array[reportCfgIdx], sizeof(ReportConfigToAddMod_t));
8041       if(!reportCfgList->list.array[reportCfgIdx])
8042       {
8043          DU_LOG("\nERROR  -->  F1AP: fillReportCfgToAddModList(): Memory allocation failed for report config list's array element");
8044          return RFAILED;
8045       }
8046    }
8047
8048    reportCfgIdx = 0;
8049    reportCfg = reportCfgList->list.array[reportCfgIdx];
8050    reportCfg->reportConfigId = 1;
8051    reportCfg->reportConfig.present = ReportConfigToAddMod__reportConfig_PR_reportConfigNR;
8052
8053    /* Report Configuration for NR */
8054    CU_ALLOC(reportCfg->reportConfig.choice.reportConfigNR, sizeof(ReportConfigNR_t));
8055    if(!reportCfg->reportConfig.choice.reportConfigNR)
8056    {
8057       DU_LOG("\nERROR  -->  F1AP: fillReportCfgToAddModList(): Memory allocation failed for report config NR");
8058       return RFAILED;
8059    }
8060    reportCfgNr = reportCfg->reportConfig.choice.reportConfigNR;
8061
8062    /* Report Type */
8063    reportCfgNr->reportType.present = ReportConfigNR__reportType_PR_eventTriggered;
8064    CU_ALLOC(reportCfgNr->reportType.choice.eventTriggered, sizeof(EventTriggerConfig_t));
8065    if(!reportCfgNr->reportType.choice.eventTriggered)
8066    {
8067       DU_LOG("\nERROR  -->  F1AP: fillReportCfgToAddModList(): Memory allocation failed for event triggerred");
8068       return RFAILED;
8069    }
8070    eventTriggCfg = reportCfgNr->reportType.choice.eventTriggered;
8071
8072    /* Event 3 */
8073    eventTriggCfg->eventId.present = EventTriggerConfig__eventId_PR_eventA3;
8074    CU_ALLOC(eventTriggCfg->eventId.choice.eventA3, sizeof(struct EventTriggerConfig__eventId__eventA3));
8075    if(!eventTriggCfg->eventId.choice.eventA3)
8076    {
8077       DU_LOG("\nERROR  -->  F1AP: fillReportCfgToAddModList(): Memory allocation failed for event A3");
8078       return RFAILED;
8079    }
8080
8081    eventTriggCfg->eventId.choice.eventA3->a3_Offset.present = MeasTriggerQuantityOffset_PR_rsrp;
8082    eventTriggCfg->eventId.choice.eventA3->a3_Offset.choice.rsrp = 6; /* i.e. 3.0db . From Reference pcap log */
8083    eventTriggCfg->eventId.choice.eventA3->reportOnLeave = false;
8084    eventTriggCfg->eventId.choice.eventA3->hysteresis = 0;
8085    eventTriggCfg->eventId.choice.eventA3->timeToTrigger = TimeToTrigger_ms40;
8086    eventTriggCfg->eventId.choice.eventA3->useWhiteCellList = false;
8087
8088    /* Reference Signal Type */
8089    eventTriggCfg->rsType = NR_RS_Type_ssb;
8090
8091    /* Report Interval */
8092    eventTriggCfg->reportInterval = ReportInterval_ms1024;
8093
8094    /* Report Amount */
8095    eventTriggCfg->reportAmount = EventTriggerConfig__reportAmount_r8;
8096
8097    /* Report Quantity cell */
8098    eventTriggCfg->reportQuantityCell.rsrp = true;
8099    eventTriggCfg->reportQuantityCell.rsrq = false;
8100    eventTriggCfg->reportQuantityCell.sinr = false;
8101
8102    /* Maximum reported cells */
8103    eventTriggCfg->maxReportCells = 3;
8104
8105    /* Report qunatity RS Indexes */
8106    CU_ALLOC(eventTriggCfg->reportQuantityRS_Indexes, sizeof(MeasReportQuantity_t));
8107    if(!eventTriggCfg->reportQuantityRS_Indexes)
8108    {
8109       DU_LOG("\nERROR  -->  F1AP: fillReportCfgToAddModList(): Memory allocation failed for report qunatity RS indexes");
8110       return RFAILED;
8111    }
8112    eventTriggCfg->reportQuantityRS_Indexes->rsrp = true;
8113    eventTriggCfg->reportQuantityRS_Indexes->rsrq = false;
8114    eventTriggCfg->reportQuantityRS_Indexes->sinr = false;
8115
8116    /* Maximum number of RS indexes to report */
8117    CU_ALLOC(eventTriggCfg->maxNrofRS_IndexesToReport, sizeof(long));
8118    if(!eventTriggCfg->maxNrofRS_IndexesToReport)
8119    {
8120       DU_LOG("\nERROR  -->  F1AP: fillReportCfgToAddModList(): Memory allocation failed for max number of RS indexes to report");
8121       return RFAILED;
8122    }
8123    *(eventTriggCfg->maxNrofRS_IndexesToReport) = 1;
8124
8125    /* Include Beam measurement */
8126    eventTriggCfg->includeBeamMeasurements = false;
8127
8128    return ROK;
8129 }
8130
8131 /*******************************************************************
8132  *
8133  * @brief Fill measurement Id to add/mod list
8134
8135  * @details
8136  *
8137  *    Function : fillMeasIdToAddModList
8138  *
8139  *    Functionality: Fill measurement Id to add/mod list
8140  *
8141  * @params[in] Measurement Id to add/mod list
8142  * @return ROK     - success
8143  *         RFAILED - failure
8144  *
8145  * ****************************************************************/
8146 uint8_t fillMeasIdToAddModList(MeasIdToAddModList_t *measIdList)
8147 {
8148    uint8_t elementCnt;
8149    uint8_t measIdIdx;
8150
8151    elementCnt = 1;
8152    measIdList->list.count = elementCnt;
8153    measIdList->list.size = measIdList->list.count *sizeof(MeasIdToAddMod_t *);
8154
8155    CU_ALLOC(measIdList->list.array, measIdList->list.size);
8156    if(!measIdList->list.array)
8157    {
8158       return RFAILED;
8159    }
8160
8161    for(measIdIdx=0; measIdIdx < measIdList->list.count; measIdIdx++)
8162    {
8163       CU_ALLOC(measIdList->list.array[measIdIdx], sizeof(MeasIdToAddMod_t));
8164       if(!measIdList->list.array[measIdIdx])
8165       {
8166          return RFAILED;
8167       }
8168
8169       measIdIdx=0;
8170       measIdList->list.array[measIdIdx]->measId = 1;
8171       measIdList->list.array[measIdIdx]->measObjectId = 1;
8172       measIdList->list.array[measIdIdx]->reportConfigId = 1;
8173    }
8174    return ROK;
8175 }
8176
8177 /*******************************************************************
8178  *
8179  * @brief Fill s-measurement configuration
8180  *
8181  * @details
8182  *
8183  *    Function : fillSMeasConfig
8184  *
8185  *    Functionality: Fill s-measurement configuration
8186  *
8187  * @params[in] s-Measurement config
8188  * @return ROK     - success
8189  *         RFAILED - failure
8190  *
8191  * ****************************************************************/
8192 uint8_t fillSMeasConfig(struct MeasConfigRrc__s_MeasureConfig *sMeasCfg)
8193 {
8194    sMeasCfg->present = MeasConfigRrc__s_MeasureConfig_PR_ssb_RSRP;
8195    sMeasCfg->choice.ssb_RSRP = 100; /* Value taken from reference PCAP log */
8196
8197    return ROK;
8198 }
8199
8200 /*******************************************************************
8201  *
8202  * @brief Fill quantity config
8203  *
8204  * @details
8205  *
8206  *    Function : fillQunatityConfig
8207  *
8208  *    Functionality: Fill quantity config
8209  *
8210  * @params[in] Quantity Config
8211  * @return ROK     - success
8212  *         RFAILED - failure
8213  *
8214  * ****************************************************************/
8215 uint8_t fillQuantityConfig(QuantityConfig_t *quantityCfg)
8216 {
8217    uint8_t elementCnt = 0;
8218    uint8_t quanCfgIdx = 0;
8219    QuantityConfigNR_t *quantityCfgNr;
8220
8221    CU_ALLOC(quantityCfg->quantityConfigNR_List, sizeof(struct QuantityConfig__quantityConfigNR_List));
8222    if(!quantityCfg->quantityConfigNR_List)
8223    {
8224       return RFAILED;
8225    }
8226
8227    elementCnt = 1;
8228    quantityCfg->quantityConfigNR_List->list.count = elementCnt;
8229    quantityCfg->quantityConfigNR_List->list.size = elementCnt * sizeof(QuantityConfigNR_t *);
8230
8231    CU_ALLOC(quantityCfg->quantityConfigNR_List->list.array, quantityCfg->quantityConfigNR_List->list.size);
8232    if(!quantityCfg->quantityConfigNR_List->list.array)
8233    {
8234       return RFAILED;
8235    }
8236
8237    for(quanCfgIdx = 0; quanCfgIdx < quantityCfg->quantityConfigNR_List->list.count; quanCfgIdx++)
8238    {
8239       CU_ALLOC(quantityCfg->quantityConfigNR_List->list.array[quanCfgIdx], sizeof(QuantityConfigNR_t));
8240       if(!quantityCfg->quantityConfigNR_List->list.array[quanCfgIdx])
8241       {
8242          return RFAILED;
8243       }
8244    }
8245
8246    quanCfgIdx = 0;
8247    quantityCfgNr = quantityCfg->quantityConfigNR_List->list.array[quanCfgIdx];
8248
8249    /* Quantity Config of Reference signal */
8250    CU_ALLOC(quantityCfgNr->quantityConfigCell.ssb_FilterConfig.filterCoefficientRSRP, sizeof(FilterCoefficient_t));
8251    if(!quantityCfgNr->quantityConfigCell.ssb_FilterConfig.filterCoefficientRSRP)
8252    {
8253       return RFAILED;
8254    }
8255    *(quantityCfgNr->quantityConfigCell.ssb_FilterConfig.filterCoefficientRSRP) = FilterCoefficient_fc4;
8256
8257    CU_ALLOC(quantityCfgNr->quantityConfigCell.ssb_FilterConfig.filterCoefficientRSRQ, sizeof(FilterCoefficient_t));
8258    if(!quantityCfgNr->quantityConfigCell.ssb_FilterConfig.filterCoefficientRSRQ)
8259    {
8260       return RFAILED;
8261    }
8262    *(quantityCfgNr->quantityConfigCell.ssb_FilterConfig.filterCoefficientRSRQ) = FilterCoefficient_fc4;
8263
8264    CU_ALLOC(quantityCfgNr->quantityConfigCell.ssb_FilterConfig.filterCoefficientRS_SINR, sizeof(FilterCoefficient_t));
8265    if(!quantityCfgNr->quantityConfigCell.ssb_FilterConfig.filterCoefficientRS_SINR)
8266    {
8267       return RFAILED;
8268    }
8269    *(quantityCfgNr->quantityConfigCell.ssb_FilterConfig.filterCoefficientRS_SINR) = FilterCoefficient_fc4;
8270
8271    /* Quantity Config RS index */
8272    CU_ALLOC(quantityCfgNr->quantityConfigRS_Index, sizeof(QuantityConfigRS_t));
8273    if(!quantityCfgNr->quantityConfigRS_Index)
8274    {
8275       return RFAILED;
8276    }
8277
8278    CU_ALLOC(quantityCfgNr->quantityConfigRS_Index->ssb_FilterConfig.filterCoefficientRSRP, sizeof(FilterCoefficient_t));
8279    if(!quantityCfgNr->quantityConfigRS_Index->ssb_FilterConfig.filterCoefficientRSRP)
8280    {
8281       return RFAILED;
8282    }
8283    *(quantityCfgNr->quantityConfigRS_Index->ssb_FilterConfig.filterCoefficientRSRP) = FilterCoefficient_fc4;
8284
8285    CU_ALLOC(quantityCfgNr->quantityConfigRS_Index->ssb_FilterConfig.filterCoefficientRSRQ, sizeof(FilterCoefficient_t));
8286    if(!quantityCfgNr->quantityConfigRS_Index->ssb_FilterConfig.filterCoefficientRSRQ)
8287    {
8288       return RFAILED;
8289    }
8290    *(quantityCfgNr->quantityConfigRS_Index->ssb_FilterConfig.filterCoefficientRSRQ) = FilterCoefficient_fc4;
8291
8292    CU_ALLOC(quantityCfgNr->quantityConfigRS_Index->ssb_FilterConfig.filterCoefficientRS_SINR, sizeof(FilterCoefficient_t));
8293    if(!quantityCfgNr->quantityConfigRS_Index->ssb_FilterConfig.filterCoefficientRS_SINR)
8294    {
8295       return RFAILED;
8296    }
8297    *(quantityCfgNr->quantityConfigRS_Index->ssb_FilterConfig.filterCoefficientRS_SINR) = FilterCoefficient_fc4;
8298
8299    return ROK;
8300 }
8301
8302 /*******************************************************************
8303  *
8304  * @brief Fill measurement configuration
8305  *
8306  * @details
8307  *
8308  *    Function : fillMeasConfig
8309  *
8310  *    Functionality: Fill measurement configuration
8311  *
8312  * @params[in] Measurement config
8313  * @return ROK     - success
8314  *         RFAILED - failure
8315  *
8316  * ****************************************************************/
8317 uint8_t fillMeasConfig(MeasConfigRrc_t *measConfig)
8318 {
8319    /* Measurement object to add/mod list */
8320    CU_ALLOC(measConfig->measObjectToAddModList, sizeof(MeasObjectToAddModList_t));
8321    if(!measConfig->measObjectToAddModList)
8322    {
8323       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for measurement object list in fillMeasConfig");
8324       return RFAILED;
8325    }
8326    if(fillMeasObjToAddModList(measConfig->measObjectToAddModList) != ROK)
8327    {
8328       DU_LOG("\nERROR  -->  F1AP: Failure in fillMeasObjToAddModList");
8329       return RFAILED;
8330    }
8331
8332    /* Report Config To add/mod list */
8333    CU_ALLOC(measConfig->reportConfigToAddModList, sizeof(ReportConfigToAddModList_t));
8334    if(!measConfig->reportConfigToAddModList)
8335    {
8336       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for report config list in  fillMeasConfig");
8337       return RFAILED;
8338    }
8339    if(fillReportCfgToAddModList(measConfig->reportConfigToAddModList) != ROK)
8340    {
8341       DU_LOG("\nERROR  -->  F1AP: Failure in fillReportCfgToAddModList");
8342       return RFAILED;
8343    }
8344
8345    /* Measurement Id to add/mod list */
8346    CU_ALLOC(measConfig->measIdToAddModList, sizeof(MeasIdToAddModList_t));
8347    if(!measConfig->measIdToAddModList)
8348    {
8349       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for measuerment id list in  fillMeasConfig");
8350       return RFAILED;
8351    }
8352    if(fillMeasIdToAddModList(measConfig->measIdToAddModList) != ROK)
8353    {
8354       DU_LOG("\nERROR  -->  F1AP: Failure in fillMeasIdToAddModList");
8355       return RFAILED;
8356    }
8357
8358    /* S-Measurement config */
8359    CU_ALLOC(measConfig->s_MeasureConfig, sizeof(struct MeasConfigRrc__s_MeasureConfig));
8360    if(!measConfig->s_MeasureConfig)
8361    {
8362       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for s measuerment config in  fillMeasConfig");
8363       return RFAILED;
8364    }
8365    if(fillSMeasConfig(measConfig->s_MeasureConfig) != ROK)
8366    {
8367       DU_LOG("\nERROR  -->  F1AP: Failure in fillSMeasConfig");
8368       return RFAILED;
8369    }
8370
8371    /* Qunatity Config */
8372    CU_ALLOC(measConfig->quantityConfig, sizeof(QuantityConfig_t));
8373    if(!measConfig->quantityConfig)
8374    {
8375       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for quantity config in  fillMeasConfig");
8376       return RFAILED;
8377    }
8378    if(fillQuantityConfig(measConfig->quantityConfig) != ROK)
8379    {
8380       DU_LOG("\nERROR  -->  F1AP: Failure in fillQuantityConfig");
8381       return RFAILED;
8382    }
8383
8384 return ROK;
8385 }
8386
8387 /*******************************************************************
8388  *
8389  * @brief Fill RRC reconfiguration non-critical extension IE
8390  *
8391  * @details
8392  *
8393  *    Function : fillRrcReconfigNonCriticalExt
8394  *
8395  *    Functionality: Fill RRC reconfiguration non-critical extension
8396  *
8397  * @params[in] RRC Reconfig Non-critical extension
8398  * @return ROK     - success
8399  *         RFAILED - failure
8400  *
8401  * ****************************************************************/
8402 uint8_t fillRrcReconfigNonCriticalExt(CuUeCb *ueCb, RRCReconfiguration_v1530_IEs_t *rrcRecfg, bool updateAllRbCfg)
8403 {
8404    CU_ALLOC(rrcRecfg->masterCellGroup, sizeof(OCTET_STRING_t));
8405    if(!rrcRecfg->masterCellGroup)
8406    {
8407       return RFAILED;
8408    }
8409
8410    if(fillCellGrpCfg(ueCb, rrcRecfg->masterCellGroup, updateAllRbCfg) != ROK)
8411    {
8412       return RFAILED;
8413    }
8414
8415    return ROK;
8416 }
8417
8418 /*******************************************************************
8419  *
8420  * @brief Fill RRC reconfiguration structure
8421  *
8422  * @details
8423  *
8424  *    Function : fillRrcReconfig
8425  *
8426  *    Functionality: Fill RRC reconfiguration
8427
8428  *
8429  * @params[in] UE Cb
8430  *             RRC reconfiguration structure
8431  * @return ROK     - success
8432  *         RFAILED - failure
8433  *
8434  * ****************************************************************/
8435 uint8_t fillRrcReconfig(CuUeCb *ueCb, RRCReconfiguration_t *rrcReconfig, bool updateAllRbCfg)
8436 {
8437    memset(rrcReconfig, 0, sizeof(RRCReconfiguration_t));
8438
8439    rrcReconfig->rrc_TransactionIdentifier = 1;
8440    rrcReconfig->criticalExtensions.present = RRCReconfiguration__criticalExtensions_PR_rrcReconfiguration;
8441
8442    CU_ALLOC(rrcReconfig->criticalExtensions.choice.rrcReconfiguration, sizeof(RRCReconfiguration_IEs_t));
8443    if(!rrcReconfig->criticalExtensions.choice.rrcReconfiguration)
8444    {
8445       DU_LOG("\nERROR  -->  F1AP : Memormy allocation failed for RRC reconfiguration IE in fillRrcReconfig");
8446       return RFAILED;
8447    }
8448
8449    /* Radio Bearer Configuration */
8450    CU_ALLOC(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->radioBearerConfig, sizeof(RadioBearerConfig_t));
8451    if(!rrcReconfig->criticalExtensions.choice.rrcReconfiguration->radioBearerConfig)
8452    {
8453       DU_LOG("\nERROR  -->  F1AP : Memormy allocation failed for radio bearer config in fillRrcReconfig");
8454       return RFAILED;
8455    }
8456    if(fillRadioBearerConfig(ueCb, rrcReconfig->criticalExtensions.choice.rrcReconfiguration->radioBearerConfig, updateAllRbCfg) != ROK)
8457    {
8458       DU_LOG("\nERROR  -->  F1AP : Failed to fill radio bearer config in fillRrcReconfig");
8459       return RFAILED;
8460    }
8461
8462    /* Measurement Configuration */
8463    CU_ALLOC(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->measConfig, sizeof(MeasConfigRrc_t));
8464    if(!rrcReconfig->criticalExtensions.choice.rrcReconfiguration->measConfig)
8465    {
8466       DU_LOG("\nERROR  -->  F1AP : Memormy allocation failed for Measurement config IE in fillRrcReconfig");
8467       return RFAILED;
8468    }
8469    if(fillMeasConfig(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->measConfig) != ROK)
8470    {
8471       DU_LOG("\nERROR  -->  F1AP : Failed to fill measurement config in fillRrcReconfig");
8472       return RFAILED;
8473    }
8474
8475    /* Non Critical extension */
8476    CU_ALLOC(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->nonCriticalExtension, sizeof(struct RRCReconfiguration_v1530_IEs));
8477    if(!rrcReconfig->criticalExtensions.choice.rrcReconfiguration->nonCriticalExtension)
8478    {
8479       DU_LOG("\nERROR  -->  F1AP : Memormy allocation failed for non critical extension IE in fillRrcReconfig");
8480       return RFAILED;
8481    }
8482    if(fillRrcReconfigNonCriticalExt(ueCb, rrcReconfig->criticalExtensions.choice.rrcReconfiguration->nonCriticalExtension, updateAllRbCfg) != ROK)
8483    {
8484       DU_LOG("\nERROR  -->  F1AP : Failed to fill non critical extension in fillRrcReconfig");
8485       return RFAILED;
8486    }
8487    return ROK;
8488 }
8489
8490 /*******************************************************************
8491  *
8492  * @brief Fill RRC reconfiguration Octet string
8493  *
8494  * @details
8495  *
8496  *    Function : fillRrcReconfigBuf
8497  *
8498  *    Functionality: Fill RRC reconfiguration octet string
8499
8500  *
8501  * @params[in] OCTET_STRING_t buffer
8502  * @return ROK     - success
8503  *         RFAILED - failure
8504  *
8505  * ****************************************************************/
8506 uint8_t fillRrcReconfigBuf(CuUeCb *ueCb, OCTET_STRING_t  *rrcReconfigBuf, bool updateAllRbCfg)
8507 {
8508    uint8_t          ret = RFAILED;
8509    asn_enc_rval_t   encRetVal;
8510    RRCReconfiguration_t rrcRecfg, *rrcReconfig = NULLP;
8511    rrcReconfig = &rrcRecfg;
8512
8513    while(true)
8514    {
8515       if(fillRrcReconfig(ueCb, rrcReconfig, updateAllRbCfg) != ROK)
8516       {
8517          DU_LOG( "\nERROR  -->  F1AP : Failed to fill RRC Reconfiguration in fillRrcReconfigBuf");
8518          break;
8519       }
8520
8521       /* Encode RRC Reconfiguration */
8522       xer_fprint(stdout, &asn_DEF_RRCReconfiguration, rrcReconfig);
8523       cmMemset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
8524       encBufSize = 0;
8525       encRetVal = aper_encode(&asn_DEF_RRCReconfiguration, 0, rrcReconfig, PrepFinalEncBuf, encBuf);
8526
8527       /* Encode results */
8528       if(encRetVal.encoded == ENCODE_FAIL)
8529       {
8530          DU_LOG( "\nERROR  -->  F1AP : Could not encode RRC Reconfiguration (at %s)\n",\
8531                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
8532          break;
8533       }
8534       else
8535       {
8536          DU_LOG("\nDEBUG  -->  F1AP : Created APER encoded buffer for RRC Reconfiguration\n");
8537          for(int i=0; i< encBufSize; i++)
8538          {
8539             DU_LOG("%x",encBuf[i]);
8540          }
8541       }
8542
8543       rrcReconfigBuf->size = encBufSize;
8544       CU_ALLOC(rrcReconfigBuf->buf, rrcReconfigBuf->size);
8545       if(!rrcReconfigBuf->buf)
8546       {
8547          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in fillRrcReconfigBuf");
8548          break;
8549       }
8550       memcpy(rrcReconfigBuf->buf, encBuf, rrcReconfigBuf->size);
8551       ret = ROK;
8552       break;
8553    }
8554
8555    freeRrcReconfig(rrcReconfig);
8556    return ret;
8557 }
8558
8559 /*******************************************************************
8560  *
8561  * @brief Fill HO preparation information Octet string
8562  *
8563  * @details
8564  *
8565  *    Function : fillHOPreparationInfoBuf
8566  *
8567  *    Functionality: Fill HO preparation information Octet string
8568
8569  *
8570  * @params[in] HandoverPreparationInformation_t buffer
8571  * @return ROK     - success
8572  *         RFAILED - failure
8573  *
8574  * ****************************************************************/
8575 uint8_t fillHOPreparationInfoBuf(CuUeCb *ueCb, HandoverPreparationInformation_t *hoPrepInfoBuf)
8576 {
8577    uint8_t          ret = RFAILED;
8578    asn_enc_rval_t   encRetVal;
8579    HandoverPreparationInformationRrc_t hoPrepInfo;
8580    HandoverPreparationInformationRrc_IEs_t *hoPrepInfoIe;
8581
8582    while(true)
8583    {
8584
8585       hoPrepInfo.criticalExtensions.present = HandoverPreparationInformationRrc__criticalExtensions_PR_c1;
8586       CU_ALLOC(hoPrepInfo.criticalExtensions.choice.c1, sizeof(struct HandoverPreparationInformationRrc__criticalExtensions__c1));
8587       if(!hoPrepInfo.criticalExtensions.choice.c1)
8588       {
8589          DU_LOG( "\nERROR  -->  F1AP : Failed to allocate memory for c1 in fillHOPreparationInfo");
8590          break;
8591       }
8592       hoPrepInfo.criticalExtensions.choice.c1->present = \
8593          HandoverPreparationInformationRrc__criticalExtensions__c1_PR_handoverPreparationInformation;
8594
8595       CU_ALLOC(hoPrepInfo.criticalExtensions.choice.c1->choice.handoverPreparationInformation , \
8596          sizeof(HandoverPreparationInformationRrc_IEs_t));
8597       if(!hoPrepInfo.criticalExtensions.choice.c1->choice.handoverPreparationInformation)
8598       {
8599          DU_LOG( "\nERROR  -->  F1AP : Failed to allocate memory for handover preparation information IE in fillHOPreparationInfo");
8600          break;
8601       }
8602       hoPrepInfoIe = hoPrepInfo.criticalExtensions.choice.c1->choice.handoverPreparationInformation;
8603
8604       /* Fill UE Capability RAT container list */
8605       ret = fillUeCapRatContList(&hoPrepInfoIe->ue_CapabilityRAT_List);
8606       if(ret != ROK)
8607       {
8608          DU_LOG( "\nERROR  -->  F1AP : Failed to fill UE Capability RAT container list");
8609          break;
8610       }
8611
8612       /* Fill Source config */
8613       hoPrepInfoIe->sourceConfig = NULLP;
8614       CU_ALLOC(hoPrepInfoIe->sourceConfig, sizeof(AS_Config_t));
8615       if(!hoPrepInfoIe->sourceConfig)
8616       {
8617          DU_LOG( "\nERROR  -->  F1AP : Failed to allocate memory for source config in fillHOPreparationInfo");
8618          return RFAILED;
8619       }
8620       ret = fillRrcReconfigBuf(ueCb, &hoPrepInfoIe->sourceConfig->rrcReconfiguration, true);
8621
8622       hoPrepInfoIe->rrm_Config = NULLP;
8623       hoPrepInfoIe->as_Context = NULLP;
8624       hoPrepInfoIe->nonCriticalExtension = NULLP;
8625
8626       /* encode UE Capability RAT Container List into duToCuRrcContainer */
8627       xer_fprint(stdout, &asn_DEF_HandoverPreparationInformationRrc, &hoPrepInfo);
8628       cmMemset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
8629       encBufSize = 0;
8630       encRetVal = aper_encode(&asn_DEF_HandoverPreparationInformationRrc, 0, \
8631             &hoPrepInfo, PrepFinalEncBuf, encBuf);
8632
8633       /* Encode results */
8634       if(encRetVal.encoded == ENCODE_FAIL)
8635       {
8636          DU_LOG( "\nERROR  -->  F1AP : Could not encode UE Capability RAT Container (at %s)\n",\
8637                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
8638          break;
8639       }
8640       else
8641       {
8642          DU_LOG("\nDEBUG  -->  F1AP : Created APER encodedbuffer for UE Capability RAT Container\n");
8643          for(int i=0; i< encBufSize; i++)
8644          {
8645             DU_LOG("%x",encBuf[i]);
8646          }
8647       }
8648
8649       hoPrepInfoBuf->size = encBufSize;
8650       CU_ALLOC(hoPrepInfoBuf->buf, hoPrepInfoBuf->size);
8651       if(!hoPrepInfoBuf->buf)
8652       {
8653          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in fillUeCapabilityContainer");
8654          break;
8655       }
8656       memcpy(hoPrepInfoBuf->buf, encBuf, hoPrepInfoBuf->size);
8657       ret = ROK;
8658       break;
8659    }
8660    freeHOPreparationInfo(&hoPrepInfo);
8661    return ret;
8662 }
8663
8664 /*******************************************************************
8665  *
8666  * @brief Fills CuToDuContainer
8667  *
8668  * @details
8669  *
8670  *    Function : fillCuToDuContainer
8671  *
8672  *    Functionality: Fills CuToDuContainer
8673  *
8674  * @params[in] pointer to CUtoDURRCInformation_t
8675  *
8676  * @return ROK     - success
8677  *         RFAILED - failure
8678  *
8679  ******************************************************************/
8680
8681 uint8_t fillCuToDuContainer(CuUeCb *ueCb, CUtoDURRCInformation_t *rrcMsg)
8682 {
8683    uint8_t elementCnt = 0;
8684    uint8_t ret = ROK;
8685    uint8_t idx, idx2, rrcBufLen;
8686
8687    /* UE Capabulity RAT Container List */
8688    CU_ALLOC(rrcMsg->uE_CapabilityRAT_ContainerList, sizeof(UE_CapabilityRAT_ContainerList_t));
8689    if(!rrcMsg->uE_CapabilityRAT_ContainerList)
8690    {
8691       DU_LOG("\nERROR  -->  F1AP : Memory allocation for UE capability RAT container list failed");
8692       return RFAILED;
8693    }
8694    ret = fillUeCapRatContListBuf(rrcMsg->uE_CapabilityRAT_ContainerList);
8695
8696    CU_ALLOC(rrcMsg->measConfig, sizeof(MeasConfig_t));
8697    if(!rrcMsg->measConfig)
8698    {
8699       DU_LOG("\nERROR  -->  F1AP : Memory allocation for measurement configuration failed");
8700       return RFAILED;
8701    }
8702    ret = fillMeasTimingConfigBuf(rrcMsg->measConfig);
8703
8704    if(ueCb->state == UE_HANDOVER_IN_PROGRESS)
8705    {
8706       /* IE extensions */
8707       CU_ALLOC(rrcMsg->iE_Extensions, sizeof(ProtocolExtensionContainer_4624P16_t));
8708       if(rrcMsg->iE_Extensions)
8709       {
8710          elementCnt = 2;
8711          rrcMsg->iE_Extensions->list.count = elementCnt;
8712          rrcMsg->iE_Extensions->list.size = elementCnt * sizeof(CUtoDURRCInformation_ExtIEs_t *);
8713
8714          /* Initialize the CUtoDURRCInformation_ExtIEs */
8715          CU_ALLOC(rrcMsg->iE_Extensions->list.array, rrcMsg->iE_Extensions->list.size);
8716
8717          if(rrcMsg->iE_Extensions->list.array == NULLP)
8718          {
8719             DU_LOG("\nERROR  -->  F1AP : Memory allocation for CUtoDURRCInformation_ExtIEs failed");
8720             ret = RFAILED;
8721          }
8722
8723          for(idx=0; idx<elementCnt; idx++)
8724          {
8725             CU_ALLOC(rrcMsg->iE_Extensions->list.array[idx], sizeof(CUtoDURRCInformation_ExtIEs_t));
8726             if(rrcMsg->iE_Extensions->list.array[idx] == NULLP)
8727             {
8728                DU_LOG("\nERROR  -->  F1AP : Memory allocation for array elements failed");
8729                ret = RFAILED;
8730             }
8731          }
8732
8733          idx = 0;
8734
8735          /* Cell Group Configuration */
8736          rrcMsg->iE_Extensions->list.array[idx]->id = ProtocolIE_ID_id_CellGroupConfig;
8737          rrcMsg->iE_Extensions->list.array[idx]->criticality = Criticality_ignore;
8738          rrcMsg->iE_Extensions->list.array[idx]->extensionValue.present  =\
8739                                                                           CUtoDURRCInformation_ExtIEs__extensionValue_PR_CellGroupConfig;
8740          ret = fillCellGrpCfg(ueCb, &rrcMsg->iE_Extensions->list.array[idx]->extensionValue.choice.CellGroupConfig, true);
8741
8742          /* Handover Preparation Information */
8743          idx++;
8744          rrcMsg->iE_Extensions->list.array[idx]->id = ProtocolIE_ID_id_HandoverPreparationInformation;
8745          rrcMsg->iE_Extensions->list.array[idx]->criticality = Criticality_ignore;
8746          rrcMsg->iE_Extensions->list.array[idx]->extensionValue.present  = \
8747                                                                            CUtoDURRCInformation_ExtIEs__extensionValue_PR_HandoverPreparationInformation;
8748          ret = fillHOPreparationInfoBuf(ueCb, &rrcMsg->iE_Extensions->list.array[idx]->extensionValue.choice.HandoverPreparationInformation);
8749       }
8750    }
8751    return ret;
8752 }
8753
8754 /*******************************************************************
8755  *
8756  * @brief Free CuToDuContainer
8757  *
8758  * @details
8759  *
8760  *    Function : FreeCuToDuInfo
8761  *
8762  *    Functionality: Free CuToDuContainer
8763  *
8764  * @params[in] pointer to CUtoDURRCInformation_t
8765  *
8766  * @return ROK     - success
8767  *         RFAILED - failure
8768  *
8769  ******************************************************************/
8770
8771 void FreeCuToDuInfo(CUtoDURRCInformation_t *rrcMsg)
8772 {
8773    uint8_t idx, idx2;
8774
8775    if(rrcMsg->uE_CapabilityRAT_ContainerList)
8776    {
8777       if(rrcMsg->uE_CapabilityRAT_ContainerList->buf)
8778          CU_FREE(rrcMsg->uE_CapabilityRAT_ContainerList->buf, rrcMsg->uE_CapabilityRAT_ContainerList->size);
8779       CU_FREE(rrcMsg->uE_CapabilityRAT_ContainerList, sizeof(UE_CapabilityRAT_ContainerList_t));
8780    }
8781    if(rrcMsg->iE_Extensions)
8782    {
8783       if(rrcMsg->iE_Extensions->list.array)
8784       {
8785          for(idx= 0; idx < rrcMsg->iE_Extensions->list.count; idx++)
8786          {
8787             if(rrcMsg->iE_Extensions->list.array[idx])
8788             {
8789                switch(rrcMsg->iE_Extensions->list.array[idx]->id)
8790                {
8791                   case ProtocolIE_ID_id_CellGroupConfig:
8792                      if(rrcMsg->iE_Extensions->list.array[idx]->extensionValue.choice.CellGroupConfig.buf != NULLP)
8793                      {
8794                         CU_FREE(rrcMsg->iE_Extensions->list.array[idx]->extensionValue.choice.CellGroupConfig.buf,\
8795                               rrcMsg->iE_Extensions->list.array[idx]->extensionValue.choice.CellGroupConfig.size);
8796
8797                      }
8798                      break;
8799                   default:
8800                      DU_LOG("\nERROR  -->  F1AP : Invalid Event type %ld at FreeCuToDuInfo()", \
8801                            rrcMsg->iE_Extensions->list.array[idx]->id);
8802                      break;
8803                }
8804             }
8805             break;
8806          }
8807          for(idx2 = 0; idx2 < idx; idx2++)
8808          {
8809             CU_FREE(rrcMsg->iE_Extensions->list.array[idx2], sizeof(CUtoDURRCInformation_ExtIEs_t));
8810          }
8811          CU_FREE(rrcMsg->iE_Extensions->list.array, rrcMsg->iE_Extensions->list.size);
8812
8813       }
8814
8815       CU_FREE(rrcMsg->iE_Extensions, sizeof(ProtocolExtensionContainer_4624P16_t));
8816    }
8817 }
8818 /*******************************************************************
8819  *
8820  * @brief Builds and sends the UE Setup Request
8821  *
8822  * @details
8823  *
8824  *    Function : BuildAndSendUeContextSetupReq
8825  *
8826  *    Functionality: Constructs the UE Setup Request and sends
8827  *                   it to the CU through SCTP.
8828  *
8829  * @params[in]
8830  *
8831  * @return ROK     - success
8832  *         RFAILED - failure
8833  *
8834  * ****************************************************************/
8835 uint8_t BuildAndSendUeContextSetupReq(uint32_t duId, CuUeCb *ueCb, uint16_t rrcContLen, uint8_t *rrcContainer)
8836 {
8837    uint8_t   Nrcgiret, SplCellListret, SrbSetupret;
8838    uint8_t   ret= RFAILED, ret1;
8839    uint8_t   elementCnt;
8840    uint8_t   idx, idx1, bufLen, duIdx;
8841    uint32_t  spCellId;
8842    DuDb      *targetDuDb = NULLP;
8843    F1AP_PDU_t           *f1apMsg = NULLP;
8844    UEContextSetupRequest_t *ueSetReq = NULLP;
8845    asn_enc_rval_t encRetVal;        /* Encoder return value */
8846    memset(&encRetVal, 0, sizeof(asn_enc_rval_t));
8847
8848    while(true)
8849    {
8850       DU_LOG("\nINFO  -->  F1AP : Building UE Context Setup Request\n");
8851
8852       CU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
8853       if(f1apMsg == NULLP)
8854       {
8855          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
8856          break;
8857       }
8858
8859       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
8860       CU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
8861       if(f1apMsg->choice.initiatingMessage == NULLP)
8862       {
8863          DU_LOG("\nERROR  -->  F1AP : Memory allocation for     F1AP-PDU failed");
8864          break;
8865       }
8866
8867       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_UEContextSetup;
8868       f1apMsg->choice.initiatingMessage->criticality = Criticality_reject;
8869       f1apMsg->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_UEContextSetupRequest;
8870
8871       ueSetReq = &f1apMsg->choice.initiatingMessage->value.choice.UEContextSetupRequest;
8872
8873       if(ueCb->state == UE_HANDOVER_IN_PROGRESS)
8874          elementCnt = 7;
8875       else
8876          elementCnt = 12;
8877       ueSetReq->protocolIEs.list.count = elementCnt;
8878       ueSetReq->protocolIEs.list.size = elementCnt * sizeof(UEContextSetupRequestIEs_t *);
8879
8880       /* Initialize the UESetup members */
8881       CU_ALLOC(ueSetReq->protocolIEs.list.array,ueSetReq->protocolIEs.list.size);
8882
8883       if(ueSetReq->protocolIEs.list.array == NULLP)
8884       {
8885          DU_LOG("\nERROR  -->  F1AP : Memory allocation for UE Context SetupRequest failed");
8886          break;
8887       }
8888
8889       for(idx1=0; idx1<elementCnt; idx1++)
8890       {
8891          CU_ALLOC(ueSetReq->protocolIEs.list.array[idx1],sizeof(UEContextSetupRequestIEs_t));
8892          if(ueSetReq->protocolIEs.list.array[idx1] == NULLP)
8893          {
8894             break;
8895          }
8896       }
8897
8898       idx = 0;
8899
8900       /*GNB CU UE F1AP ID*/
8901       ueSetReq->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
8902       ueSetReq->protocolIEs.list.array[idx]->criticality        =       Criticality_reject;
8903       ueSetReq->protocolIEs.list.array[idx]->value.present = UEContextSetupRequestIEs__value_PR_GNB_CU_UE_F1AP_ID;
8904       ueSetReq->protocolIEs.list.array[idx]->value.choice.GNB_CU_UE_F1AP_ID = ueCb->gnbCuUeF1apId;
8905
8906       if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
8907       {
8908          /*GNB DU UE F1AP ID*/
8909          idx++;
8910          ueSetReq->protocolIEs.list.array[idx]->id      = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
8911          ueSetReq->protocolIEs.list.array[idx]->criticality     =       Criticality_ignore;
8912          ueSetReq->protocolIEs.list.array[idx]->value.present = UEContextSetupRequestIEs__value_PR_GNB_DU_UE_F1AP_ID;
8913          ueSetReq->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID = ueCb->gnbDuUeF1apId;
8914       }
8915
8916       /*Special Cell ID*/
8917       idx++;
8918       ueSetReq->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_SpCell_ID;
8919       ueSetReq->protocolIEs.list.array[idx]->criticality        =       Criticality_reject;
8920       ueSetReq->protocolIEs.list.array[idx]->value.present = UEContextSetupRequestIEs__value_PR_NRCGI;
8921       if(ueCb->state == UE_HANDOVER_IN_PROGRESS)
8922       {
8923          /* Spec 38.473 Sec 9.2.2.1 : For handover case, this IE shall be considered as target cell. */
8924          SEARCH_DU_DB(duIdx, ueCb->hoInfo.targetDuId, targetDuDb);
8925          /* Since we are supporting only one cell per DU, accessing 0th index to
8926           * get target cell info */
8927          spCellId = targetDuDb->cellCb[0].nrCellId;
8928       }
8929       else
8930          spCellId = ueCb->cellCb->nrCellId;
8931       Nrcgiret = BuildNrcgi(&ueSetReq->protocolIEs.list.array[idx]->value.choice.NRCGI, spCellId);
8932       if(Nrcgiret != ROK)
8933       {
8934          break;
8935       }
8936
8937       /*Served Cell Index*/
8938       idx++;
8939       ueSetReq->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_ServCellIndex;
8940       ueSetReq->protocolIEs.list.array[idx]->criticality        =       Criticality_reject;
8941       ueSetReq->protocolIEs.list.array[idx]->value.present = UEContextSetupRequestIEs__value_PR_ServCellIndex;
8942       ueSetReq->protocolIEs.list.array[idx]->value.choice.ServCellIndex = CELL_INDEX;
8943
8944       if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
8945       {
8946          /*CellULConfigured*/
8947          idx++;
8948          ueSetReq->protocolIEs.list.array[idx]->id      = ProtocolIE_ID_id_SpCellULConfigured;
8949          ueSetReq->protocolIEs.list.array[idx]->criticality     =       Criticality_ignore;
8950          ueSetReq->protocolIEs.list.array[idx]->value.present = UEContextSetupRequestIEs__value_PR_CellULConfigured;
8951          ueSetReq->protocolIEs.list.array[idx]->value.choice.CellULConfigured = CellULConfigured_none;
8952       }
8953
8954       /*CUtoDURRCContainer*/
8955       idx++;
8956       ueSetReq->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_CUtoDURRCInformation;
8957       ueSetReq->protocolIEs.list.array[idx]->criticality        =       Criticality_reject;
8958       ueSetReq->protocolIEs.list.array[idx]->value.present = UEContextSetupRequestIEs__value_PR_CUtoDURRCInformation;
8959       if(fillCuToDuContainer(ueCb, &ueSetReq->protocolIEs.list.array[idx]->value.choice.CUtoDURRCInformation))
8960       {
8961          break;
8962       }
8963
8964       if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
8965       {
8966          /*Special Cells to be SetupList*/
8967          idx++;
8968          ueSetReq->protocolIEs.list.array[idx]->id      = ProtocolIE_ID_id_SCell_ToBeSetup_List;
8969          ueSetReq->protocolIEs.list.array[idx]->criticality     =       Criticality_ignore;
8970          ueSetReq->protocolIEs.list.array[idx]->value.present = UEContextSetupRequestIEs__value_PR_SCell_ToBeSetup_List;
8971          SplCellListret = BuildSplCellList(ueCb, &ueSetReq->protocolIEs.list.array[idx]->value.choice.SCell_ToBeSetup_List);
8972          if(SplCellListret != ROK)
8973          {
8974             break;
8975          }
8976       }
8977
8978       /*SRBs To Be Setup List*/
8979       idx++;
8980       ueSetReq->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_SRBs_ToBeSetup_List;
8981       ueSetReq->protocolIEs.list.array[idx]->criticality        =       Criticality_reject;
8982       ueSetReq->protocolIEs.list.array[idx]->value.present = UEContextSetupRequestIEs__value_PR_SRBs_ToBeSetup_List;
8983       SrbSetupret = BuildSRBSetup(ueCb, &ueSetReq->protocolIEs.list.array[idx]->value.choice.SRBs_ToBeSetup_List);
8984       if(SrbSetupret != ROK)
8985       {
8986          break;
8987       }
8988
8989       /*DRBs to Be Setup List*/
8990       idx++;
8991       ueSetReq->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_DRBs_ToBeSetup_List;
8992       ueSetReq->protocolIEs.list.array[idx]->criticality        =       Criticality_reject;
8993       ueSetReq->protocolIEs.list.array[idx]->value.present = UEContextSetupRequestIEs__value_PR_DRBs_ToBeSetup_List;
8994       ret1 = BuildDRBSetup(ueCb, &ueSetReq->protocolIEs.list.array[idx]->value.choice.DRBs_ToBeSetup_List);
8995       if(ret1 != ROK)
8996       {
8997          break;
8998       }
8999
9000       if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
9001       {
9002          /* RRC Container for security mode */
9003          idx++;
9004          ueSetReq->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_RRCContainer;
9005          ueSetReq->protocolIEs.list.array[idx]->criticality = Criticality_reject;
9006          ueSetReq->protocolIEs.list.array[idx]->value.present = UEContextSetupRequestIEs__value_PR_RRCContainer;
9007
9008          char secModeBuf[9]={0x00, 0x02, 0x22, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00};
9009          bufLen =9;
9010          ueSetReq->protocolIEs.list.array[idx]->value.choice.RRCContainer.size = bufLen;
9011          CU_ALLOC(ueSetReq->protocolIEs.list.array[idx]->value.choice.RRCContainer.buf,
9012                ueSetReq->protocolIEs.list.array[idx]->value.choice.RRCContainer.size);
9013          if(!ueSetReq->protocolIEs.list.array[idx]->value.choice.RRCContainer.buf)
9014          {
9015             DU_LOG("\nERROR  -->  F1AP : Memory allocation for BuildAndSendUeContextSetupReq failed");
9016             break;
9017          }
9018          memset(ueSetReq->protocolIEs.list.array[idx]->value.choice.RRCContainer.buf, 0, bufLen);
9019          memcpy(ueSetReq->protocolIEs.list.array[idx]->value.choice.RRCContainer.buf, secModeBuf, bufLen);
9020
9021          /* RRC delivery status request */
9022          idx++;
9023          ueSetReq->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_RRCDeliveryStatusRequest;
9024          ueSetReq->protocolIEs.list.array[idx]->criticality = Criticality_ignore;
9025          ueSetReq->protocolIEs.list.array[idx]->value.present = UEContextSetupRequestIEs__value_PR_RRCDeliveryStatusRequest;
9026          ueSetReq->protocolIEs.list.array[idx]->value.choice.RRCDeliveryStatusRequest = RRCDeliveryStatusRequest_true;
9027       }
9028
9029       /* GNB-DU UE Aggregate Maximum Bit Rate hardcoded as in reference logs */
9030       idx++;
9031       ueSetReq->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_GNB_DU_UE_AMBR_UL;
9032       ueSetReq->protocolIEs.list.array[idx]->criticality = Criticality_ignore;
9033       ueSetReq->protocolIEs.list.array[idx]->value.present = UEContextSetupRequestIEs__value_PR_BitRate;
9034
9035       char bitRateBuf[4]= {0x3B, 0x37, 0xF4, 0xCD};
9036       bufLen = 4;
9037       ueSetReq->protocolIEs.list.array[idx]->value.choice.BitRate.size = bufLen;
9038       CU_ALLOC(ueSetReq->protocolIEs.list.array[idx]->value.choice.BitRate.buf,\
9039             ueSetReq->protocolIEs.list.array[idx]->value.choice.BitRate.size);
9040       if(!ueSetReq->protocolIEs.list.array[idx]->value.choice.BitRate.buf)
9041       {
9042          DU_LOG("\nERROR  -->  F1AP : Failed to allocate memory for Bit Rate in BuildAndSendUeContextSetupReq()");
9043          break;
9044       }
9045       memset(ueSetReq->protocolIEs.list.array[idx]->value.choice.BitRate.buf, 0, bufLen);
9046       memcpy(ueSetReq->protocolIEs.list.array[idx]->value.choice.BitRate.buf, bitRateBuf, bufLen);
9047
9048       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
9049
9050       /* Encode the F1SetupRequest type as APER */
9051       memset(encBuf, 0, ENC_BUF_MAX_LEN);
9052       encBufSize = 0;
9053       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
9054
9055       /* Encode results */
9056       if(encRetVal.encoded == ENCODE_FAIL)
9057       {
9058          DU_LOG( "\nERROR  -->  F1AP : Could not encode UE Context Setup Request structure (at %s)\n",\
9059                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
9060          break;
9061       }
9062       else
9063       {
9064          DU_LOG("\nDEBUG  -->  F1AP : Created APER encodedbuffer for UE Context Setup Request\n");
9065          for(int i=0; i< encBufSize; i++)
9066          {
9067             DU_LOG("%x",encBuf[i]);
9068          }
9069       }
9070
9071       /* Sending  msg  */
9072       if(SendF1APMsg(CU_APP_MEM_REG, CU_POOL, duId)     !=      ROK)
9073       {
9074          DU_LOG("\nERROR  -->  F1AP : Sending UE Context Setup Request Failed");
9075          break;
9076       }
9077       ret = ROK;
9078       break;
9079    }
9080    FreeUeContextSetupReq(f1apMsg);
9081
9082    return ret;
9083 }/* End of BuildAndSendUeContextSetupReq*/
9084
9085 /**********************************************************************
9086  * @brief Function to extractTeId received in UE context setup Response
9087  *
9088  * @details
9089  *
9090  *    Function : extractTeId
9091  *
9092  *    Functionality:
9093  *         - Function to extract TeId
9094  *
9095  * @params[in]
9096  * @return ROK     - success
9097  *         RFAILED - failure
9098  *
9099  **********************************************************************/
9100 uint8_t extractTeId(DLUPTNLInformation_ToBeSetup_List_t *dlTnlInfo)
9101 {
9102    uint8_t arrIdx = 0;
9103    uint32_t teId = 0;
9104    GTPTunnel_t *gtpDl = NULLP;
9105
9106    for(arrIdx =0; arrIdx < dlTnlInfo->list.count; arrIdx++)
9107    {
9108       if(dlTnlInfo->list.array[arrIdx]->dLUPTNLInformation.present == UPTransportLayerInformation_PR_gTPTunnel)
9109       {
9110          if(dlTnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel != NULLP)
9111          {
9112             gtpDl = dlTnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel;
9113             if(gtpDl->gTP_TEID.size > 0)
9114             {
9115                teIdStringToInt(gtpDl->gTP_TEID.buf, &teId);
9116             }
9117             else
9118                DU_LOG("\nERROR  -->  EGTP: No TeId received");
9119             return(teId);
9120          }
9121       }
9122    }
9123    return teId;
9124 }
9125
9126 /****************************************************************
9127  * @brief Function to add Drb tunnels
9128  *
9129  * @details
9130  *
9131  *    Function : addDrbTunnels
9132  *
9133  *    Functionality:
9134  *         - Function to add Drb tunnels
9135  *
9136  * @params[in]
9137  * @return ROK     - success
9138  *         RFAILED - failure
9139  *
9140  * ****************************************************************/
9141 uint8_t addDrbTunnels(uint8_t teId)
9142 {
9143    uint8_t ret = ROK;
9144    EgtpTnlEvt tnlEvt;
9145
9146    if(teId > MAX_TEID || teId < MIN_TEID)
9147    {
9148       DU_LOG("\nERROR  -->  EGTP : TEID(%x) OUT Of Range",teId);
9149    }
9150    memset(&tnlEvt, 0, sizeof(EgtpTnlEvt));
9151    tnlEvt.action = EGTP_TNL_MGMT_ADD;
9152    tnlEvt.lclTeid = teId;
9153    tnlEvt.remTeid = teId;
9154    ret = cuEgtpTnlMgmtReq(tnlEvt);
9155    if(ret != ROK)
9156    {
9157       DU_LOG("\nERROR  -->  EGTP : Tunnel management request failed for teId %x", teId);
9158    }
9159    return ROK;
9160 }
9161
9162 /****************************************************************
9163  * @brief Function to process Drb Setup List
9164  *
9165  * @details
9166  *
9167  *    Function : procDrbSetupList
9168  *
9169  *    Functionality:
9170  *         - Function to process DRB Setup List
9171  *
9172  * @params[in]
9173  * @return ROK     - success
9174  *         RFAILED - failure
9175  *
9176  * ****************************************************************/
9177 uint8_t procDrbSetupList(DRBs_Setup_List_t *drbSetupList)
9178 {
9179    uint8_t arrIdx = 0;
9180    uint32_t teId = 0;
9181    DRBs_Setup_ItemIEs_t *drbItemIe = NULLP;
9182
9183    if(drbSetupList != NULLP)
9184    {
9185       for(arrIdx = 0; arrIdx < drbSetupList->list.count; arrIdx++)
9186       {
9187          drbItemIe = ((DRBs_Setup_ItemIEs_t *)drbSetupList->list.array[arrIdx]);
9188          if(drbItemIe->value.present == DRBs_Setup_ItemIEs__value_PR_DRBs_Setup_Item)
9189          {
9190             /* extracting teId */
9191             teId  = extractTeId(&drbItemIe->value.choice.DRBs_Setup_Item.dLUPTNLInformation_ToBeSetup_List);
9192             if(teId > 0)
9193             {
9194               if(addDrbTunnels(teId)== ROK)
9195               {
9196                 DU_LOG("\nDEBUG  --> EGTP: Tunnel Added for TeId %d", teId);
9197               }
9198             }
9199             else
9200                return RFAILED;
9201          }
9202       }
9203    }
9204    return ROK;
9205 }
9206
9207 /****************************************************************
9208  * @brief Function to process Ue Context Setup Response
9209  *
9210  * @details
9211  *
9212  *    Function : procUeContextSetupResponse
9213  *
9214  *    Functionality:
9215  *         - Function to process Ue Context Setup Response
9216  *
9217  * @params[in]
9218  * @return ROK     - success
9219  *         RFAILED - failure
9220  *
9221  * ****************************************************************/
9222 uint8_t procUeContextSetupResponse(uint32_t duId, F1AP_PDU_t *f1apMsg)
9223 {
9224    uint8_t duIdx=0, idx, duUeF1apId;
9225    DuDb *duDb;
9226    CuUeCb *ueCb;
9227    UEContextSetupResponse_t *ueCtxtSetupRsp = NULLP;
9228
9229    SEARCH_DU_DB(duIdx, duId, duDb);
9230    ueCtxtSetupRsp = &f1apMsg->choice.successfulOutcome->value.choice.UEContextSetupResponse;
9231
9232    for(idx=0; idx < ueCtxtSetupRsp->protocolIEs.list.count; idx++)
9233    {
9234       switch(ueCtxtSetupRsp->protocolIEs.list.array[idx]->id)
9235       {
9236           case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
9237              {
9238                 duUeF1apId = ueCtxtSetupRsp->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID;
9239                 ueCb = &duDb->ueCb[duUeF1apId-1];
9240                 break;
9241              }
9242           case ProtocolIE_ID_id_DRBs_Setup_List:
9243              {
9244                 /* Adding Tunnels for successful DRB */
9245                 procDrbSetupList(&ueCtxtSetupRsp->protocolIEs.list.array[idx]->value.choice.DRBs_Setup_List);
9246                 break;
9247              }
9248          case ProtocolIE_ID_id_DUtoCURRCInformation:
9249              {
9250                 DU_LOG("\nINFO  -->  Received Du to Cu RRC Information ");
9251                 if((extractDuToCuRrcCont(ueCb, ueCtxtSetupRsp->protocolIEs.list.array[idx]->value.choice.\
9252                    DUtoCURRCInformation.cellGroupConfig)) != ROK)
9253                 {
9254                    DU_LOG("\nERROR  -->  F1AP: Failed to extract Du to Cu RRC Information ");
9255                    return RFAILED;
9256                 }
9257                 break;
9258              }
9259       }
9260    }
9261    ueCb->f1apMsgDb.dlRrcMsgCount++; /* keeping DL RRC Msg Count */
9262    return ROK;
9263 }
9264
9265 /****************************************************************
9266  * @brief Function to process Ul Rrc Msg received from DU
9267  *
9268  * @details
9269  *
9270  *    Function : procUlRrcMsg
9271  *
9272  *    Functionality:
9273  *         - Function to process Ul Rrc Msg received from DU
9274  *
9275  * @params[in]
9276  * @return ROK     - success
9277  *         RFAILED - failure
9278  *
9279  * ****************************************************************/
9280
9281 uint8_t procUlRrcMsg(uint32_t duId, F1AP_PDU_t *f1apMsg)
9282 {
9283    uint8_t idx, ret, srbId, rrcMsgType, duIdx=0;
9284    uint8_t cuUeF1apId, duUeF1apId;
9285    uint8_t *rrcContainer = NULLP;
9286    uint16_t rrcContLen;
9287    DuDb     *duDb;
9288    CuUeCb   *ueCb;
9289    ULRRCMessageTransfer_t *ulRrcMsg = NULLP;
9290
9291    ret = ROK;
9292    SEARCH_DU_DB(duIdx, duId, duDb);
9293    ulRrcMsg = &f1apMsg->choice.initiatingMessage->value.choice.ULRRCMessageTransfer;
9294
9295    for(idx=0; idx < ulRrcMsg->protocolIEs.list.count; idx++)
9296    {
9297       switch(ulRrcMsg->protocolIEs.list.array[idx]->id)
9298       {
9299          case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
9300             {
9301                cuUeF1apId = ulRrcMsg->protocolIEs.list.array[idx]->value.choice.GNB_CU_UE_F1AP_ID;
9302                break;
9303             }
9304          case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
9305             {
9306                duUeF1apId = ulRrcMsg->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID;
9307                break;
9308             }
9309          case ProtocolIE_ID_id_SRBID:
9310             srbId = ulRrcMsg->protocolIEs.list.array[idx]->value.choice.SRBID;
9311             break;
9312
9313          case ProtocolIE_ID_id_RRCContainer:
9314             {
9315                rrcContLen = ulRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.size;
9316                CU_ALLOC(rrcContainer, rrcContLen);
9317                if(!rrcContainer)
9318                {
9319                   DU_LOG("\nERROR  -->  F1AP : Failed to allocated memory in procUlRrcMsg");
9320                   return RFAILED;
9321                }
9322                memcpy(rrcContainer, ulRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.buf, rrcContLen);
9323                break;
9324             }
9325
9326          default:
9327             DU_LOG("\nERROR  -->  F1AP : Invalid Event %ld", ulRrcMsg->protocolIEs.list.array[idx]->id);
9328             break;
9329       }
9330    }
9331
9332    if(srbId == 1)
9333    {
9334       ueCb = &duDb->ueCb[duUeF1apId-1];
9335       ueCb->f1apMsgDb.dlRrcMsgCount++;
9336       rrcMsgType = setDlRRCMsgType(ueCb);
9337       if(rrcMsgType == REGISTRATION_ACCEPT)
9338       {
9339          DU_LOG("\nINFO  -->  F1AP: Sending DL RRC MSG for RRC Registration Accept");
9340          ret = BuildAndSendDLRRCMessageTransfer(duId, ueCb, srbId, rrcMsgType);
9341       }
9342       if(rrcMsgType == UE_CONTEXT_SETUP_REQ)
9343       {
9344          DU_LOG("\nINFO  -->  F1AP: Sending Ue Context Setup Req");
9345          ret = BuildAndSendUeContextSetupReq(duId, ueCb, rrcContLen, rrcContainer);
9346       }
9347       if(rrcMsgType == SECURITY_MODE_COMPLETE)
9348       {
9349          /* To trigger the DL RRC Msg for RRC Reconfig */
9350          ueCb->f1apMsgDb.dlRrcMsgCount++;
9351          rrcMsgType = setDlRRCMsgType(ueCb);
9352          if(rrcMsgType == RRC_RECONFIG)
9353          {
9354             DU_LOG("\nINFO  -->  F1AP: Sending DL RRC MSG for RRC Reconfig");
9355             BuildAndSendDLRRCMessageTransfer(duId, ueCb, srbId, rrcMsgType);
9356          }
9357       }
9358       if(rrcMsgType == RRC_RECONFIG_COMPLETE)
9359       {
9360          ueCb->state = UE_ACTIVE;
9361          ueCb->f1apMsgDb.dlRrcMsgCount++;
9362          rrcMsgType = setDlRRCMsgType(ueCb);
9363          if(rrcMsgType == UE_CONTEXT_MOD_REQ)
9364          {
9365             DU_LOG("\nINFO  -->  F1AP: Sending UE Context Modification Request");
9366             BuildAndSendUeContextModificationReq(duId, ueCb, RRC_RECONFIG_COMPLETE_IND);
9367          }
9368       }
9369    }
9370    return ret;
9371 }
9372
9373 /****************************************************************
9374  * @brief Build And Send F1ResetAck
9375  *
9376  * @details
9377  *
9378  *    Function : FreeF1ResetAck
9379  *
9380  *    Functionality:
9381  *         - Build And Send  F1ResetRSP
9382  *
9383  *  @params[in]
9384  * @return ROK     - success
9385  *         RFAILED - failure
9386  *
9387  * ****************************************************************/
9388 void FreeF1ResetAck(F1AP_PDU_t *f1apMsg)
9389 {
9390    uint8_t idx;
9391    ResetAcknowledge_t *f1ResetAck;
9392
9393    if(f1apMsg)
9394    {
9395       if(f1apMsg->choice.successfulOutcome)
9396       {
9397          f1ResetAck= &f1apMsg->choice.successfulOutcome->value.choice.ResetAcknowledge;
9398
9399          if(f1ResetAck->protocolIEs.list.array)
9400          {
9401             for(idx=0; idx<f1ResetAck->protocolIEs.list.count ; idx++)
9402             {
9403                if(f1ResetAck->protocolIEs.list.array[idx])
9404                {
9405                   CU_FREE(f1ResetAck->protocolIEs.list.array[idx], sizeof(ResetAcknowledgeIEs_t));
9406                }
9407             }
9408             CU_FREE(f1ResetAck->protocolIEs.list.array, f1ResetAck->protocolIEs.list.size );
9409          }
9410          CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
9411       }
9412       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
9413    }
9414 }
9415
9416 /****************************************************************
9417  * @brief Build And Send F1ResetAck
9418  *
9419  * @details
9420  *
9421  *    Function : BuildAndSendF1ResetAck
9422  *
9423  *    Functionality:
9424  *         - Build And Send  F1ResetRSP
9425  *
9426  *  @params[in]
9427  * @return ROK     - success
9428  *         RFAILED - failure
9429  *
9430  * ****************************************************************/
9431
9432 uint8_t BuildAndSendF1ResetAck()
9433 {
9434    uint8_t                idx = 0;
9435    uint8_t                elementCnt = 0;
9436    uint8_t                ret = RFAILED;
9437    F1AP_PDU_t             *f1apMsg = NULL;
9438    ResetAcknowledge_t     *f1ResetAck = NULLP;
9439    asn_enc_rval_t         encRetVal;
9440    DU_LOG("\nINFO  -->  F1AP : Building F1 Reset Acknowledgment \n");
9441
9442    do{
9443       /* Allocate the memory for F1ResetRequest_t */
9444       CU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
9445       if(f1apMsg == NULLP)
9446       {
9447          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
9448          break;
9449       }
9450
9451       f1apMsg->present =  F1AP_PDU_PR_successfulOutcome;
9452
9453       CU_ALLOC(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
9454       if(f1apMsg->choice.successfulOutcome == NULLP)
9455       {
9456          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
9457          break;
9458       }
9459
9460       f1apMsg->choice.successfulOutcome->procedureCode = ProcedureCode_id_Reset;
9461       f1apMsg->choice.successfulOutcome->criticality   = Criticality_reject;
9462       f1apMsg->choice.successfulOutcome->value.present = SuccessfulOutcome__value_PR_ResetAcknowledge;
9463       f1ResetAck = &f1apMsg->choice.successfulOutcome->value.choice.ResetAcknowledge;
9464
9465       elementCnt = 1;
9466
9467       f1ResetAck->protocolIEs.list.count = elementCnt;
9468       f1ResetAck->protocolIEs.list.size = elementCnt*sizeof(ResetAcknowledgeIEs_t *);
9469
9470       CU_ALLOC(f1ResetAck->protocolIEs.list.array, f1ResetAck->protocolIEs.list.size );
9471       if(f1ResetAck->protocolIEs.list.array == NULLP)
9472       {
9473          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1ResetAckIEs failed");
9474          break;
9475       }
9476
9477       for(idx=0; idx<elementCnt; idx++)
9478       {
9479          CU_ALLOC(f1ResetAck->protocolIEs.list.array[idx], sizeof(ResetAcknowledgeIEs_t));
9480          if(f1ResetAck->protocolIEs.list.array[idx] == NULLP)
9481          {
9482             break;
9483          }
9484       }
9485       /*TransactionID*/
9486       idx = 0;
9487       f1ResetAck->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_TransactionID;
9488       f1ResetAck->protocolIEs.list.array[idx]->criticality = Criticality_reject;
9489       f1ResetAck->protocolIEs.list.array[idx]->value.present = ResetAcknowledgeIEs__value_PR_TransactionID;
9490       f1ResetAck->protocolIEs.list.array[idx]->value.choice.TransactionID = TRANS_ID;
9491
9492       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
9493
9494       /* Encode the F1SetupRequest type as UPER */
9495       memset(encBuf, 0, ENC_BUF_MAX_LEN);
9496       encBufSize = 0;
9497       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
9498
9499       /* Check encode results */
9500       if(encRetVal.encoded == ENCODE_FAIL)
9501       {
9502          DU_LOG("\nERROR  -->  F1AP : Could not encode F1ResetAck structure (at %s)\n",\
9503                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
9504          break;
9505       }
9506       else
9507       {
9508          DU_LOG("\nDEBUG  -->  F1AP : Created APER encodedbuffer for F1ResetAck \n");
9509          for(int i=0; i< encBufSize; i++)
9510          {
9511             DU_LOG("%x",encBuf[i]);
9512          }
9513       }
9514
9515       /* Sending msg */
9516       /* TODO : Hardcoding DU ID to 1 for messages other than F1 Setup Response. This will be made generic in future gerrit */
9517       if(SendF1APMsg(CU_APP_MEM_REG, CU_POOL, DU_ID) != ROK)
9518       {
9519          DU_LOG("\nERROR  -->  F1AP : Sending F1 Reset Response failed");
9520          break;
9521       }
9522
9523       ret = ROK;
9524       break;
9525    }while(true);
9526
9527    FreeF1ResetAck(f1apMsg);
9528    return ret;
9529 }
9530
9531 void FreeUlTnlInfoforDrb2(ULUPTNLInformation_ToBeSetup_List_t *ulInfo)
9532 {
9533    uint8_t arrIdx =0;
9534
9535    if(ulInfo->list.array)
9536    {
9537       for(arrIdx=0; arrIdx<ulInfo->list.count ; arrIdx++)
9538       {
9539          if(ulInfo->list.array[arrIdx])
9540          {
9541             if(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel )
9542             {
9543                if(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf)
9544                {
9545                   if(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf)
9546                   {
9547                      CU_FREE(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
9548                      gTP_TEID.buf,ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.\
9549                      gTPTunnel->gTP_TEID.size);
9550                   }
9551                   CU_FREE(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
9552                   transportLayerAddress.buf,ulInfo->list.array[arrIdx]->\
9553                   uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.size);
9554                }
9555                CU_FREE(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel,\
9556                sizeof(GTPTunnel_t));
9557             }
9558             CU_FREE(ulInfo->list.array[arrIdx],sizeof(ULUPTNLInformation_ToBeSetup_Item_t));
9559          }
9560       }
9561       CU_FREE(ulInfo->list.array,ulInfo->list.size);
9562    }
9563 }
9564
9565 /*******************************************************************
9566 *
9567 * @brief Deletes the EGTP tunnel
9568 *
9569 * @details
9570 *
9571 *    Function : deleteEgtpTunnel
9572 *
9573 *    Functionality: Deletes the EGTP tunnel
9574 *
9575 * @params[in] uint8_t *buf
9576 *
9577 * @return ROK     - success
9578 *         RFAILED - failure
9579 *
9580 * ****************************************************************/
9581 uint8_t deleteEgtpTunnel(uint8_t *buf)
9582 {
9583    uint32_t teId = 0;
9584    EgtpTnlEvt tnlEvt;
9585
9586    teIdStringToInt(buf, &teId);
9587    if(teId > MAX_TEID || teId < MIN_TEID)
9588    {
9589       DU_LOG("\nERROR  -->  EGTP : TEID(%d) OUT Of Range", teId);
9590       return RFAILED;
9591    }
9592    memset(&tnlEvt, 0, sizeof(EgtpTnlEvt));
9593    tnlEvt.action = EGTP_TNL_MGMT_DEL;
9594    tnlEvt.lclTeid = teId;
9595    tnlEvt.remTeid = teId;
9596    if((cuEgtpTnlMgmtReq(tnlEvt)) != ROK)
9597    {
9598       DU_LOG("\nERROR  -->  EGTP : Failed to delete tunnel Id %d", teId);
9599    }
9600    return ROK;
9601 }
9602
9603 /*******************************************************************
9604 *
9605 * @brief Builds the Uplink Tunnel Info
9606 *
9607 * @details
9608 *
9609 *    Function : BuildUlTnlInfoforSetupMod
9610 *
9611 *    Functionality: Constructs the UL TnlInfo For DRB list
9612 *
9613 * @params[in] ULUPTNLInformation_ToBeSetup_List_t *ulInfo
9614 *
9615 * @return ROK     - success
9616 *         RFAILED - failure
9617 *
9618 * ****************************************************************/
9619 uint8_t BuildUlTnlInfoforSetupMod(uint8_t ueId, uint8_t drbId, TnlInfo *ulTnlInfo, ULUPTNLInformation_ToBeSetup_List_t *ulInfo, uint8_t actionType)
9620 {
9621    uint8_t arrIdx;
9622    uint8_t ulCnt;
9623
9624    ulCnt = 1;
9625    ulInfo->list.count = ulCnt;
9626    ulInfo->list.size = ulCnt * sizeof(ULUPTNLInformation_ToBeSetup_Item_t *);
9627    CU_ALLOC(ulInfo->list.array,ulInfo->list.size);
9628    if(ulInfo->list.array == NULLP)
9629    {
9630       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildUlTnlInfoforSetupMod");
9631       return RFAILED;
9632    }
9633    for(arrIdx=0; arrIdx<ulCnt; arrIdx++)
9634    {
9635       CU_ALLOC(ulInfo->list.array[arrIdx],sizeof(ULUPTNLInformation_ToBeSetup_Item_t));
9636       if(ulInfo->list.array[arrIdx] == NULLP)
9637       {
9638          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildUlTnlInfoforSetupMod");
9639          return RFAILED;
9640       }
9641    }
9642
9643    arrIdx = 0;
9644    ulInfo->list.array[arrIdx]->uLUPTNLInformation.present = \
9645    UPTransportLayerInformation_PR_gTPTunnel;
9646
9647    /*GTP TUNNEL*/
9648    CU_ALLOC(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel,\
9649          sizeof(GTPTunnel_t));
9650    if(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel == NULLP)
9651    {
9652       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildUlTnlInfoforSetupMod");
9653       return RFAILED;
9654    }
9655    ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
9656       transportLayerAddress.size        = 4*sizeof(uint8_t);
9657    CU_ALLOC(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
9658          transportLayerAddress.buf,ulInfo->list.array[arrIdx]->\
9659          uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.size);
9660    if(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
9661          transportLayerAddress.buf == NULLP)
9662    {
9663       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildUlTnlInfoforSetupMod");
9664       return RFAILED;
9665    }
9666
9667    ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
9668       transportLayerAddress.buf[0] = 192;
9669    ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
9670       transportLayerAddress.buf[1] = 168;
9671    ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
9672       transportLayerAddress.buf[2] = 130;
9673    ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
9674       transportLayerAddress.buf[3] = 82;
9675    ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
9676       transportLayerAddress.bits_unused = 0;
9677
9678    ulTnlInfo->address[0] = ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[0];
9679    ulTnlInfo->address[1] = ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[1];
9680    ulTnlInfo->address[2] = ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[2];
9681    ulTnlInfo->address[3] = ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[3];
9682
9683    /*GTP TEID*/
9684    ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.size\
9685       = 4 * sizeof(uint8_t);
9686    CU_ALLOC(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
9687          gTP_TEID.buf,ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.\
9688          gTPTunnel->gTP_TEID.size);
9689    if(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf\
9690          == NULLP)
9691    {
9692       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildUlTnlInfoforSetupMod");
9693       return RFAILED;
9694    }
9695    ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
9696       gTP_TEID.buf[0] = 0;
9697    ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
9698       gTP_TEID.buf[1] = 0;
9699    ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
9700       gTP_TEID.buf[2] = 0;
9701    if(actionType == ProtocolIE_ID_id_DRBs_ToBeModified_Item)
9702    {
9703      /*TODO: DRB context to be stored in CU STUB so that tunnel Id can be easily
9704       * fetched based on the Drb Id */
9705
9706      /*For For UE Id=1, DRB=2 is modified. For UE Id = 2, DRB=5 is modified and so on.*/
9707       ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[3]=\
9708                                                         (MAX_NUM_DRB_ADDED_PER_UE *(ueId  - 1)) + drbId;
9709    }
9710    else
9711    {
9712       ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
9713         gTP_TEID.buf[3] = cuCb.cuCfgParams.egtpParams.currTunnelId++;
9714    }
9715
9716    ulTnlInfo->teId[0] = ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[0];
9717    ulTnlInfo->teId[1] = ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[1];
9718    ulTnlInfo->teId[2] = ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[2];
9719    ulTnlInfo->teId[3] = ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[3];
9720    return ROK;
9721 }/*End of BuildULTnlInfo*/
9722
9723 /*******************************************************************
9724 *
9725 * @brief freeing the DRB item
9726 *
9727 * @details
9728 *
9729 *    Function : FreeDrbItem
9730 *
9731 *    Functionality: freeing the DRB item
9732 *
9733 * @params[in] DRBs_ToBeSetupMod_Item_t *drbItem
9734 *
9735 * @return ROK     - success
9736 *         RFAILED - failure
9737 *
9738 * ****************************************************************/
9739
9740 void FreeDrbItem(DRBs_ToBeSetupMod_Item_t *drbItem)
9741 {
9742    uint8_t arrIdx =0;
9743    SNSSAI_t *snssai =NULLP;
9744    Flows_Mapped_To_DRB_List_t *flowMap = NULLP;
9745
9746    drbItem->qoSInformation.present = QoSInformation_PR_choice_extension;
9747    switch(drbItem->qoSInformation.present)
9748    {
9749       case QoSInformation_PR_NOTHING:
9750          break;
9751       case QoSInformation_PR_eUTRANQoS:
9752          {
9753             if(drbItem->qoSInformation.choice.eUTRANQoS)
9754             {
9755                CU_FREE(drbItem->qoSInformation.choice.eUTRANQoS, sizeof(EUTRANQoS_t));
9756             }
9757             break;
9758          }
9759       case QoSInformation_PR_choice_extension:
9760          {
9761             if(drbItem->qoSInformation.choice.choice_extension)
9762             {
9763                FreeQOSInfo(&drbItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS);
9764
9765                snssai = &drbItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI;
9766                if(snssai->sST.buf)
9767                {
9768                   CU_FREE(snssai->sST.buf,snssai->sST.size);
9769                }
9770                if(snssai->sD)
9771                {
9772                   if(snssai->sD->buf)
9773                   {
9774                      CU_FREE(snssai->sD->buf,snssai->sD->size);
9775                   }
9776                   CU_FREE(snssai->sD,sizeof(OCTET_STRING_t));
9777                }
9778
9779                flowMap = &drbItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.flows_Mapped_To_DRB_List;
9780                if(flowMap->list.array)
9781                {
9782                   for(arrIdx=0; arrIdx<flowMap->list.count; arrIdx++)
9783                   {
9784                      if(flowMap->list.array[arrIdx] )
9785                      {
9786                         FreeQOSInfo(&flowMap->list.array[arrIdx]->qoSFlowLevelQoSParameters);
9787                         CU_FREE(flowMap->list.array[arrIdx],sizeof(Flows_Mapped_To_DRB_Item_t));
9788                      }
9789                   }
9790                   CU_FREE(flowMap->list.array,flowMap->list.size);
9791                }
9792
9793                CU_FREE(drbItem->qoSInformation.choice.choice_extension,sizeof(QoSInformation_ExtIEs_t));
9794             }
9795             break;
9796          }
9797
9798    }
9799    FreeUlTnlInfoforDrb2(&drbItem->uLUPTNLInformation_ToBeSetup_List);
9800    if(drbItem->uLConfiguration)
9801    {
9802       CU_FREE(drbItem->uLConfiguration,sizeof(ULConfiguration_t));
9803    }
9804 }
9805
9806 /*******************************************************************
9807 *
9808 * @brief filling the DRB setup Mod item
9809 *
9810 * @details
9811 *
9812 *    Function : FillDrbItemToSetupMod
9813 *
9814 *    Functionality: filling the DRB setup Mod item
9815 *
9816 *
9817 * @params[in] DRBs_ToBeSetupMod_Item_t *drbItem
9818 *
9819 * @return ROK     - success
9820 *         RFAILED - failure
9821 *
9822 * ****************************************************************/
9823
9824 uint8_t FillDrbItemToSetupMod(CuUeCb *ueCb, uint8_t arrIdx, DRBs_ToBeSetupMod_Item_t *drbItem)
9825 {
9826    uint8_t ret = ROK;
9827
9828    /*Drb Id */
9829    drbItem->dRBID = arrIdx + DRB_ID_TO_ADD_MOD;
9830    ueCb->drbList[ueCb->numDrb].drbId = drbItem->dRBID;
9831
9832    /*qoSInformation*/
9833    drbItem->qoSInformation.present = QoSInformation_PR_choice_extension;
9834
9835    switch(drbItem->qoSInformation.present)
9836    {
9837       case QoSInformation_PR_NOTHING:
9838       {
9839          break;
9840       }
9841       case QoSInformation_PR_eUTRANQoS:
9842       {
9843
9844          CU_ALLOC(drbItem->qoSInformation.choice.eUTRANQoS, sizeof(EUTRANQoS_t));
9845          if(drbItem->qoSInformation.choice.eUTRANQoS)
9846          {
9847             DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in FillDrbItemToSetupMod");
9848             return RFAILED;
9849          }
9850          drbItem->qoSInformation.choice.eUTRANQoS->qCI = QCI;
9851          drbItem->qoSInformation.choice.eUTRANQoS->allocationAndRetentionPriority.priorityLevel =
9852             PriorityLevel_no_priority;
9853
9854          drbItem->qoSInformation.choice.eUTRANQoS->allocationAndRetentionPriority.pre_emptionCapability =
9855             Pre_emptionCapability_may_trigger_pre_emption;
9856
9857          drbItem->qoSInformation.choice.eUTRANQoS->allocationAndRetentionPriority.pre_emptionVulnerability =
9858             Pre_emptionVulnerability_pre_emptable;
9859
9860          break;
9861       }
9862       case QoSInformation_PR_choice_extension:
9863       {
9864          CU_ALLOC(drbItem->qoSInformation.choice.choice_extension,sizeof(QoSInformation_ExtIEs_t));
9865          if(drbItem->qoSInformation.choice.choice_extension == NULLP)
9866          {
9867             DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in FillDrbItemToSetupMod");
9868             return RFAILED;
9869          }
9870
9871          drbItem->qoSInformation.choice.choice_extension->id = ProtocolIE_ID_id_DRB_Information;
9872          drbItem->qoSInformation.choice.choice_extension->criticality = Criticality_ignore;
9873          drbItem->qoSInformation.choice.choice_extension->value.present = QoSInformation_ExtIEs__value_PR_DRB_Information;
9874          ret =  BuildQOSInfo(&ueCb->drbList[ueCb->numDrb].qos, &drbItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS,\
9875            ProtocolIE_ID_id_DRBs_ToBeSetupMod_Item, PDU_SESSION_ID_2, FALSE);
9876          if(ret != ROK)
9877          {
9878             DU_LOG("\nERROR  -->  F1AP : BuildQOSInfo failed");
9879             return RFAILED;
9880          }
9881
9882          /*SNSSAI*/
9883          ret = BuildSNSSAI(&ueCb->drbList[ueCb->numDrb], &drbItem->qoSInformation.choice.\
9884                choice_extension->value.choice.DRB_Information.sNSSAI, cuCb.snssaiList[1], FALSE);
9885          if(ret != ROK)
9886          {
9887             DU_LOG("\nERROR  -->  F1AP : BuildSNSSAI failed");
9888             return RFAILED;
9889          }
9890
9891          /*Flows mapped to DRB List*/
9892          ret = BuildFlowsMap(&ueCb->drbList[ueCb->numDrb], &drbItem->qoSInformation.choice.\
9893                choice_extension->value.choice.DRB_Information.flows_Mapped_To_DRB_List,\
9894           ProtocolIE_ID_id_DRBs_ToBeSetupMod_Item, FALSE);
9895          if(ret != ROK)
9896          {
9897             DU_LOG("\nERROR  -->  F1AP : BuildFlowsMap failed");
9898             return RFAILED;
9899          }
9900       }
9901    }
9902
9903    /*ULUPTNLInformation To Be Setup List*/
9904    ret = BuildUlTnlInfoforSetupMod(ueCb->gnbCuUeF1apId, drbItem->dRBID, &ueCb->drbList[ueCb->numDrb].ulUpTnlInfo, \
9905       &drbItem->uLUPTNLInformation_ToBeSetup_List, ProtocolIE_ID_id_DRBs_ToBeSetupMod_Item);
9906    if(ret != ROK)
9907    {
9908       DU_LOG("\nERROR  -->  F1AP : BuildUlTnlInfoforSetupMod failed");
9909       return RFAILED;
9910    }
9911
9912    /*RLCMode*/
9913    drbItem->rLCMode = RLCMode_rlc_um_bidirectional;
9914    ueCb->drbList[ueCb->numDrb].rlcMode = drbItem->rLCMode;
9915
9916    ueCb->numDrb++;
9917    return ROK;
9918 }
9919
9920 /*******************************************************************
9921 *
9922 * @brief Builds the DRB to be Setup Mod ItemIes
9923 *
9924 * @details
9925 *
9926 *    Function : FillDrbItemList
9927 *
9928 *    Functionality: Constructs the DRB to be Setup Mod Item Ies
9929 *
9930 * @params[in] struct DRBs_ToBeSetupMod_ItemIEs *drbItemIe
9931 *
9932 * @return ROK     - success
9933 *         RFAILED - failure
9934 *
9935 * ****************************************************************/
9936
9937 uint8_t FillDrbItemList(CuUeCb *ueCb, uint8_t arrIdx, struct DRBs_ToBeSetupMod_ItemIEs *drbItemIe)
9938 {
9939    drbItemIe->id = ProtocolIE_ID_id_DRBs_ToBeSetupMod_Item;
9940    drbItemIe->criticality = Criticality_reject;
9941    drbItemIe->value.present = DRBs_ToBeSetupMod_ItemIEs__value_PR_DRBs_ToBeSetupMod_Item;
9942
9943    if(FillDrbItemToSetupMod(ueCb, arrIdx, (&(drbItemIe->value.choice.DRBs_ToBeSetupMod_Item))) != ROK)
9944    {
9945       DU_LOG("\nERROR  -->  F1AP : FillDrbItemToSetupMod failed");
9946       return RFAILED;
9947    }
9948    return ROK;
9949 }
9950 /*******************************************************************
9951 *
9952 * @brief free the DRB to be Setup Mod list
9953 *
9954 * @details
9955 *
9956 *    Function : FreeDrbToBeSetupModList
9957 *
9958 *    Functionality: free the DRB to be Setup Mod list
9959 *
9960 * @params[in] DRBs_ToBeSetupMod_List_t *drbSet
9961 *
9962 * @return ROK     - success
9963 *         RFAILED - failure
9964 *
9965 * ****************************************************************/
9966 void FreeDrbToBeSetupModList(DRBs_ToBeSetupMod_List_t *drbSet)
9967 {
9968    uint8_t arrIdx =0;
9969    struct DRBs_ToBeSetupMod_ItemIEs *drbItemIe;
9970
9971    if(drbSet->list.array)
9972    {
9973       for(arrIdx=0; arrIdx<drbSet->list.count ; arrIdx++)
9974       {
9975          if(drbSet->list.array[arrIdx] != NULLP)
9976          {
9977             if(arrIdx == 0)
9978             {
9979                drbItemIe = (DRBs_ToBeSetupMod_ItemIEs_t *)drbSet->list.array[arrIdx];
9980                FreeDrbItem(&(drbItemIe->value.choice.DRBs_ToBeSetupMod_Item));
9981             }
9982             CU_FREE(drbSet->list.array[arrIdx], sizeof(DRBs_ToBeSetupMod_ItemIEs_t));
9983          }
9984       }
9985       CU_FREE(drbSet->list.array, drbSet->list.size);
9986    }
9987
9988 }
9989
9990 /*******************************************************************
9991 *
9992 * @brief Builds the DRB to be Setup Mod list
9993 *
9994 * @details
9995 *
9996 *    Function : BuildDrbToBeSetupList
9997 *
9998 *    Functionality: Constructs the DRB to be Setup Mod list
9999 *
10000 * @params[in] DRBs_ToBeSetupMod_List_t *drbSet
10001 *
10002 * @return ROK     - success
10003 *         RFAILED - failure
10004 *
10005 * ****************************************************************/
10006
10007 uint8_t BuildDrbToBeSetupList(CuUeCb *ueCb, DRBs_ToBeSetupMod_List_t *drbSet)
10008 {
10009    uint8_t ret = ROK;
10010    uint8_t arrIdx =0;
10011    uint8_t drbCnt =0;
10012
10013    drbCnt = MAX_DRB_SET_UE_CONTEXT_MOD_REQ;
10014    drbSet->list.count = drbCnt;
10015    drbSet->list.size = drbCnt * sizeof(DRBs_ToBeSetupMod_ItemIEs_t *);
10016    CU_ALLOC(drbSet->list.array, drbSet->list.size);
10017    if(drbSet->list.array == NULLP)
10018    {
10019       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDrbToBeSetupList");
10020       return  RFAILED;
10021    }
10022
10023    for(arrIdx=0; arrIdx<drbCnt; arrIdx++)
10024    {
10025       CU_ALLOC(drbSet->list.array[arrIdx], sizeof(DRBs_ToBeSetupMod_ItemIEs_t));
10026       if(drbSet->list.array[arrIdx] == NULLP)
10027       {
10028          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDrbToBeSetupList for array idx [%d]", arrIdx);
10029          return  RFAILED;
10030       }
10031
10032       ret = FillDrbItemList(ueCb, arrIdx, (DRBs_ToBeSetupMod_ItemIEs_t *)drbSet->list.array[arrIdx]);
10033       if(ret != ROK)
10034       {
10035          DU_LOG("\nERROR  -->  F1AP : FillDrbItemList failed");
10036       }
10037    }
10038
10039    return ret;
10040 }
10041
10042 /*******************************************************************
10043 *
10044 * @brief Filling the DRB to be modified item
10045 *
10046 * @details
10047 *
10048 *    Function : FillDrbToBeModItem
10049 *
10050 *    Functionality: filling the DRB to be modified item
10051 *
10052 * @params[in] DRBs_ToBeModified_Item_t *drbItem
10053 *
10054 * @return ROK     - success
10055 *         RFAILED - failure
10056 *
10057 * ****************************************************************/
10058
10059 uint8_t FillDrbToBeModItem(CuUeCb *ueCb, uint8_t arrIdx, DRBs_ToBeModified_Item_t *drbItem)
10060 {
10061    uint8_t ret = ROK;
10062    uint drbIdx=0;
10063    DrbInfo *drbToBeMod;
10064
10065    /*Drb Id */
10066    drbItem->dRBID = DRB2 + arrIdx;
10067
10068    /* Search for DRB ID in CU databse */
10069    for(drbIdx = 0; drbIdx < ueCb->numDrb; drbIdx++)
10070    {
10071       if(ueCb->drbList[drbIdx].drbId == drbItem->dRBID)
10072       {
10073          drbToBeMod = &ueCb->drbList[drbIdx];
10074          break;
10075       }
10076    }
10077
10078    /*qoSInformation*/
10079    drbItem->qoSInformation = NULLP;
10080    CU_ALLOC(drbItem->qoSInformation, sizeof(QoSInformation_t));
10081    if(drbItem->qoSInformation != NULLP)
10082    {
10083       drbItem->qoSInformation->present = QoSInformation_PR_choice_extension;
10084
10085       switch(drbItem->qoSInformation->present)
10086       {
10087          case QoSInformation_PR_NOTHING:
10088             {
10089                break;
10090             }
10091          case QoSInformation_PR_eUTRANQoS:
10092             {
10093
10094                CU_ALLOC(drbItem->qoSInformation->choice.eUTRANQoS, sizeof(EUTRANQoS_t));
10095                if(drbItem->qoSInformation->choice.eUTRANQoS)
10096                {
10097                   DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in FillDrbToBeModItem");
10098                   return RFAILED;
10099                }
10100                drbItem->qoSInformation->choice.eUTRANQoS->qCI = QCI;
10101                drbItem->qoSInformation->choice.eUTRANQoS->allocationAndRetentionPriority.priorityLevel =
10102                   PriorityLevel_no_priority;
10103
10104                drbItem->qoSInformation->choice.eUTRANQoS->allocationAndRetentionPriority.pre_emptionCapability =
10105                   Pre_emptionCapability_may_trigger_pre_emption;
10106
10107                drbItem->qoSInformation->choice.eUTRANQoS->allocationAndRetentionPriority.pre_emptionVulnerability =
10108                   Pre_emptionVulnerability_pre_emptable;
10109
10110                break;
10111             }
10112          case QoSInformation_PR_choice_extension:
10113             {
10114                CU_ALLOC(drbItem->qoSInformation->choice.choice_extension,sizeof(QoSInformation_ExtIEs_t));
10115                if(drbItem->qoSInformation->choice.choice_extension == NULLP)
10116                {
10117                   DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in FillDrbItemToSetupMod");
10118                   return RFAILED;
10119                }
10120
10121                drbItem->qoSInformation->choice.choice_extension->id = ProtocolIE_ID_id_DRB_Information;
10122                drbItem->qoSInformation->choice.choice_extension->criticality = Criticality_ignore;
10123                drbItem->qoSInformation->choice.choice_extension->value.present = QoSInformation_ExtIEs__value_PR_DRB_Information;
10124                ret =  BuildQOSInfo(&drbToBeMod->qos, &drbItem->qoSInformation->choice.choice_extension->value.choice.DRB_Information.dRB_QoS,\
10125                      ProtocolIE_ID_id_DRBs_ToBeModified_Item, INVALID_PDU_SESSION_ID, FALSE);
10126                if(ret != ROK)
10127                {
10128                   DU_LOG("\nERROR  -->  F1AP : BuildQOSInfo failed");
10129                   return RFAILED;
10130                }
10131
10132                /*SNSSAI*/
10133                ret = BuildSNSSAI(drbToBeMod, &drbItem->qoSInformation->choice.\
10134                      choice_extension->value.choice.DRB_Information.sNSSAI, cuCb.snssaiList[0], FALSE);
10135                if(ret != ROK)
10136                {
10137                   DU_LOG("\nERROR  -->  F1AP : BuildSNSSAI failed");
10138                   return RFAILED;
10139                }
10140
10141                /*Flows mapped to DRB List*/
10142                ret = BuildFlowsMap(drbToBeMod, &drbItem->qoSInformation->choice.\
10143                      choice_extension->value.choice.DRB_Information.flows_Mapped_To_DRB_List,\
10144                      ProtocolIE_ID_id_DRBs_ToBeModified_Item, FALSE);
10145                if(ret != ROK)
10146                {
10147                   DU_LOG("\nERROR  -->  F1AP : BuildFlowsMap failed");
10148                   return RFAILED;
10149                }
10150             }
10151       }
10152    }/* End of QoS */
10153
10154    /*ULUPTNLInformation To Be Setup List*/
10155    ret = BuildUlTnlInfoforSetupMod(ueCb->gnbCuUeF1apId, drbItem->dRBID, &drbToBeMod->ulUpTnlInfo, &drbItem->uLUPTNLInformation_ToBeSetup_List,\
10156             ProtocolIE_ID_id_DRBs_ToBeModified_Item);
10157    if(ret != ROK)
10158    {
10159       DU_LOG("\nERROR  -->  F1AP : BuildUlTnlInfoforSetupMod failed");
10160       return RFAILED;
10161    }
10162    return ROK;
10163 }
10164
10165 /*******************************************************************
10166 *
10167 * @brief Builds the DRB to be modified Item IE
10168 *
10169 * @details
10170 *
10171 *    Function : FillDrbToBeModItemList
10172 *
10173 *    Functionality: Constructs the DRB to be modified Mod Item Ies
10174 *
10175 * @params[in] struct DRBs_ToBeModified_ItemIEs *drbItemIe
10176 *
10177 * @return ROK     - success
10178 *         RFAILED - failure
10179 *
10180 * ****************************************************************/
10181
10182 uint8_t FillDrbToBeModItemList(CuUeCb *ueCb, uint8_t arrIdx, struct DRBs_ToBeModified_ItemIEs *drbItemIe)
10183 {
10184    drbItemIe->id = ProtocolIE_ID_id_DRBs_ToBeModified_Item;
10185    drbItemIe->criticality = Criticality_reject;
10186    drbItemIe->value.present = DRBs_ToBeModified_ItemIEs__value_PR_DRBs_ToBeModified_Item;
10187    if(FillDrbToBeModItem(ueCb, arrIdx, &(drbItemIe->value.choice.DRBs_ToBeModified_Item)) != ROK)
10188    {
10189       DU_LOG("\nERROR  -->  F1AP : FillDrbToBeModItem failed");
10190       return RFAILED;
10191    }
10192
10193    return ROK;
10194 }
10195
10196 /*******************************************************************
10197 *
10198 * @brief Builds the DRB to be modified list
10199 *
10200 * @details
10201 *
10202 *    Function : BuildDrbToBeModList
10203 *
10204 *    Functionality: Constructs the DRB to be modified list
10205 *
10206 * @params[in] DRBs_ToBeModified_List_t *drbSet
10207 *
10208 * @return ROK     - success
10209 *         RFAILED - failure
10210 *
10211 * ****************************************************************/
10212
10213 uint8_t BuildDrbToBeModifiedList(CuUeCb *ueCb, DRBs_ToBeModified_List_t *drbSet)
10214 {
10215    uint8_t ret = ROK;
10216    uint8_t arrIdx =0;
10217    uint8_t drbCnt =0;
10218
10219    drbCnt = MAX_DRB_MODIFIED_UE_MOD_REQ;
10220    drbSet->list.count = drbCnt;
10221    drbSet->list.size = drbCnt * sizeof(DRBs_ToBeModified_ItemIEs_t *);
10222    CU_ALLOC(drbSet->list.array, drbSet->list.size);
10223    if(drbSet->list.array == NULLP)
10224    {
10225       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDrbToBeModifiedList");
10226       return  RFAILED;
10227    }
10228    for(arrIdx=0; arrIdx<drbCnt; arrIdx++)
10229    {
10230       CU_ALLOC(drbSet->list.array[arrIdx], sizeof(DRBs_ToBeModified_ItemIEs_t));
10231       if(drbSet->list.array[arrIdx] == NULLP)
10232       {
10233          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDrbToBeSetupList");
10234          return  RFAILED;
10235       }
10236
10237       ret = FillDrbToBeModItemList(ueCb, arrIdx, (DRBs_ToBeModified_ItemIEs_t *)drbSet->list.array[arrIdx]);
10238       if(ret != ROK)
10239       {
10240          DU_LOG("\nERROR  -->  F1AP : FillDrbToBeModItemList failed");
10241       }
10242    }
10243
10244    return ret;
10245 }
10246
10247 /*******************************************************************
10248 *
10249 * @brief freeing the DRB  item
10250 *
10251 * @details
10252 *
10253 *    Function : FreeModifiedDrbItem
10254 *
10255 *    Functionality: freeing the DRB 2 item
10256 *
10257 * @params[in] DRBs_ToBeSetupMod_Item_t *drbItem
10258 *
10259 * @return ROK     - success
10260 *         RFAILED - failure
10261 *
10262 * ****************************************************************/
10263
10264 void FreeModifiedDrbItem(DRBs_ToBeModified_Item_t *drbItem)
10265 {
10266    uint8_t arrIdx =0;
10267    SNSSAI_t *snssai =NULLP;
10268    Flows_Mapped_To_DRB_List_t *flowMap = NULLP;
10269
10270    if(drbItem->qoSInformation != NULLP)
10271    {
10272       switch(drbItem->qoSInformation->present)
10273       {
10274          case QoSInformation_PR_NOTHING:
10275             break;
10276          case QoSInformation_PR_eUTRANQoS:
10277             {
10278                if(drbItem->qoSInformation->choice.eUTRANQoS)
10279                {
10280                   CU_FREE(drbItem->qoSInformation->choice.eUTRANQoS, sizeof(EUTRANQoS_t));
10281                }
10282                break;
10283             }
10284          case QoSInformation_PR_choice_extension:
10285             {
10286                if(drbItem->qoSInformation->choice.choice_extension)
10287                {
10288                   FreeQOSInfo(&drbItem->qoSInformation->choice.choice_extension->value.choice.DRB_Information.dRB_QoS);
10289
10290                   snssai = &drbItem->qoSInformation->choice.choice_extension->value.choice.DRB_Information.sNSSAI;
10291                   if(snssai->sST.buf)
10292                   {
10293                      CU_FREE(snssai->sST.buf,snssai->sST.size);
10294                   }
10295                   if(snssai->sD)
10296                   {
10297                      if(snssai->sD->buf)
10298                      {
10299                         CU_FREE(snssai->sD->buf,snssai->sD->size);
10300                      }
10301                      CU_FREE(snssai->sD,sizeof(OCTET_STRING_t));
10302                   }
10303
10304                   flowMap = &drbItem->qoSInformation->choice.choice_extension->value.choice.DRB_Information.flows_Mapped_To_DRB_List;
10305                   if(flowMap->list.array)
10306                   {
10307                      for(arrIdx=0; arrIdx<flowMap->list.count; arrIdx++)
10308                      {
10309                         if(flowMap->list.array[arrIdx] )
10310                         {
10311                            FreeQOSInfo(&flowMap->list.array[arrIdx]->qoSFlowLevelQoSParameters);
10312                            CU_FREE(flowMap->list.array[arrIdx],sizeof(Flows_Mapped_To_DRB_Item_t));
10313                         }
10314                      }
10315                      CU_FREE(flowMap->list.array,flowMap->list.size);
10316                   }
10317
10318                   CU_FREE(drbItem->qoSInformation->choice.choice_extension,sizeof(QoSInformation_ExtIEs_t));
10319                }
10320                break;
10321             }
10322       }
10323    }
10324    FreeUlTnlInfoforDrb2(&drbItem->uLUPTNLInformation_ToBeSetup_List);
10325    if(drbItem->uLConfiguration)
10326    {
10327       CU_FREE(drbItem->uLConfiguration,sizeof(ULConfiguration_t));
10328    }
10329 }
10330
10331 /*******************************************************************
10332 *
10333 * @brief free the DRB to be modfified list
10334 *
10335 * @details
10336 *
10337 *    Function : FreeDrbToBeModifiedList
10338 *
10339 *    Functionality: free the DRB to be Setup Mod list
10340 *
10341 * @params[in] FreeDrbToBeModifiedList_t *drbSet
10342 *
10343 * @return ROK     - success
10344 *         RFAILED - failure
10345 *
10346 * ****************************************************************/
10347 void FreeDrbToBeModifiedList(DRBs_ToBeModified_List_t *drbSet)
10348 {
10349    uint8_t arrIdx =0;
10350    struct DRBs_ToBeModified_ItemIEs *drbItemIe;
10351
10352    if(drbSet->list.array)
10353    {
10354       for(arrIdx=0; arrIdx<drbSet->list.count ; arrIdx++)
10355       {
10356          if(drbSet->list.array[arrIdx] != NULLP)
10357          {
10358             drbItemIe = (struct DRBs_ToBeModified_ItemIEs *)drbSet->list.array[arrIdx];
10359             FreeModifiedDrbItem(&(drbItemIe->value.choice.DRBs_ToBeModified_Item));
10360             CU_FREE(drbSet->list.array[arrIdx], sizeof(DRBs_ToBeModified_ItemIEs_t));
10361          }
10362       }
10363       CU_FREE(drbSet->list.array, drbSet->list.size);
10364    }
10365
10366 }
10367
10368 /*******************************************************************
10369  *
10370  * @brief  free the UeContextModification Request
10371  *
10372  * @details
10373  *
10374  *    Function : FreeUeContextModicationRequest
10375  *
10376  *    Functionality : deallocation of memory allocated in UeContextModiification
10377  request
10378  *
10379  * @params[in] F1AP_PDU_t *f1apMsg
10380  *
10381  * @return void
10382 *
10383 * ****************************************************************/
10384 void FreeUeContextModicationRequest(F1AP_PDU_t *f1apMsg)
10385 {
10386    uint8_t arrIdx =0 , ieId=0;
10387    UEContextModificationRequest_t *UeContextModifyReq = NULLP;
10388
10389    if(f1apMsg)
10390    {
10391       if(f1apMsg->choice.initiatingMessage)
10392       {
10393          UeContextModifyReq =&f1apMsg->choice.initiatingMessage->value.choice.UEContextModificationRequest;
10394          if(UeContextModifyReq->protocolIEs.list.array)
10395          {
10396             for( arrIdx = 0 ; arrIdx<UeContextModifyReq->protocolIEs.list.count ; arrIdx++)
10397             {
10398                if(UeContextModifyReq->protocolIEs.list.array[arrIdx])
10399                {
10400                   ieId = UeContextModifyReq->protocolIEs.list.array[arrIdx]->id;
10401                   switch(ieId)
10402                   {
10403                      case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
10404                         break;
10405                      case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
10406                         break;
10407                      case ProtocolIE_ID_id_DRBs_ToBeSetupMod_List:
10408                         {
10409                            FreeDrbToBeSetupModList(&UeContextModifyReq->protocolIEs.list.array[arrIdx]->value.\
10410                                  choice.DRBs_ToBeSetupMod_List);
10411                            break;
10412                         }
10413                      case ProtocolIE_ID_id_DRBs_ToBeModified_List:
10414                         {
10415                            FreeDrbToBeModifiedList(&UeContextModifyReq->protocolIEs.list.array[arrIdx]->value.\
10416                                  choice.DRBs_ToBeSetupMod_List);
10417                            break;
10418                         }
10419
10420                   }
10421                   CU_FREE(UeContextModifyReq->protocolIEs.list.array[arrIdx], sizeof(UEContextModificationRequest_t));
10422                }
10423             }
10424             CU_FREE(UeContextModifyReq->protocolIEs.list.array, UeContextModifyReq->protocolIEs.list.size);
10425          }
10426          CU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
10427       }
10428       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
10429    }
10430 }
10431
10432 /*******************************************************************
10433  *
10434  * @brief Builds the Ue Context Modification Req
10435  *
10436  * @details
10437  *
10438  *    Function : BuildAndSendUeContextModificationReq
10439  *
10440  *    Functionality: Constructs the Ue Context Modification Req
10441  *
10442  * @params[in]
10443  *
10444  * @return ROK     - success
10445  *         RFAILED - failure
10446  *
10447  * ****************************************************************/
10448 uint8_t BuildAndSendUeContextModificationReq(uint32_t duId, void *cuUeCb, UeCtxtModAction action)
10449 {
10450    uint8_t    ieIdx = 0;
10451    uint8_t    elementCnt = 0;
10452    uint8_t    ret = RFAILED;
10453    CuUeCb     *ueCb = (CuUeCb *)cuUeCb;
10454    F1AP_PDU_t *f1apMsg = NULLP;
10455    UEContextModificationRequest_t *ueContextModifyReq = NULLP;
10456
10457    asn_enc_rval_t         encRetVal;
10458    DU_LOG("\nINFO  -->  F1AP : Building Ue context modification request\n");
10459
10460    while(1)
10461    {
10462       CU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
10463       if(f1apMsg == NULLP)
10464       {
10465          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed Ue context modification");
10466          break;
10467       }
10468
10469       f1apMsg->present =  F1AP_PDU_PR_initiatingMessage;
10470
10471       CU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
10472       if(f1apMsg->choice.initiatingMessage == NULLP)
10473       {
10474          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed Ue context modification");
10475          break;
10476       }
10477       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_UEContextModification;
10478       f1apMsg->choice.initiatingMessage->criticality = Criticality_reject;
10479       f1apMsg->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_UEContextModificationRequest;
10480
10481       ueContextModifyReq =&f1apMsg->choice.initiatingMessage->value.choice.UEContextModificationRequest;
10482
10483       if(action == MODIFY_UE)
10484          elementCnt = 4;
10485       else if(action == QUERY_CONFIG)
10486          elementCnt = 3;
10487       else if(action == RRC_RECONFIG_COMPLETE_IND)
10488          elementCnt = 3;
10489       ueContextModifyReq->protocolIEs.list.count = elementCnt;
10490       ueContextModifyReq->protocolIEs.list.size = elementCnt*sizeof(UEContextModificationRequest_t *);
10491
10492       /* Initialize the UE context modification members */
10493       CU_ALLOC(ueContextModifyReq->protocolIEs.list.array, ueContextModifyReq->protocolIEs.list.size);
10494       if(ueContextModifyReq->protocolIEs.list.array == NULLP)
10495       {
10496          DU_LOG("\nERROR  -->  F1AP : Memory allocation for UE context modifcation Request failed");
10497          break;
10498       }
10499
10500       for(ieIdx=0 ; ieIdx<elementCnt; ieIdx++)
10501       {
10502          CU_ALLOC(ueContextModifyReq->protocolIEs.list.array[ieIdx], sizeof(UEContextModificationRequest_t));
10503          if(ueContextModifyReq->protocolIEs.list.array[ieIdx] == NULLP)
10504          {
10505             DU_LOG("\nERROR  -->  F1AP : Memory allocation for UE context modifcation Request failed");
10506             break;
10507          }
10508       }
10509
10510       ieIdx=0;
10511       ueContextModifyReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
10512       ueContextModifyReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
10513       ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present = \
10514                                                                          UEContextModificationRequestIEs__value_PR_GNB_CU_UE_F1AP_ID;
10515       ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID = ueCb->gnbCuUeF1apId;
10516
10517       ieIdx++;
10518       ueContextModifyReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
10519       ueContextModifyReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
10520       ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present=\
10521                                                                        UEContextModificationRequestIEs__value_PR_GNB_DU_UE_F1AP_ID;
10522       ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID = ueCb->gnbDuUeF1apId;
10523
10524       if(action == MODIFY_UE)
10525       {
10526          /* DRB to be setup list */
10527          ieIdx++;
10528          ueContextModifyReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_DRBs_ToBeSetupMod_List;
10529          ueContextModifyReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
10530          ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present =\
10531                                                                            UEContextModificationRequestIEs__value_PR_DRBs_ToBeSetupMod_List;
10532          ret = BuildDrbToBeSetupList(ueCb, &(ueContextModifyReq->protocolIEs.list.array[ieIdx]->\
10533                   value.choice.DRBs_ToBeSetupMod_List));
10534
10535          /* DRB to be modified list */
10536          ieIdx++;
10537          ueContextModifyReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_DRBs_ToBeModified_List;
10538          ueContextModifyReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
10539          ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present =\
10540                                                                            UEContextModificationRequestIEs__value_PR_DRBs_ToBeModified_List;
10541          ret = BuildDrbToBeModifiedList(ueCb, &(ueContextModifyReq->protocolIEs.list.array[ieIdx]->\
10542                   value.choice.DRBs_ToBeModified_List));
10543
10544          /* TODO: DRB to be release list */
10545
10546          if(ret != ROK)
10547          {
10548             break;
10549          }
10550       }
10551       else if(action == QUERY_CONFIG)
10552       {
10553          ieIdx++;
10554          ueContextModifyReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_GNB_DUConfigurationQuery;
10555          ueContextModifyReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
10556          ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present = \
10557             UEContextModificationRequestIEs__value_PR_GNB_DUConfigurationQuery;
10558          ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DUConfigurationQuery = GNB_DUConfigurationQuery_true;
10559       }
10560       else if(action == RRC_RECONFIG_COMPLETE_IND)
10561       {
10562          ieIdx++;
10563          ueContextModifyReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_RRCReconfigurationCompleteIndicator;
10564          ueContextModifyReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
10565          ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present = \
10566             UEContextModificationRequestIEs__value_PR_RRCReconfigurationCompleteIndicator;
10567          ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.RRCReconfigurationCompleteIndicator = \
10568             RRCReconfigurationCompleteIndicator_true;
10569       }
10570
10571       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
10572
10573       /* Encode the F1SetupRequest type as APER */
10574       memset(encBuf, 0, ENC_BUF_MAX_LEN);
10575       encBufSize = 0;
10576       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
10577
10578       /* Encode results */
10579       if(encRetVal.encoded == ENCODE_FAIL)
10580       {
10581          DU_LOG("\nERROR  -->  F1AP : Could not encode ueContextModifyReq structure (at %s)\n",\
10582                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
10583          break;
10584       }
10585       else
10586       {
10587          DU_LOG("\nDEBUG  -->  F1AP : Created APER encodedbuffer for ueContextModifyReq\n");
10588          for(ieIdx=0; ieIdx< encBufSize; ieIdx++)
10589          {
10590             DU_LOG("%x",encBuf[ieIdx]);
10591          }
10592       }
10593
10594       /* TODO : Hardcoding DU ID to 1 for messages other than F1 Setup Response. This will be made generic in future gerrit */
10595       if(SendF1APMsg(CU_APP_MEM_REG, CU_POOL, duId) != ROK)
10596       {
10597          DU_LOG("\nERROR  -->  F1AP : Sending Ue context modification request  failed");
10598          break;
10599       }
10600
10601       ret = ROK;
10602       break;
10603
10604    }
10605    FreeUeContextModicationRequest(f1apMsg);
10606    return ret;
10607 }
10608
10609 /*****************************************************************i
10610  *
10611 * @brief Free memory allocated for UE Context Release Command
10612 *
10613 * @details
10614 *
10615 *    Function : FreeUeContextReleaseCommand
10616 *
10617 *    Functionality:
10618 *         - Free memory allocated for UE Context Release Command
10619 *
10620 * @params[in] F1AP_PDU_t *f1apMsg
10621 * @return void
10622 *
10623 * *************************************************************/
10624 void FreeUeContextReleaseCommand(F1AP_PDU_t *f1apMsg)
10625 {
10626    uint8_t ieIdx;
10627    UEContextReleaseCommand_t *ueReleaseCommand = NULLP;
10628
10629    if(f1apMsg)
10630    {
10631       if(f1apMsg->choice.initiatingMessage)
10632       {
10633          ueReleaseCommand =&f1apMsg->choice.initiatingMessage->value.choice.UEContextReleaseCommand;
10634          if(ueReleaseCommand->protocolIEs.list.array)
10635          {
10636             for(ieIdx=0 ; ieIdx<ueReleaseCommand->protocolIEs.list.count; ieIdx++)
10637             {
10638                CU_FREE(ueReleaseCommand->protocolIEs.list.array[ieIdx], sizeof(UEContextReleaseCommand_t));
10639             }
10640             CU_FREE(ueReleaseCommand->protocolIEs.list.array, ueReleaseCommand->protocolIEs.list.size);
10641          }
10642          CU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
10643       }
10644       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
10645    }
10646 }
10647 /*******************************************************************
10648  *
10649  * @brief Builds the Ue Context Release Command
10650  *
10651  * @details
10652 *
10653 *    Function : BuildAndSendUeContextReleaseCommand
10654 *
10655 *    Functionality: Constructs the Ue Context Release Command
10656 *
10657 * @params[in]
10658 *
10659 * @return ROK     - success
10660 *         RFAILED - failure
10661 *
10662 * ****************************************************************/
10663 uint8_t BuildAndSendUeContextReleaseCommand(uint32_t duId, uint8_t cuUeF1apId, uint8_t duUeF1apId)
10664 {
10665    bool       memAllocFailed = false;
10666    uint8_t  duIdx = 0, ieIdx = 0,elementCnt = 0, ret = RFAILED, bufLen=0;
10667    DuDb *duDb;
10668    CuUeCb *ueCb;
10669    F1AP_PDU_t *f1apMsg = NULLP;
10670    UEContextReleaseCommand_t *ueContextReleaseCommand = NULLP;
10671
10672    asn_enc_rval_t         encRetVal;
10673    DU_LOG("\nINFO  -->  F1AP : Building Ue context release command\n");
10674
10675    while(true)
10676    {
10677       CU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
10678       if(f1apMsg == NULLP)
10679       {
10680          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseCommand(): Memory allocation for F1AP-PDU");
10681          break;
10682       }
10683
10684       f1apMsg->present =  F1AP_PDU_PR_initiatingMessage;
10685
10686       CU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
10687       if(f1apMsg->choice.initiatingMessage == NULLP)
10688       {
10689          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseCommand(): Memory allocation for F1AP-PDU failed ");
10690          break;
10691       }
10692       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_UEContextRelease;
10693       f1apMsg->choice.initiatingMessage->criticality = Criticality_reject;
10694       f1apMsg->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_UEContextReleaseCommand;
10695
10696       ueContextReleaseCommand =&f1apMsg->choice.initiatingMessage->value.choice.UEContextReleaseCommand;
10697
10698       SEARCH_DU_DB(duIdx, duId, duDb);
10699       ueCb = &duDb->ueCb[duUeF1apId-1];
10700       if(ueCb->state == UE_HANDOVER_IN_PROGRESS)
10701          elementCnt = 3;
10702       else
10703          elementCnt = 4;
10704
10705       ueContextReleaseCommand->protocolIEs.list.count = elementCnt;
10706       ueContextReleaseCommand->protocolIEs.list.size = elementCnt*sizeof(UEContextReleaseCommand_t*);
10707
10708       /* Initialize the UE context modification members */
10709       CU_ALLOC(ueContextReleaseCommand->protocolIEs.list.array, ueContextReleaseCommand->protocolIEs.list.size);
10710       if(ueContextReleaseCommand->protocolIEs.list.array == NULLP)
10711       {
10712          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseCommand():Memory allocation failed");
10713          break;
10714       }
10715
10716       for(ieIdx=0 ; ieIdx<elementCnt; ieIdx++)
10717       {
10718          CU_ALLOC(ueContextReleaseCommand->protocolIEs.list.array[ieIdx], sizeof(UEContextReleaseCommand_t));
10719          if(ueContextReleaseCommand->protocolIEs.list.array[ieIdx] == NULLP)
10720          {
10721             DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseCommand(): Memory allocation failed ");
10722             memAllocFailed = true;
10723             break;
10724          }
10725       }
10726
10727       if(memAllocFailed == true)
10728       {
10729          break;
10730       }
10731
10732       ieIdx=0;
10733       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
10734       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
10735       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.present = \
10736       UEContextReleaseCommandIEs__value_PR_GNB_CU_UE_F1AP_ID;
10737       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID =cuUeF1apId;
10738
10739       ieIdx++;
10740       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
10741       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
10742       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.present=\
10743       UEContextReleaseCommandIEs__value_PR_GNB_DU_UE_F1AP_ID;
10744       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID =duUeF1apId;
10745
10746       /* Cause of UE context release */
10747       ieIdx++;
10748       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_Cause;
10749       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->criticality = Criticality_ignore;
10750       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.present=\
10751                                                                             UEContextReleaseCommandIEs__value_PR_Cause;
10752       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.Cause.present = Cause_PR_radioNetwork;
10753       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.Cause.choice.radioNetwork=\
10754                                                                                                      CauseRadioNetwork_normal_release;
10755       if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
10756       {
10757          /* RRC Container for RRC release */
10758          ieIdx++;
10759          ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_RRCContainer;
10760          ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->criticality = Criticality_ignore;
10761          ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.present = \
10762                                                                                  UEContextReleaseCommandIEs__value_PR_RRCContainer;
10763          char secModeBuf[7]={ 0x00, 0x05, 0x13, 0x00, 0x00, 0x00, 0x00};
10764          bufLen =7;
10765          ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.size = bufLen;
10766          CU_ALLOC(ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf,
10767                ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.size);
10768          if(!ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf)
10769          {
10770             DU_LOG("\nERROR  -->  F1AP : Memory allocation for BuildAndSendUeContextReleaseCommand failed");
10771             break;
10772          }
10773          memset(ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf, 0, bufLen);
10774          memcpy(ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf, secModeBuf, bufLen);
10775       }
10776       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
10777
10778       /* Encode the UE Context Release Command type as APER */
10779       memset(encBuf, 0, ENC_BUF_MAX_LEN);
10780       encBufSize = 0;
10781       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
10782             encBuf);
10783
10784       /* Encode results */
10785       if(encRetVal.encoded == ENCODE_FAIL)
10786       {
10787          DU_LOG("\nERROR  -->  F1AP : Could not encode Release Command structure (at %s)\n",\
10788                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
10789          break;
10790       }
10791       else
10792       {
10793          DU_LOG("\nDEBUG  -->  F1AP : Created APER encoded buffer for Ue Context Release Command\n");
10794          for(ieIdx=0; ieIdx< encBufSize; ieIdx++)
10795          {
10796             DU_LOG("%x",encBuf[ieIdx]);
10797          }
10798       }
10799
10800       /* TODO : Hardcoding DU ID to 1 for messages other than F1 Setup Response. This will be made generic in future gerrit */
10801       if(SendF1APMsg(CU_APP_MEM_REG, CU_POOL, duId) != ROK)
10802       {
10803          DU_LOG("\nERROR  -->  F1AP : Sending Ue context Release Command failed");
10804          break;
10805       }
10806
10807       ret = ROK;
10808       break;
10809
10810    }
10811    FreeUeContextReleaseCommand(f1apMsg);
10812    return ret;
10813 }
10814 /*******************************************************************
10815 *
10816 * @brief process Ue context release request
10817 *
10818 * @details
10819 *
10820 *    Function : procUeContextReleaseReq
10821 *
10822 *    Functionality:
10823 *         - process Ue context release request
10824 *
10825 * @params[in] F1AP_PDU_t *f1apMsg
10826 * @return ROK     - success
10827 *         RFAILED - failure
10828 *
10829 * ****************************************************************/
10830 uint8_t procUeContextReleaseReq(uint32_t duId, F1AP_PDU_t *f1apMsg)
10831 {
10832    uint8_t ieIdx=0, duUeF1apId=0,cuUeF1apId=0;
10833
10834    UEContextReleaseRequest_t *ueReleaseReq = NULLP;
10835    ueReleaseReq = &f1apMsg->choice.initiatingMessage->value.choice.UEContextReleaseRequest;
10836
10837    for(ieIdx=0; ieIdx < ueReleaseReq->protocolIEs.list.count; ieIdx++)
10838    {
10839       switch(ueReleaseReq->protocolIEs.list.array[ieIdx]->id)
10840       {
10841          case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
10842             {
10843                cuUeF1apId = ueReleaseReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID;
10844                break;
10845             }
10846          case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
10847             {
10848                duUeF1apId = ueReleaseReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID;
10849                break;
10850             }
10851          default:
10852               break;
10853       }
10854    }
10855
10856    if(BuildAndSendUeContextReleaseCommand(duId, cuUeF1apId, duUeF1apId) != ROK)
10857    {
10858       DU_LOG("\nERROR  -->  F1AP : procUeContextReleaseReq(): Failed to build Ue Context Release Command ");
10859       return RFAILED;
10860    }
10861    return ROK;
10862 }
10863 /*******************************************************************
10864 *
10865 * @brief processing of Gnb-DU config update
10866 *
10867 * @details
10868 *
10869 *    Function : procGnbDuUpdate
10870 *
10871 *    Functionality:
10872 *         - processing of Gnb-DU config update
10873 *
10874 * @params[in] F1AP_PDU_t *f1apMsg
10875 * @return ROK     - success
10876 *         RFAILED - failure
10877 *
10878 * ****************************************************************/
10879 uint8_t procGnbDuUpdate(uint32_t duId, F1AP_PDU_t *f1apMsg)
10880 {
10881    bool cellToBeDelete = false;
10882    uint8_t ieIdx = 0, ueIdx = 0, duIdx = 0, cellIdx=0;
10883    uint16_t nrCellId;
10884    DuDb *duDb;
10885    CuCellCb *cellCb;
10886    GNBDUConfigurationUpdate_t *duCfgUpdate = NULLP;
10887
10888    duCfgUpdate = &f1apMsg->choice.initiatingMessage->value.choice.GNBDUConfigurationUpdate;
10889    for(ieIdx=0; ieIdx < duCfgUpdate->protocolIEs.list.count; ieIdx++)
10890    {
10891       switch(duCfgUpdate->protocolIEs.list.array[ieIdx]->id)
10892       {
10893          case ProtocolIE_ID_id_TransactionID:
10894             break;
10895          case ProtocolIE_ID_id_Served_Cells_To_Modify_List:
10896             break;
10897          case ProtocolIE_ID_id_Served_Cells_To_Delete_List:
10898             {
10899                struct Served_Cells_To_Delete_ItemIEs *deleteItemIe = \
10900                   (struct Served_Cells_To_Delete_ItemIEs *)duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.\
10901                   Served_Cells_To_Delete_List.list.array[0];
10902                nrCellId = deleteItemIe->value.choice.Served_Cells_To_Delete_Item.oldNRCGI.nRCellIdentity.buf[4] >>\
10903                   deleteItemIe->value.choice.Served_Cells_To_Delete_Item.oldNRCGI.nRCellIdentity.bits_unused;
10904                cellToBeDelete = true;
10905                break;
10906             }
10907          case ProtocolIE_ID_id_gNB_DU_ID:
10908             break;
10909       }
10910    }
10911    if(BuildAndSendDUUpdateAck(duId) != ROK)
10912    {
10913       DU_LOG("ERROR  -->  F1AP : Failed to build and send DUUpdateAck");
10914       return RFAILED;
10915    }
10916 #if 0
10917    /* We don't require F1 Reset message in Cell Up and Broadcast Procedure flow, So that's why
10918     * commented this trigger for now */
10919
10920    if(cellToBeDelete == false)
10921    {
10922       DU_LOG("\nINFO  -->  F1AP : Sending F1 reset request");
10923       if(BuildAndSendF1ResetReq() != ROK)
10924       {
10925          DU_LOG("ERROR  -->  F1AP : Failed to build and send F1 reset request");
10926          return RFAILED;
10927       }
10928    }
10929 #endif
10930    if(cellToBeDelete == true)
10931    {
10932       SEARCH_DU_DB(duIdx, duId, duDb);
10933       SEARCH_CELL_DB(cellIdx, duDb, nrCellId, cellCb);
10934       for(ueIdx = 0; ueIdx < cellCb->numUe; ueIdx++)
10935       {
10936          CU_FREE(cellCb->ueCb[ueIdx]->f1apMsgDb.duToCuContainer.buf, cellCb->ueCb[ueIdx]->f1apMsgDb.duToCuContainer.size);
10937          memset(cellCb->ueCb[ueIdx], 0, sizeof(CuUeCb));
10938       }
10939    }
10940
10941    return ROK;
10942 }
10943
10944 /*******************************************************************
10945 *
10946 * @brief storing slice list in CU database
10947 *
10948 * @details
10949 *
10950 *    Function : buildSliceList
10951 *
10952 *    Functionality:
10953 *         - storing slice list in CU database
10954 *
10955 * @params[in] SliceSupportList_t *sliceSupportList
10956 * @return ROK     - success
10957 *         RFAILED - failure
10958 *
10959 * ****************************************************************/
10960 uint8_t buildSliceList(SliceSupportList_t *sliceSupportList)
10961 {
10962    uint8_t sliceListIdx = 0;
10963
10964    if(sliceSupportList)
10965    {
10966       if(sliceSupportList->list.array)
10967       {
10968          cuCb.numSnssaiSupported = sliceSupportList->list.count;
10969          for(sliceListIdx=0; sliceListIdx<sliceSupportList->list.count; sliceListIdx++)
10970          {
10971             if(sliceSupportList->list.array[sliceListIdx])
10972             {
10973                CU_ALLOC(cuCb.snssaiList[sliceListIdx], sizeof(Snssai));
10974                if(cuCb.snssaiList[sliceListIdx] == NULLP)
10975                {
10976                    DU_LOG("\nERROR  --> CU_STUB: buildSliceList(): Memory allocation failed");
10977                    return RFAILED;
10978                }
10979                if(sliceSupportList->list.array[sliceListIdx]->sNSSAI.sST.buf)
10980                {
10981                   memcpy(&cuCb.snssaiList[sliceListIdx]->sst, sliceSupportList->list.array[sliceListIdx]->\
10982                   sNSSAI.sST.buf, sliceSupportList->list.array[sliceListIdx]->sNSSAI.sST.size);
10983                }
10984                if(sliceSupportList->list.array[sliceListIdx]->sNSSAI.sD->size)
10985                {
10986                   memcpy(&cuCb.snssaiList[sliceListIdx]->sd,\
10987                   sliceSupportList->list.array[sliceListIdx]->sNSSAI.sD->buf,\
10988                   sliceSupportList->list.array[sliceListIdx]->sNSSAI.sD->size);
10989                }
10990             }
10991          }
10992       }
10993    }
10994    return ROK;
10995 }
10996
10997 /****************************************************************
10998  * @brief Function to process Srb Setup Mod List
10999  *
11000  * @details
11001  *
11002  *    Function : procSrbSetupModList
11003  *
11004  *    Functionality:
11005  *         - Function to process SRB Setup Mod List
11006  *
11007  * @params[in]
11008  * @return ROK     - success
11009  *         RFAILED - failure
11010  *
11011  * ****************************************************************/
11012 uint8_t procSrbSetupModList(CuUeCb *ueCb, SRBs_SetupMod_List_t *srbSetupList)
11013 {
11014    uint8_t arrIdx = 0, srbIdx;
11015    struct SRBs_SetupMod_ItemIEs *srbItemIe = NULLP;
11016
11017    if(srbSetupList != NULLP)
11018    {
11019       for(arrIdx = 0; arrIdx < srbSetupList->list.count; arrIdx++)
11020       {
11021          srbItemIe = ((struct SRBs_SetupMod_ItemIEs *)srbSetupList->list.array[arrIdx]);
11022          if(srbItemIe->value.present == SRBs_SetupMod_ItemIEs__value_PR_SRBs_SetupMod_Item)
11023          {
11024             for(srbIdx = 0; srbIdx < ueCb->numSrb; srbIdx++)
11025             {
11026                if(ueCb->srbList[srbIdx].srbId == srbItemIe->value.choice.SRBs_SetupMod_Item.sRBID)
11027                {
11028                   ueCb->srbList[srbIdx].lcId = srbItemIe->value.choice.SRBs_SetupMod_Item.lCID;
11029                   break;
11030                }
11031             }
11032          }
11033
11034       }
11035    }
11036    return ROK;
11037 }
11038
11039
11040 /****************************************************************
11041  * @brief Function to process Drb Setup Mod List
11042  *
11043  * @details
11044  *
11045  *    Function : procDrbSetupModList
11046  *
11047  *    Functionality:
11048  *         - Function to process DRB Setup Mod List
11049  *
11050  * @params[in]
11051  * @return ROK     - success
11052  *         RFAILED - failure
11053  *
11054  * ****************************************************************/
11055 uint8_t procDrbSetupModList(CuUeCb *ueCb, DRBs_SetupMod_List_t *drbSetupList)
11056 {
11057    uint8_t arrIdx = 0, drbIdx;
11058    uint32_t teId = 0;
11059    struct DRBs_SetupMod_ItemIEs *drbItemIe = NULLP;
11060
11061    if(drbSetupList != NULLP)
11062    {
11063       for(arrIdx = 0; arrIdx < drbSetupList->list.count; arrIdx++)
11064       {
11065          drbItemIe = ((struct DRBs_SetupMod_ItemIEs *)drbSetupList->list.array[arrIdx]);
11066          if(drbItemIe->value.present == DRBs_SetupMod_ItemIEs__value_PR_DRBs_SetupMod_Item)
11067          {
11068             for(drbIdx = 0; drbIdx < ueCb->numDrb; drbIdx++)
11069             {
11070                if(ueCb->drbList[drbIdx].drbId == drbItemIe->value.choice.DRBs_SetupMod_Item.dRBID)
11071                {
11072                   if(drbItemIe->value.choice.DRBs_SetupMod_Item.lCID)
11073                      ueCb->drbList[drbIdx].lcId = *(drbItemIe->value.choice.DRBs_SetupMod_Item.lCID);
11074                   break;
11075                }
11076             }
11077
11078             if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
11079             {
11080             /* extracting teId */
11081             teId  = extractTeId(&drbItemIe->value.choice.DRBs_SetupMod_Item.dLUPTNLInformation_ToBeSetup_List);
11082             if(teId > 0)
11083             {
11084               if(addDrbTunnels(teId)== ROK)
11085               {
11086                 DU_LOG("\nDEBUG  --> EGTP: Tunnel Added for TeId %d", teId);
11087               }
11088             }
11089             else
11090                return RFAILED;
11091             }
11092          }
11093       }
11094    }
11095    return ROK;
11096 }
11097
11098 /*******************************************************************
11099 *
11100 * @brief processing of GNB_DU_Served_Cells Plmn list  information
11101 *
11102 * @details
11103 *
11104 *    Function : procServedCellPlmnList
11105 *
11106 *    Functionality:
11107 *         - processing of GNB_DU_Served_Cells Plmn list information for storing
11108 *         SNSSAI list
11109 *
11110 * @params[in] F1AP_PDU_t *f1apMsg
11111 * @return ROK     - success
11112 *         RFAILED - failure
11113 *
11114 * ****************************************************************/
11115 uint8_t procServedCellPlmnList(ServedPLMNs_List_t *srvPlmn)
11116 {
11117    uint8_t srvPlmnIdx=0, ieExtensionsLstIdx=0;
11118    ProtocolExtensionContainer_4624P3_t **ieExtend;
11119
11120    if(srvPlmn->list.array)
11121    {
11122       for(srvPlmnIdx=0; srvPlmnIdx<srvPlmn->list.count; srvPlmnIdx++)
11123       {
11124          if(srvPlmn->list.array[srvPlmnIdx])
11125          {
11126             ieExtend =  &srvPlmn->list.array[srvPlmnIdx]->iE_Extensions;
11127             if(*ieExtend)
11128             {
11129                if((*ieExtend)->list.array)
11130                {
11131                   for(ieExtensionsLstIdx = 0; ieExtensionsLstIdx<(*ieExtend)->list.count; ieExtensionsLstIdx++)
11132                   {
11133                      if((*ieExtend)->list.array[ieExtensionsLstIdx])
11134                      {
11135                         switch((*ieExtend)->list.array[ieExtensionsLstIdx]->id )
11136                         {
11137                            case ProtocolIE_ID_id_TAISliceSupportList:
11138                               {
11139                                  if(buildSliceList(&(*ieExtend)->list.array[ieExtensionsLstIdx]->\
11140                                           extensionValue.choice.SliceSupportList) != ROK)
11141                                  {
11142                                     DU_LOG("\nERROR  --> CU_STUB: procServedCellPlmnList(): Failed to build slice List");
11143                                     return RFAILED;
11144                                  }
11145                               }
11146                         }
11147                      }
11148                   }
11149                }
11150             }
11151          }
11152       }
11153    }
11154    return ROK;
11155 }
11156
11157 /****************************************************************
11158  * @brief Function to process Ue Context Modification Response
11159  *
11160  * @details
11161  *
11162  *    Function : procUeContextModificationResponse
11163  *
11164  *    Functionality:
11165  *         - Function to process Ue Context Modification Response
11166  *
11167  * @params[in]
11168  * @return ROK     - success
11169  *         RFAILED - failure
11170  *
11171  * ****************************************************************/
11172 uint8_t procUeContextModificationResponse(uint32_t duId, F1AP_PDU_t *f1apMsg)
11173 {
11174    uint8_t idx=0, duIdx=0, duUeF1apId;
11175    DuDb *duDb;
11176    CuUeCb *ueCb;
11177    UEContextModificationResponse_t *ueCtxtModRsp = NULLP;
11178
11179    SEARCH_DU_DB(duIdx, duId, duDb);
11180    ueCtxtModRsp = &f1apMsg->choice.successfulOutcome->value.choice.UEContextModificationResponse;
11181
11182    for(idx=0; idx < ueCtxtModRsp->protocolIEs.list.count; idx++)
11183    {
11184       switch(ueCtxtModRsp->protocolIEs.list.array[idx]->id)
11185       {
11186           case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
11187              {
11188                 duUeF1apId = ueCtxtModRsp->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID;
11189                 ueCb = &duDb->ueCb[duUeF1apId-1];
11190                 break;
11191              }
11192           case ProtocolIE_ID_id_DRBs_SetupMod_List:
11193              {
11194                 /* Adding Tunnels for successful DRB */
11195                 procDrbSetupModList(ueCb, &ueCtxtModRsp->protocolIEs.list.array[idx]->value.choice.DRBs_SetupMod_List);
11196                 break;
11197
11198              }
11199           case ProtocolIE_ID_id_SRBs_SetupMod_List:
11200              {
11201                 procSrbSetupModList(ueCb, &ueCtxtModRsp->protocolIEs.list.array[idx]->value.choice.SRBs_SetupMod_List);
11202                 break;
11203              }
11204          case ProtocolIE_ID_id_DUtoCURRCInformation:
11205              {
11206                 DU_LOG("\nINFO  -->  Received Du to Cu RRC Information ");
11207                 if((extractDuToCuRrcCont(ueCb, ueCtxtModRsp->protocolIEs.list.array[idx]->value.choice.\
11208                    DUtoCURRCInformation.cellGroupConfig)) != ROK)
11209                 {
11210                    DU_LOG("\nERROR  -->  F1AP : Failed to extract Du to Cu RRC Information");
11211                    return RFAILED;
11212                 }
11213                 break;
11214              }
11215
11216       }
11217    }
11218    if(ueCb->state == UE_HANDOVER_IN_PROGRESS)
11219    {
11220       BuildAndSendUeContextSetupReq(ueCb->hoInfo.targetDuId, ueCb, 0, NULLP);
11221       return ROK;
11222    }
11223
11224    return ROK;
11225 }
11226
11227 /*******************************************************************
11228 *
11229 * @brief processing of F1 setup request
11230 *
11231 * @details
11232 *
11233 *    Function : procF1SetupReq
11234 *
11235 *    Functionality:
11236 *         - processing of  F1 setup request
11237 *
11238 * @params[in] F1AP_PDU_t *f1apMsg
11239 * @return ROK     - success
11240 *         RFAILED - failure
11241 *
11242 * ****************************************************************/
11243 void procF1SetupReq(uint32_t *destDuId, F1AP_PDU_t *f1apMsg)
11244 {
11245    uint8_t ieIdx = 0, plmnidx=0, duIdx = 0, ret=ROK, cellIdx = 0;
11246    uint32_t duId = 0, nrCellId = 0;
11247    DuDb     *duDb = NULLP;
11248    CuCellCb *cellCb = NULLP;
11249    BIT_STRING_t nrcellIdentity;
11250    F1SetupRequest_t *f1SetupReq = NULLP;
11251    GNB_DU_Served_Cells_Item_t *srvCellItem = NULLP;
11252    GNB_DU_Served_Cells_List_t *duServedCell = NULLP;
11253
11254    f1SetupReq = &f1apMsg->choice.initiatingMessage->value.choice.F1SetupRequest;
11255    for(ieIdx=0; ieIdx < f1SetupReq->protocolIEs.list.count; ieIdx++)
11256    {
11257       switch(f1SetupReq->protocolIEs.list.array[ieIdx]->id)
11258       {
11259          case ProtocolIE_ID_id_gNB_DU_ID:
11260            {
11261               duId = f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf[0];
11262               SEARCH_DU_DB(duIdx, duId, duDb);
11263               if(duDb == NULLP)
11264               {
11265                  duDb = &cuCb.duInfo[cuCb.numDu];
11266                  memset(duDb, 0, sizeof(DuDb));
11267                  duDb->duId = duId;
11268                  cuCb.numDu++;
11269                  *destDuId = duId;
11270               }
11271               else
11272                  return;
11273               break;
11274            }
11275          case ProtocolIE_ID_id_gNB_DU_Name:
11276            {
11277               strcpy((char *)duDb->duName, (char*)f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_Name.buf);
11278               break;
11279            }
11280          case ProtocolIE_ID_id_gNB_DU_Served_Cells_List:
11281            {
11282                duServedCell = &f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_Served_Cells_List;
11283                if(duServedCell->list.array)
11284                {
11285                   for(plmnidx=0; plmnidx<duServedCell->list.count; plmnidx++)
11286                   {
11287                      if(duServedCell->list.array[plmnidx])
11288                      {
11289                         switch(duServedCell->list.array[plmnidx]->id)
11290                         {
11291                            case ProtocolIE_ID_id_GNB_DU_Served_Cells_Item:
11292                            {
11293                               srvCellItem =  &duServedCell->list.array[plmnidx]->value.choice.GNB_DU_Served_Cells_Item;
11294                               ret = procServedCellPlmnList(&srvCellItem->served_Cell_Information.servedPLMNs);
11295                               memcpy(&nrcellIdentity, &srvCellItem->served_Cell_Information.nRCGI.nRCellIdentity, sizeof(BIT_STRING_t));
11296
11297                               nrCellId = nrcellIdentity.buf[4] >> nrcellIdentity.bits_unused;
11298                               SEARCH_CELL_DB(cellIdx, duDb, nrCellId, cellCb);
11299                               if(cellCb == NULLP)
11300                               {
11301                                  cellCb = &duDb->cellCb[duDb->numCells];
11302                                  memset(cellCb, 0, sizeof(CuCellCb));
11303                                  cellCb->nrCellId = nrCellId;
11304                                  duDb->numCells++;
11305                               }
11306                            }
11307                         }
11308                      }
11309                   }
11310                }
11311            }
11312       }
11313    }
11314    if(ret == ROK)
11315    {
11316       BuildAndSendF1SetupRsp(duId, &nrcellIdentity);
11317    }
11318    else
11319    {
11320        DU_LOG("\nERROR  --> CU_STUB: procF1SetupReq(): Failed to process F1 setup request");
11321    }
11322 }
11323
11324 /*******************************************************************
11325  *
11326  * @brief Handles received F1AP message and sends back response
11327  *
11328  * @details
11329  *
11330  *    Function : F1APMsgHdlr
11331  *
11332  *    Functionality:
11333  *         - Decodes received F1AP control message
11334  *         - Prepares response message, encodes and sends to SCTP
11335  *
11336  * @params[in]
11337  * @return ROK     - success
11338  *         RFAILED - failure
11339  *
11340  * ****************************************************************/
11341 void F1APMsgHdlr(uint32_t *duId, Buffer *mBuf)
11342 {
11343    int i;
11344    char *recvBuf;
11345    MsgLen copyCnt;
11346    MsgLen recvBufLen;
11347    F1AP_PDU_t *f1apMsg = NULLP;
11348    asn_dec_rval_t rval; /* Decoder return value */
11349    F1AP_PDU_t f1apasnmsg ;
11350
11351    DU_LOG("\nINFO  -->  F1AP : Received F1AP message buffer");
11352    ODU_PRINT_MSG(mBuf, 0,0);
11353
11354    /* Copy mBuf into char array to decode it */
11355    ODU_GET_MSG_LEN(mBuf, &recvBufLen);
11356    CU_ALLOC(recvBuf, (Size)recvBufLen);
11357
11358    if(recvBuf == NULLP)
11359    {
11360       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed");
11361       return;
11362    }
11363    if(ODU_COPY_MSG_TO_FIX_BUF(mBuf, 0, recvBufLen, (Data *)recvBuf, &copyCnt) != ROK)
11364    {
11365       DU_LOG("\nERROR  -->  F1AP : Failed while copying %d", copyCnt);
11366       return;
11367    }
11368
11369    DU_LOG("\nDEBUG  -->  F1AP : Received flat buffer to be decoded : ");
11370    for(i=0; i< recvBufLen; i++)
11371    {
11372       DU_LOG("%x",recvBuf[i]);
11373    }
11374
11375    /* Decoding flat buffer into F1AP messsage */
11376    f1apMsg = &f1apasnmsg;
11377    memset(f1apMsg, 0, sizeof(F1AP_PDU_t));
11378
11379    rval = aper_decode(0, &asn_DEF_F1AP_PDU, (void **)&f1apMsg, recvBuf, recvBufLen, 0, 0);
11380    CU_FREE(recvBuf, (Size)recvBufLen);
11381
11382    if(rval.code == RC_FAIL || rval.code == RC_WMORE)
11383    {
11384       DU_LOG("\nERROR  -->  F1AP : ASN decode failed");
11385       return;
11386    }
11387    DU_LOG("\n");
11388    xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
11389
11390    switch(f1apMsg->present)
11391    {
11392       case F1AP_PDU_PR_initiatingMessage:
11393          {
11394             switch(f1apMsg->choice.initiatingMessage->value.present)
11395             {
11396                case InitiatingMessage__value_PR_Reset:
11397                   {
11398                      DU_LOG("\nINFO  -->  F1AP : F1 reset request received ");
11399                      BuildAndSendF1ResetAck();
11400                      break;
11401                   }
11402
11403                case InitiatingMessage__value_PR_F1SetupRequest:
11404                   {
11405                      DU_LOG("\nINFO  -->  F1AP : F1 setup request received");
11406                      procF1SetupReq(duId, f1apMsg);
11407                      break;
11408                   }
11409
11410                case InitiatingMessage__value_PR_GNBDUConfigurationUpdate:
11411                   {
11412                      DU_LOG("\nINFO  -->  F1AP : GNB-DU config update received");
11413                      procGnbDuUpdate(*duId, f1apMsg);
11414                      break;
11415                   }
11416                case InitiatingMessage__value_PR_InitialULRRCMessageTransfer:
11417                   {
11418                      DU_LOG("\nINFO  -->  F1AP : Received InitialULRRCMessageTransfer");
11419                      procInitULRRCMsg(*duId, f1apMsg);
11420                      break;
11421                   }
11422                case InitiatingMessage__value_PR_ULRRCMessageTransfer:
11423                   {
11424                      DU_LOG("\nINFO  -->  F1AP : Received ULRRCMessageTransfer");
11425                      procUlRrcMsg(*duId, f1apMsg);
11426                      break;
11427                   }
11428
11429                case InitiatingMessage__value_PR_RRCDeliveryReport:
11430                   {
11431                      DU_LOG("\nINFO  -->  F1AP : Received RRC delivery report");
11432                      break;
11433                   }
11434                case InitiatingMessage__value_PR_UEContextReleaseRequest:
11435                   {
11436                      DU_LOG("\nINFO  -->  F1AP : Received UE Context Release Request");
11437                      procUeContextReleaseReq(*duId, f1apMsg);
11438                      break;
11439                   }
11440                default:
11441                   {
11442                      DU_LOG("\nERROR  -->  F1AP : Invalid type of intiating message [%d]",\
11443                            f1apMsg->choice.initiatingMessage->value.present);
11444                      return;
11445                   }
11446             }/* End of switch(initiatingMessage) */
11447             break;
11448          }
11449
11450       case F1AP_PDU_PR_successfulOutcome:
11451          {
11452             switch(f1apMsg->choice.successfulOutcome->value.present)
11453             {
11454                case SuccessfulOutcome__value_PR_ResetAcknowledge:
11455                   {
11456                      DU_LOG("\nINFO  -->  F1Reset Acknowledgement is received successfully ");
11457                      break;
11458                   }
11459                case SuccessfulOutcome__value_PR_UEContextSetupResponse:
11460                   {
11461                      DU_LOG("\nINFO  -->  F1AP : UE ContextSetupResponse received");
11462                      procUeContextSetupResponse(*duId, f1apMsg);
11463                      break;
11464                   }
11465                case SuccessfulOutcome__value_PR_UEContextModificationResponse:
11466                   {
11467                      DU_LOG("\nINFO  -->  F1AP : UE Context Modification Response received");
11468                      procUeContextModificationResponse(*duId, f1apMsg);
11469                      break;
11470                   }
11471                case SuccessfulOutcome__value_PR_UEContextReleaseComplete:
11472                   {
11473                       DU_LOG("\nINFO  -->  F1AP : UE Context release complete received");
11474                       break;
11475                   }
11476                default:
11477                   {
11478                      DU_LOG("\nERROR  -->  F1AP : Invalid type of successful outcome message [%d]",\
11479                            f1apMsg->choice.successfulOutcome->value.present);
11480                      return;
11481                   }
11482             }/* End of switch(successfulOutcome) */
11483             break;
11484          }
11485       default:
11486          {
11487             DU_LOG("\nERROR  -->  F1AP : Invalid type of f1apMsg->present [%d]",f1apMsg->present);
11488             return;
11489          }
11490    }/* End of switch(f1apMsg->present) */
11491
11492 } /* End of F1APMsgHdlr */
11493
11494 /**********************************************************************
11495   End of file
11496  **********************************************************************/