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 /*******************************************************************
1183  *
1184  * @brief Fills QOS flow configuration
1185  *
1186  * @details
1187  *
1188  *    Function : fillQosFlowsToAdd
1189  *
1190  *    Functionality: Fills QOS flow configuration
1191  *
1192  * @params[in] struct SDAP_Config__mappedQoS_FlowsToAdd *qosFlow
1193  *
1194  * @return ROK     - success
1195  *         RFAILED - failure
1196  *
1197  * ****************************************************************/
1198 uint8_t fillQosFlowsToAdd(struct SDAP_Config__mappedQoS_FlowsToAdd *qosFlow)
1199 {
1200    uint8_t idx, ied, elementCnt;
1201
1202    elementCnt = 1;
1203    qosFlow->list.count = elementCnt;
1204    qosFlow->list.size  = elementCnt * sizeof(QFI_t *);
1205    CU_ALLOC(qosFlow->list.array, qosFlow->list.size);
1206    if(qosFlow->list.array != NULLP)
1207    {
1208       for(idx = 0; idx < elementCnt; idx++)
1209       {
1210          CU_ALLOC(qosFlow->list.array[idx], sizeof(QFI_t));
1211          if(qosFlow->list.array[idx] == NULLP)
1212          {
1213             for(ied = 0; ied < idx; ied++)
1214             {
1215                CU_FREE(qosFlow->list.array[idx], sizeof(QFI_t));
1216             }
1217             CU_FREE(qosFlow->list.array, qosFlow->list.size);
1218             return RFAILED;
1219          }
1220       }
1221    }
1222    idx = 0;
1223    *qosFlow->list.array[idx] = 9;
1224    return ROK;
1225 }
1226
1227 /*******************************************************************
1228  *
1229  * @brief Fills CN Assoc for Drb to Add/Mod List
1230  *
1231  * @details
1232  *
1233  *    Function : fillCnAssoc
1234  *
1235  *    Functionality: Fills CN Assoc for Drb to Add/Mod List
1236  *
1237  * @params[in] struct DRB_ToAddMod__cnAssociation *
1238  *
1239  * @return ROK     - success
1240  *         RFAILED - failure
1241  *
1242  * ****************************************************************/
1243
1244 uint8_t fillCnAssoc(struct DRB_ToAddMod__cnAssociation *cnAssoc)
1245 {
1246    uint8_t ret = ROK;
1247
1248    cnAssoc->present = DRB_ToAddMod__cnAssociation_PR_sdap_Config;
1249    if(cnAssoc->present == DRB_ToAddMod__cnAssociation_PR_eps_BearerIdentity)
1250    {
1251       cnAssoc->choice.eps_BearerIdentity = 5;
1252    }
1253    if(cnAssoc->present == DRB_ToAddMod__cnAssociation_PR_sdap_Config)
1254    {
1255       CU_ALLOC(cnAssoc->choice.sdap_Config, sizeof(SDAP_Config_t));
1256       if(cnAssoc->choice.sdap_Config)
1257       {
1258          cnAssoc->choice.sdap_Config->pdu_Session = 5;
1259          cnAssoc->choice.sdap_Config->sdap_HeaderDL = 0;
1260          cnAssoc->choice.sdap_Config->sdap_HeaderUL = 0;
1261          cnAssoc->choice.sdap_Config->defaultDRB = true;
1262          cnAssoc->choice.sdap_Config->mappedQoS_FlowsToAdd = NULLP;
1263          cnAssoc->choice.sdap_Config->mappedQoS_FlowsToRelease = NULLP;
1264          CU_ALLOC(cnAssoc->choice.sdap_Config->mappedQoS_FlowsToAdd, \
1265                sizeof(struct SDAP_Config__mappedQoS_FlowsToAdd));
1266          if(cnAssoc->choice.sdap_Config->mappedQoS_FlowsToAdd)
1267          {
1268             ret = fillQosFlowsToAdd(cnAssoc->choice.sdap_Config->mappedQoS_FlowsToAdd);
1269          }
1270          else
1271          {
1272             DU_LOG("\nERROR  -->  F1AP: Memory alloc failed at mappedQoS_FlowsToAdd in fillCnAssoc()");
1273             CU_FREE(cnAssoc->choice.sdap_Config, sizeof(SDAP_Config_t));
1274             ret = RFAILED;
1275          }
1276       }
1277       else
1278       {
1279          DU_LOG("\nERROR  -->  F1AP: Mem alloc failed at fillCnAssoc()");
1280          ret = RFAILED;
1281       }
1282    }
1283    return ret;
1284 }
1285
1286 /*******************************************************************
1287  *
1288  * @brief Fills Radio Bearer Config for Drb
1289  *
1290  * @details
1291  *
1292  *    Function : fillDrbCfg
1293  *
1294  *    Functionality: Fills Radio Bearer Config for Drb
1295  *
1296  * @params[in] drbId, DRB_ToAddModList *
1297  *
1298  * @return ROK     - success
1299  *         RFAILED - failure
1300  *
1301  * ****************************************************************/
1302 uint8_t fillDrbCfg(uint8_t drbId, DRB_ToAddModList_t *drbCfg)
1303 {
1304    uint8_t idx, ied, ret, elementCnt;
1305
1306    ret = ROK;
1307    if(drbCfg != NULLP)
1308    {
1309       elementCnt = 1;
1310       drbCfg->list.count = elementCnt;
1311       drbCfg->list.size =\
1312                          elementCnt * sizeof(DRB_ToAddMod_t *);
1313       CU_ALLOC(drbCfg->list.array, drbCfg->list.size);
1314       if(drbCfg->list.array != NULLP)
1315       {
1316          for(idx = 0; idx < elementCnt; idx++)
1317          {
1318             CU_ALLOC(drbCfg->list.array[idx], sizeof(DRB_ToAddMod_t));
1319             if(drbCfg->list.array[idx] == NULLP)
1320             {
1321                for(ied = 0; ied < idx; ied++)
1322                {
1323                   CU_FREE(drbCfg->list.array[idx], sizeof(DRB_ToAddMod_t));
1324                }
1325                CU_FREE(drbCfg->list.array, drbCfg->list.size);
1326                return RFAILED;
1327             }
1328          }
1329       }
1330       else
1331       {
1332          return RFAILED;
1333       }
1334       idx = 0;
1335       /* CN ASSOCIATION */
1336       CU_ALLOC(drbCfg->list.array[idx]->cnAssociation, sizeof(struct DRB_ToAddMod__cnAssociation));
1337       if(drbCfg->list.array[idx]->cnAssociation)
1338       {
1339          ret = fillCnAssoc(drbCfg->list.array[idx]->cnAssociation);
1340       }
1341       /* DRB */
1342       drbCfg->list.array[idx]->drb_Identity = drbId;
1343    }
1344    return ret;
1345 }
1346
1347 /*******************************************************************
1348  *
1349  * @brief Fills RRC Reconfig Message required for DLRRCMessageTransfer
1350  *
1351  * @details
1352  *
1353  *    Function : fillRrcReconfigIE
1354  *
1355  *    Functionality: Fills RRC Reconfig Message required for
1356  *                   DLRRCMessageTransfer
1357  *
1358  * @params[in] RRCReconfiguration_IEs_t* rrcReconfig
1359  *
1360  * @return ROK     - success
1361  *         RFAILED - failure
1362  *
1363  * ****************************************************************/
1364
1365 uint8_t fillRrcReconfigIE(RRCReconfiguration_IEs_t *rrcReconfigMsg)
1366 {
1367    uint8_t ret = ROK;
1368    CU_ALLOC(rrcReconfigMsg->radioBearerConfig, sizeof(RadioBearerConfig_t));
1369    if(rrcReconfigMsg->radioBearerConfig)
1370    {
1371       CU_ALLOC(rrcReconfigMsg->radioBearerConfig->srb_ToAddModList, sizeof(SRB_ToAddModList_t));
1372       if(rrcReconfigMsg->radioBearerConfig->srb_ToAddModList != NULLP)
1373       {
1374          ret = fillSrbCfg(SRB2, rrcReconfigMsg->radioBearerConfig->srb_ToAddModList);
1375
1376       }
1377       if(ret == ROK)
1378       {
1379          CU_ALLOC(rrcReconfigMsg->radioBearerConfig->drb_ToAddModList, sizeof(DRB_ToAddModList_t));
1380          if(rrcReconfigMsg->radioBearerConfig->drb_ToAddModList != NULLP)
1381          {
1382             ret = fillDrbCfg(DRB1, rrcReconfigMsg->radioBearerConfig->drb_ToAddModList);
1383             if(ret == RFAILED)
1384             {
1385                DU_LOG("\nERROR  -->  F1AP : Failed to fill DrbCfg at fillRrcReconfigIE()");
1386                CU_FREE(rrcReconfigMsg->radioBearerConfig->srb_ToAddModList, sizeof(SRB_ToAddModList_t));
1387                CU_FREE(rrcReconfigMsg->radioBearerConfig->drb_ToAddModList, sizeof(DRB_ToAddModList_t));
1388             }
1389          }
1390       }
1391       else
1392       {
1393          DU_LOG("\nERROR  -->  F1AP : memory Alloc failed at fillRrcReconfigIE()");
1394          CU_FREE(rrcReconfigMsg->radioBearerConfig->srb_ToAddModList, sizeof(SRB_ToAddModList_t));
1395       }
1396    }
1397
1398    return ret;
1399 }
1400 /*******************************************************************
1401  *
1402  * @brief Fills DL DCCH Message required for DLRRCMessageTransfer
1403  *
1404  * @details
1405  *
1406  *    Function : fillDlDcchRrcMsg
1407  *
1408  *    Functionality: Fills DL DCCH Message required for
1409  *                   DLRRCMessageTransfer
1410  *
1411  * @params[in] RRCContainer_t *rrcContainer
1412  *
1413  * @return ROK     - success
1414  *         RFAILED - failure
1415  *
1416  * ****************************************************************/
1417
1418 uint8_t fillDlDcchRrcMsg(CuUeCb *ueCb, RRCContainer_t *rrcContainer)
1419 {
1420    uint8_t ret = ROK;
1421    uint16_t idx2 = 0, drbIdx = 0, srbIdx = 0;
1422    DL_DCCH_Message_t dl_DCCH_Msg;
1423    memset(&dl_DCCH_Msg, 0, sizeof(DL_DCCH_Message_t));
1424    asn_enc_rval_t        encRetVal;
1425
1426    if(rrcContainer != NULLP)
1427    {
1428       dl_DCCH_Msg.message.present = DL_DCCH_MessageType_PR_c1;
1429
1430       CU_ALLOC(dl_DCCH_Msg.message.choice.c1 , sizeof(DL_DCCH_MessageType_t));
1431       if(dl_DCCH_Msg.message.choice.c1 != NULLP)
1432       {
1433          dl_DCCH_Msg.message.choice.c1->present = DL_DCCH_MessageType__c1_PR_rrcReconfiguration;
1434          CU_ALLOC(dl_DCCH_Msg.message.choice.c1->choice.rrcReconfiguration, sizeof(RRCReconfiguration_t));
1435          if(dl_DCCH_Msg.message.choice.c1->choice.rrcReconfiguration != NULLP)
1436          {
1437             DU_LOG("\nDEBUG --> F1AP : Filling DL DCCH RRC Reconfiguration Message ");
1438             fillRrcReconfig(ueCb, dl_DCCH_Msg.message.choice.c1->choice.rrcReconfiguration, false);
1439             if(ret == ROK)
1440             {
1441                /* If RB configuration are filled successfully in RRC Reconfiguration, mark these
1442                 * configurartion as sent to UE */
1443                for(srbIdx=0; srbIdx < ueCb->numSrb; srbIdx++)
1444                {
1445                   if(ueCb->srbList[srbIdx].cfgSentToUe == false)
1446                      ueCb->srbList[srbIdx].cfgSentToUe = true;
1447                }
1448                for(drbIdx=0; drbIdx < ueCb->numDrb; drbIdx++)
1449                {
1450                   if(ueCb->drbList[drbIdx].cfgSentToUe == false)
1451                      ueCb->drbList[drbIdx].cfgSentToUe = true;
1452                }
1453
1454                /* encode DL-DCCH message into RRC Container */
1455                xer_fprint(stdout, &asn_DEF_DL_DCCH_MessageType, &dl_DCCH_Msg);
1456                memset(encBuf, 0, ENC_BUF_MAX_LEN);
1457                encBufSize = 0;
1458                encRetVal = aper_encode(&asn_DEF_DL_DCCH_MessageType, 0, &dl_DCCH_Msg, PrepFinalEncBuf, encBuf);
1459                /* Encode results */
1460                if(encRetVal.encoded == ENCODE_FAIL)
1461                {
1462                   DU_LOG( "\nERROR  -->  F1AP : Could not encode RRCContainer for DL-DCCH Msg (at %s)\n",\
1463                         encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
1464                   return RFAILED;
1465                }
1466                else
1467                {
1468                   DU_LOG("\nDEBUG  -->  F1AP : Created APER encoded buffer for RRCContainer for DL-DCCH Msg\n");
1469                   for(int i = 0; i< encBufSize; i++)
1470                   {
1471                      DU_LOG("%x",encBuf[i]);
1472                   }
1473                   rrcContainer->size = encBufSize;
1474                   CU_ALLOC(rrcContainer->buf, rrcContainer->size);
1475                   if(rrcContainer->buf != NULLP)
1476                   {
1477                      memset(rrcContainer->buf, 0, encBufSize);
1478                      for(idx2 = 0; idx2 < encBufSize; idx2++)
1479                      {
1480                         rrcContainer->buf[idx2] =       encBuf[idx2];
1481                      }
1482                   }
1483                }
1484             }
1485          }
1486          else
1487          {
1488             DU_LOG("\nERROR  -->  F1AP: Memory Alloc failed for RRC Msg at fillDlDcchRrcMsg()");
1489             ret = RFAILED;
1490          }
1491       }
1492       else
1493       {
1494          DU_LOG("\nERROR  -->  F1AP: Memory Alloc failed for DL Dcch Msg choice at fillDlDcchRrcMsg()");
1495          ret = RFAILED;
1496       }
1497    }
1498    else
1499    {
1500       DU_LOG("\nERROR  -->  F1AP: RRC Container is NULLP at fillDlDcchRrcMsg()");
1501       ret = RFAILED;
1502    }
1503    return ret;
1504 }
1505
1506 /*******************************************************************
1507  *
1508  * @brief Builds RRC Container IE required for DLRRCMessageTransfer
1509  *
1510  * @details
1511  *
1512  *    Function : BuildDLRRCContainer
1513  *
1514  *    Functionality: Builds RRC Container IE required for
1515  *                   DLRRCMessageTransfer
1516  *
1517  * @params[in]
1518  *
1519  * @return ROK     - success
1520  *         RFAILED - failure
1521  *
1522  * ****************************************************************/
1523
1524 uint8_t BuildDLRRCContainer(CuUeCb *ueCb, uint8_t rrcMsgType, RRCContainer_t *rrcContainer)
1525 {
1526    uint8_t ret, bufLen;
1527
1528    ret =ROK;
1529    if(rrcMsgType == RRC_SETUP)
1530    {
1531       ret = fillDlCcchRrcMsg(ueCb, rrcContainer);
1532       if(ret == RFAILED)
1533          DU_LOG("\nERROR  -->  F1AP: Failed to fill DL-CCCH Msg at RRC SETUP");
1534    }
1535    else if(rrcMsgType == REGISTRATION_ACCEPT)
1536    {
1537       /*Hardcoded RRC Container from reference logs*/
1538       char buf[14] ={0x00, 0x03, 0x2a, 0x80, 0xaf, 0xc0, 0x08, 0x40, 0x20, 0x20, 0x00, 0x00, 0x00, 0x00};
1539       bufLen =14;
1540       rrcContainer->size = bufLen;
1541       CU_ALLOC(rrcContainer->buf, rrcContainer->size);
1542       if(rrcContainer->buf != NULLP)
1543       {
1544          memset(rrcContainer->buf, 0, bufLen);
1545          memcpy(rrcContainer->buf, buf, bufLen);
1546       }
1547       else
1548       {
1549          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure for RRC Container buffer");
1550          ret = RFAILED;
1551       }
1552    }
1553    else if(rrcMsgType == RRC_RECONFIG)
1554    {
1555       DU_LOG("\nDEBUG --> F1AP : Filling DL DCCH RRC Message ");
1556       ret = fillDlDcchRrcMsg(ueCb, rrcContainer);
1557       if(ret == RFAILED)
1558          DU_LOG("\nERROR  -->  F1AP: Failed to fill DL-DCCH Msg for RRC Reconfiguration");
1559    }
1560
1561    return ret;
1562 }
1563
1564 /*******************************************************************
1565  *
1566  * @brief Frees the DLRRCMessageTransfer
1567  *
1568  * @details
1569  *
1570  *    Function : freeDlRrcMessageTransfer
1571  *
1572  *    Functionality: Frees the DLRRCMessageTransfer
1573  *
1574  * @params[in]
1575  *
1576  * @return ROK     - success
1577  *         RFAILED - failure
1578  *
1579  * ****************************************************************/
1580 void freeDlRrcMessageTransfer(F1AP_PDU_t *f1apMsg)
1581 {
1582    uint8_t idx=0;
1583    DLRRCMessageTransfer_t  *dlRRCMsg = NULLP;
1584
1585    if(f1apMsg)
1586    {
1587       dlRRCMsg = &f1apMsg->choice.initiatingMessage->value.choice.DLRRCMessageTransfer;
1588       if(dlRRCMsg->protocolIEs.list.array)
1589       {
1590          idx = 3;
1591          CU_FREE(dlRRCMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.buf, \
1592             dlRRCMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.size);
1593          for(idx=0; idx<dlRRCMsg->protocolIEs.list.count; idx++)
1594          {
1595             CU_FREE(dlRRCMsg->protocolIEs.list.array[idx], sizeof(DLRRCMessageTransferIEs_t));
1596          }
1597          CU_FREE(dlRRCMsg->protocolIEs.list.array, dlRRCMsg->protocolIEs.list.size);
1598       }
1599       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
1600    }
1601 }
1602
1603 /*******************************************************************
1604  *
1605  * @brief Builds and sends the DLRRCMessageTransfer
1606  *
1607  * @details
1608  *
1609  *    Function : BuildAndSendDLRRCMessageTransfer
1610  *
1611  *    Functionality: Constructs the DL RRC Message Transfer and sends
1612  *                   it to the CU through SCTP.
1613  *
1614  * @params[in]
1615  *
1616  * @return ROK     - success
1617  *         RFAILED - failure
1618  *
1619  * ****************************************************************/
1620 uint8_t BuildAndSendDLRRCMessageTransfer(uint32_t duId, CuUeCb *ueCb, uint8_t srbId, uint8_t rrcMsgType)
1621 {
1622    uint8_t   elementCnt = 0;
1623    uint8_t  ieId;
1624    uint8_t  idx;
1625    F1AP_PDU_t  *f1apMsg = NULLP;
1626    DLRRCMessageTransfer_t  *dlRRCMsg = NULLP;
1627    asn_enc_rval_t   encRetVal;        /* Encoder return value */
1628
1629    DU_LOG("\nINFO  -->  F1AP : Building DL RRC Message Transfer Message\n");
1630
1631    CU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
1632    if(f1apMsg == NULLP)
1633    {
1634       DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
1635       return RFAILED;
1636    }
1637
1638    f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
1639    CU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
1640    if(f1apMsg->choice.initiatingMessage == NULLP)
1641    {
1642       DU_LOG("\nERROR  -->  F1AP : Memory allocation for  F1AP-PDU failed");
1643       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
1644       return RFAILED;
1645    }
1646
1647    f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_DLRRCMessageTransfer;
1648    f1apMsg->choice.initiatingMessage->criticality = Criticality_ignore;
1649    f1apMsg->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_DLRRCMessageTransfer;
1650    dlRRCMsg = &f1apMsg->choice.initiatingMessage->value.choice.DLRRCMessageTransfer;
1651
1652    elementCnt = 4;
1653    dlRRCMsg->protocolIEs.list.count = elementCnt;
1654    dlRRCMsg->protocolIEs.list.size = elementCnt * sizeof(DLRRCMessageTransferIEs_t *);
1655
1656    /* Initialize the F1Setup members */
1657    CU_ALLOC(dlRRCMsg->protocolIEs.list.array, dlRRCMsg->protocolIEs.list.size);
1658    if(dlRRCMsg->protocolIEs.list.array == NULLP)
1659    {
1660       DU_LOG("\nERROR  -->  F1AP : Memory allocation for DL RRC MessageTransferIEs failed");
1661       CU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
1662       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
1663       return RFAILED;
1664    }
1665
1666    for(idx=0; idx<elementCnt; idx++)
1667    {
1668       CU_ALLOC(dlRRCMsg->protocolIEs.list.array[idx], sizeof(DLRRCMessageTransferIEs_t));
1669       if(dlRRCMsg->protocolIEs.list.array[idx] == NULLP)
1670       {
1671          for(ieId=0; ieId<idx; ieId++)
1672          {
1673             CU_FREE(dlRRCMsg->protocolIEs.list.array[ieId], sizeof(DLRRCMessageTransferIEs_t));
1674          }
1675          CU_FREE(dlRRCMsg->protocolIEs.list.array, dlRRCMsg->protocolIEs.list.size);
1676          CU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
1677          CU_FREE(f1apMsg,sizeof(F1AP_PDU_t));
1678          return RFAILED;
1679       }
1680    }
1681
1682    /* GNB CU UE F1AP ID */
1683    idx = 0;
1684    dlRRCMsg->protocolIEs.list.array[idx]->id  = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
1685    dlRRCMsg->protocolIEs.list.array[idx]->criticality  = Criticality_reject;
1686    dlRRCMsg->protocolIEs.list.array[idx]->value.present = DLRRCMessageTransferIEs__value_PR_GNB_CU_UE_F1AP_ID;
1687    dlRRCMsg->protocolIEs.list.array[idx]->value.choice.GNB_CU_UE_F1AP_ID = ueCb->gnbCuUeF1apId;
1688
1689    /* GNB DU UE F1AP ID */
1690    idx++;
1691    dlRRCMsg->protocolIEs.list.array[idx]->id  = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
1692    dlRRCMsg->protocolIEs.list.array[idx]->criticality  = Criticality_reject;
1693    dlRRCMsg->protocolIEs.list.array[idx]->value.present = DLRRCMessageTransferIEs__value_PR_GNB_DU_UE_F1AP_ID;
1694    dlRRCMsg->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID = ueCb->gnbDuUeF1apId;;
1695
1696    /* SRBID */
1697    idx++;
1698    dlRRCMsg->protocolIEs.list.array[idx]->id  = ProtocolIE_ID_id_SRBID;
1699    dlRRCMsg->protocolIEs.list.array[idx]->criticality  = Criticality_reject;
1700    dlRRCMsg->protocolIEs.list.array[idx]->value.present = DLRRCMessageTransferIEs__value_PR_SRBID;
1701    dlRRCMsg->protocolIEs.list.array[idx]->value.choice.SRBID = srbId;
1702
1703    /* RRCContainer */
1704    idx++;
1705    dlRRCMsg->protocolIEs.list.array[idx]->id  = ProtocolIE_ID_id_RRCContainer;
1706    dlRRCMsg->protocolIEs.list.array[idx]->criticality = Criticality_reject;
1707    dlRRCMsg->protocolIEs.list.array[idx]->value.present = DLRRCMessageTransferIEs__value_PR_RRCContainer;
1708    BuildDLRRCContainer(ueCb, rrcMsgType, &dlRRCMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer);
1709
1710    xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
1711
1712    /* Encode the F1SetupRequest type as APER */
1713    memset(encBuf, 0, ENC_BUF_MAX_LEN);
1714    encBufSize = 0;
1715    encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
1716          encBuf);
1717    /* Encode results */
1718    if(encRetVal.encoded == ENCODE_FAIL)
1719    {
1720       DU_LOG( "\nERROR  -->  F1AP : Could not encode DL RRC Message Transfer structure (at %s)\n",\
1721             encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
1722       return RFAILED;
1723    }
1724    else
1725    {
1726       DU_LOG("\nDEBUG  -->  F1AP : Created APER encoded buffer for DL RRC Message transfer\n");
1727       for(int i=0; i< encBufSize; i++)
1728       {
1729          DU_LOG("%x",encBuf[i]);
1730       }
1731    }
1732
1733    /* Sending  msg  */
1734    if(SendF1APMsg(CU_APP_MEM_REG,CU_POOL, duId)  !=  ROK)
1735    {
1736       DU_LOG("\nERROR  -->  F1AP : Sending  DL RRC Message Transfer Failed");
1737       return RFAILED;
1738    }
1739    freeDlRrcMessageTransfer(f1apMsg);
1740    return ROK;
1741 }/* End of BuildAndSendDLRRCMessageTransfer */
1742
1743 /*******************************************************************
1744  *
1745  * @brief Function to set the Dl RRC Msg Type
1746  *
1747  * @details
1748  *
1749  *    Function : setDlRRCMsgType
1750  *
1751  *    Functionality: Constructs the UE Setup Response and sends
1752  *                   it to the DU through SCTP.
1753  *
1754  * @params[in]
1755  *
1756  * @return ROK     - success
1757  *         RFAILED - failure
1758  *
1759  * ****************************************************************/
1760
1761 uint8_t setDlRRCMsgType(CuUeCb *ueCb)
1762 {
1763    uint8_t rrcMsgType = 0;
1764    switch(ueCb->f1apMsgDb.dlRrcMsgCount)
1765    {
1766       case RRC_SETUP:
1767          rrcMsgType = RRC_SETUP;
1768          break;
1769       case REGISTRATION_ACCEPT:
1770          rrcMsgType = REGISTRATION_ACCEPT;
1771          break;
1772       case UE_CONTEXT_SETUP_REQ:
1773          rrcMsgType = UE_CONTEXT_SETUP_REQ;
1774          break;
1775       case SECURITY_MODE_COMPLETE:
1776          rrcMsgType = SECURITY_MODE_COMPLETE;
1777          break;
1778       case RRC_RECONFIG:
1779          rrcMsgType = RRC_RECONFIG;
1780          break;
1781       case RRC_RECONFIG_COMPLETE:
1782          rrcMsgType = RRC_RECONFIG_COMPLETE;
1783          break;
1784       case UE_CONTEXT_MOD_REQ:
1785          rrcMsgType = UE_CONTEXT_MOD_REQ;
1786          break;
1787       default:
1788          break;
1789    }
1790    return rrcMsgType;
1791 }
1792
1793 /*******************************************************************
1794  *
1795  * @brief Extract configuration from CellGroupConfig
1796  *
1797  * @details
1798  *
1799  *    Function : extractCellGroupConfig
1800  *
1801  *    Functionality: Extract configuration from CellGroupConfig
1802  *        and store in local database
1803  *
1804  * @params[in] UE control block
1805  *             Cell Group Config
1806  *
1807  * @return ROK     - success
1808  *         RFAILED - failure
1809  *
1810  * ****************************************************************/
1811 uint8_t extractCellGroupConfig(CuUeCb *ueCb, CellGroupConfigRrc_t *cellGrpCfg)
1812 {
1813    uint8_t rbIdx, srbIdx, drbIdx;
1814    bool    srbFound, drbFound;
1815    SrbInfo *srbCfgDb = NULLP;
1816    DrbInfo *drbCfgDb = NULLP;
1817    RlcLcCfg *rlcLcCfgDb = NULLP;
1818    MacLcCfg *macLcCfgDb = NULLP;
1819    RLC_BearerConfig_t *rlcCfg = NULLP;
1820    RLC_Config_t *rlcLcCfg = NULLP;
1821    LogicalChannelConfig_t *macLcCfg = NULLP;
1822
1823    if(ueCb == NULLP)
1824    {
1825       DU_LOG("\nERROR  -->  F1AP: extractCellGroupConfig(): UE Cb is NULL");
1826       return RFAILED;
1827    }
1828
1829    if(cellGrpCfg == NULLP)
1830    {
1831       DU_LOG("\nERROR  -->  F1AP: extractCellGroupConfig(): cellGrpCfg is NULL");
1832       return RFAILED;
1833    }
1834
1835    for(rbIdx = 0; rbIdx < cellGrpCfg->rlc_BearerToAddModList->list.count; rbIdx++)
1836    {
1837       srbFound = false;
1838       drbFound = false;
1839
1840       rlcCfg = cellGrpCfg->rlc_BearerToAddModList->list.array[rbIdx];
1841
1842       /* Update SRB configuration in local DB */
1843       if(rlcCfg->servedRadioBearer->present == RLC_BearerConfig__servedRadioBearer_PR_srb_Identity)
1844       {
1845          /* Search if SRB entry is already present in DB */
1846          for(srbIdx = 0; srbIdx < ueCb->numSrb; srbIdx++)
1847          {
1848             if(ueCb->srbList[srbIdx].srbId == rlcCfg->servedRadioBearer->choice.srb_Identity)
1849             {
1850               srbCfgDb = &ueCb->srbList[srbIdx];
1851               srbFound = true;
1852               break;
1853             }
1854          }
1855
1856          /* If not, add SRB to UE CB's SRB list */
1857          if(!srbFound)
1858          {
1859             ueCb->srbList[ueCb->numSrb].srbId = rlcCfg->servedRadioBearer->choice.srb_Identity;
1860             srbCfgDb = &ueCb->srbList[ueCb->numSrb];
1861             ueCb->numSrb++;
1862          }
1863
1864          srbCfgDb->lcId = rlcCfg->logicalChannelIdentity;
1865          srbCfgDb->cfgSentToUe = false;
1866          rlcLcCfgDb = &srbCfgDb->rlcLcCfg;
1867          macLcCfgDb = &srbCfgDb->macLcCfg;
1868       }
1869
1870       /* Update DRB configuration in local DB */
1871       if(rlcCfg->servedRadioBearer->present == RLC_BearerConfig__servedRadioBearer_PR_drb_Identity)
1872       {
1873          /* Search if DRB entry is already present in DB */
1874          for(drbIdx = 0; drbIdx < ueCb->numDrb; drbIdx++)
1875          {
1876             if(ueCb->drbList[drbIdx].drbId == rlcCfg->servedRadioBearer->choice.drb_Identity)
1877             {
1878               drbCfgDb = &ueCb->drbList[drbIdx];
1879               drbFound = true;
1880               break;
1881             }
1882          }
1883
1884          /* If not, add DRB to UE CB's SRB list */
1885          if(!drbFound)
1886          {
1887             ueCb->drbList[ueCb->numDrb].drbId = rlcCfg->servedRadioBearer->choice.drb_Identity;
1888             drbCfgDb = &ueCb->drbList[ueCb->numDrb];
1889             ueCb->numDrb++;
1890          }
1891
1892          drbCfgDb->lcId = rlcCfg->logicalChannelIdentity;
1893          drbCfgDb->cfgSentToUe = false;
1894          rlcLcCfgDb = &drbCfgDb->rlcLcCfg;
1895          macLcCfgDb = &drbCfgDb->macLcCfg;
1896       }
1897
1898
1899       /* Update RLC configuration for this RB */
1900       rlcLcCfg = rlcCfg->rlc_Config;
1901       rlcLcCfgDb->rlcMode = rlcLcCfg->present;
1902       switch(rlcLcCfgDb->rlcMode)
1903       {
1904          case RLC_Config_PR_am:
1905             {
1906                rlcLcCfgDb->u.amCfg.ulAmCfg.snLenUl = *(rlcLcCfg->choice.am->ul_AM_RLC.sn_FieldLength);
1907                rlcLcCfgDb->u.amCfg.ulAmCfg.pollRetxTmr = rlcLcCfg->choice.am->ul_AM_RLC.t_PollRetransmit ;
1908                rlcLcCfgDb->u.amCfg.ulAmCfg.pollPdu = rlcLcCfg->choice.am->ul_AM_RLC.pollPDU ;
1909                rlcLcCfgDb->u.amCfg.ulAmCfg.pollByte = rlcLcCfg->choice.am->ul_AM_RLC.pollByte ;
1910                rlcLcCfgDb->u.amCfg.ulAmCfg.maxRetxTh = rlcLcCfg->choice.am->ul_AM_RLC.maxRetxThreshold ;
1911
1912                rlcLcCfgDb->u.amCfg.dlAmCfg.snLenDl = *(rlcLcCfg->choice.am->dl_AM_RLC.sn_FieldLength);
1913                rlcLcCfgDb->u.amCfg.dlAmCfg.reAssemTmr = rlcLcCfg->choice.am->dl_AM_RLC.t_Reassembly;
1914                rlcLcCfgDb->u.amCfg.dlAmCfg.statProhTmr = rlcLcCfg->choice.am->dl_AM_RLC.t_StatusProhibit;
1915                break;
1916             }
1917
1918          case RLC_Config_PR_um_Bi_Directional:
1919             {
1920                rlcLcCfgDb->u.umBiDirCfg.ulUmCfg.snLenUlUm = *(rlcLcCfg->choice.um_Bi_Directional->ul_UM_RLC.sn_FieldLength);
1921
1922                rlcLcCfgDb->u.umBiDirCfg.dlUmCfg.snLenDlUm = *(rlcLcCfg->choice.um_Bi_Directional->dl_UM_RLC.sn_FieldLength);
1923                rlcLcCfgDb->u.umBiDirCfg.dlUmCfg.reAssemTmr = rlcLcCfg->choice.um_Bi_Directional->dl_UM_RLC.t_Reassembly;
1924                break;
1925             }
1926       }
1927
1928       /* Update MAC configuration for this LC */
1929       macLcCfg = rlcCfg->mac_LogicalChannelConfig;
1930       macLcCfgDb->priority = macLcCfg->ul_SpecificParameters->priority ;
1931       macLcCfgDb->lcGroup = *(macLcCfg->ul_SpecificParameters->logicalChannelGroup) ;
1932       macLcCfgDb->schReqId = *(macLcCfg->ul_SpecificParameters->schedulingRequestID) ;
1933       macLcCfgDb->pbr = macLcCfg->ul_SpecificParameters->prioritisedBitRate ;
1934       macLcCfgDb->bsd = macLcCfg->ul_SpecificParameters->bucketSizeDuration ;
1935    }
1936    return ROK;
1937 }
1938
1939 /*******************************************************************
1940  *
1941  * @brief Function to decode DU to CU RRC container
1942  *
1943  * @details
1944  *
1945  *    Function : extractDuToCuRrcCont
1946  *
1947  *    Functionality: Function to decode DU to CU RRC container
1948  *
1949  * @params[in] UE Cb
1950  *             RRC conatiner octect string to be decoded
1951  *
1952  * @return ROK     - success
1953  *         RFAILED - failure
1954  *
1955  * ****************************************************************/
1956 uint8_t extractDuToCuRrcCont(CuUeCb *ueCb, OCTET_STRING_t rrcCont)
1957 {
1958    CellGroupConfigRrc_t  cellGrpCfg, *cellGrpCfgMsg = NULLP;
1959    asn_dec_rval_t rval; /* Decoder return value */
1960
1961    /* Decoding DU to CU RRC container octet string to cell group config */
1962    cellGrpCfgMsg = &cellGrpCfg;
1963    memset(cellGrpCfgMsg, 0, sizeof(CellGroupConfigRrc_t));
1964
1965    rval = aper_decode(0, &asn_DEF_CellGroupConfigRrc, (void **)&cellGrpCfgMsg, rrcCont.buf, rrcCont.size, 0, 0);
1966
1967    if(rval.code == RC_FAIL || rval.code == RC_WMORE)
1968    {
1969       DU_LOG("\nERROR  -->  F1AP : ASN decode failed");
1970       return RFAILED;
1971    }
1972    printf("\n");
1973    xer_fprint(stdout, &asn_DEF_CellGroupConfigRrc, cellGrpCfgMsg);
1974
1975    if((extractCellGroupConfig(ueCb, cellGrpCfgMsg)) != ROK)
1976    {
1977       DU_LOG("\nERROR  -->  F1AP : Failed to extract cell group config");
1978       return RFAILED;
1979    }
1980
1981    return ROK;
1982 }
1983
1984 /*******************************************************************
1985  *
1986  * @brief Function to build Initial UL RRC Message
1987  *
1988  * @details
1989  *
1990  *    Function : procInitULRRCMsg
1991  *
1992  *    Functionality: Function to build Initial UL RRC Message
1993  *
1994  * @params[in]
1995  *
1996  * @return ROK     - success
1997  *         RFAILED - failure
1998  *
1999  * ****************************************************************/
2000
2001 uint8_t procInitULRRCMsg(uint32_t duId, F1AP_PDU_t *f1apMsg)
2002 {
2003    uint8_t idx,cellIdx=0, duIdx=0, rrcMsgType, gnbDuUeF1apId;
2004    uint8_t ret =ROK;
2005    uint32_t nrCellId, crnti;
2006    DuDb     *duDb;
2007    CuCellCb *cellCb;
2008    CuUeCb   *ueCb;
2009    InitialULRRCMessageTransfer_t *initULRRCMsg = NULLP;
2010
2011    DU_LOG("\nINFO   -->  F1AP : filling the required values in DB in procInitULRRCMsg");
2012
2013    SEARCH_DU_DB(duIdx, duId, duDb);
2014    initULRRCMsg = &f1apMsg->choice.initiatingMessage->value.choice.InitialULRRCMessageTransfer;
2015
2016    for(idx=0; idx < initULRRCMsg->protocolIEs.list.count; idx++)
2017    {
2018       switch(initULRRCMsg->protocolIEs.list.array[idx]->id)
2019       {
2020          case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
2021             gnbDuUeF1apId = initULRRCMsg->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID;
2022             break;
2023
2024          case ProtocolIE_ID_id_NRCGI:
2025             nrCellId = initULRRCMsg->protocolIEs.list.array[idx]->value.choice.NRCGI.nRCellIdentity.buf[4] >>
2026                initULRRCMsg->protocolIEs.list.array[idx]->value.choice.NRCGI.nRCellIdentity.bits_unused;
2027             SEARCH_CELL_DB(cellIdx, duDb, nrCellId, cellCb);
2028             if(cellCb == NULLP)
2029                return RFAILED;
2030             break;
2031
2032          case ProtocolIE_ID_id_C_RNTI:
2033             crnti = initULRRCMsg->protocolIEs.list.array[idx]->value.choice.C_RNTI;
2034             if(duDb->ueCb[gnbDuUeF1apId-1].gnbDuUeF1apId == 0)
2035             {
2036                ueCb = &duDb->ueCb[gnbDuUeF1apId-1];
2037                memset(ueCb, 0, sizeof(CuUeCb));
2038                ueCb->cellCb = cellCb;
2039                ueCb->crnti = crnti;
2040                ueCb->gnbDuUeF1apId = gnbDuUeF1apId;
2041                ueCb->gnbCuUeF1apId = ++cuCb.gnbCuUeF1apIdGenerator;
2042                ueCb->state = UE_ATTACH_IN_PROGRESS;
2043                (duDb->numUe)++;
2044
2045                cellCb->ueCb[cellCb->numUe] = ueCb;
2046                cellCb->numUe++;
2047             }
2048             break;
2049
2050          case ProtocolIE_ID_id_RRCContainer:
2051             break;
2052
2053          case ProtocolIE_ID_id_DUtoCURRCContainer:
2054             {
2055                if((initULRRCMsg->protocolIEs.list.array[idx]->value.choice.DUtoCURRCContainer.size > 0) && \
2056                   (initULRRCMsg->protocolIEs.list.array[idx]->value.choice.DUtoCURRCContainer.buf != NULLP))
2057                {
2058                   DU_LOG("\nINFO  -->  Received Du to Cu RRC Container ");
2059                   ueCb->f1apMsgDb.duToCuContainer.size = initULRRCMsg->protocolIEs.list.array[idx]->value.choice.DUtoCURRCContainer.size;
2060                   CU_ALLOC(ueCb->f1apMsgDb.duToCuContainer.buf, ueCb->f1apMsgDb.duToCuContainer.size);
2061                   if(ueCb->f1apMsgDb.duToCuContainer.buf != NULLP)
2062                   {
2063                      memcpy(ueCb->f1apMsgDb.duToCuContainer.buf, \
2064                         initULRRCMsg->protocolIEs.list.array[idx]->value.choice.DUtoCURRCContainer.buf, \
2065                         ueCb->f1apMsgDb.duToCuContainer.size);
2066                   }
2067                   if((extractDuToCuRrcCont(ueCb, initULRRCMsg->protocolIEs.list.array[idx]->value.choice.DUtoCURRCContainer)) != ROK)
2068                   {
2069                      DU_LOG("\nERROR  --> F1AP : Failed to extract DU to CU RRC Container ");
2070                      ret = RFAILED;
2071                   }
2072                }
2073                else
2074                {
2075                   DU_LOG("\nERROR  -->  Failed to receive Du to Cu RRC Container ");
2076                   ret = RFAILED;
2077                }
2078                break;
2079             }
2080
2081          default:
2082             DU_LOG("\nERROR  -->  Invalid Event %ld", initULRRCMsg->protocolIEs.list.array[idx]->id);
2083             break;
2084       }
2085       if(ret == RFAILED)
2086          break;
2087    }
2088
2089    if(ret == ROK)
2090    {
2091       ueCb->f1apMsgDb.dlRrcMsgCount++;
2092       rrcMsgType = setDlRRCMsgType(ueCb);
2093       ret = BuildAndSendDLRRCMessageTransfer(duId, ueCb, SRB0, rrcMsgType);
2094    }
2095    return ret;
2096 }
2097
2098 /*******************************************************************
2099  *
2100  * @brief Builds Nrcgi
2101  *
2102  * @details
2103  *
2104  *    Function : BuildNrcgi
2105  *
2106  *    Functionality: Building the PLMN ID and NR Cell id
2107  *
2108  * @params[in] NRCGI_t *nrcgi
2109  * @return ROK     - success
2110  *         RFAILED - failure
2111  *
2112  * ****************************************************************/
2113 uint8_t BuildNrcgi(NRCGI_t *nrcgi, uint32_t nrCellId)
2114 {
2115    uint8_t ret;
2116    uint8_t unused_bits = 4;
2117    uint8_t byteSize = 5;
2118    uint8_t val = nrCellId << unused_bits;
2119
2120    /* Allocate Buffer Memory */
2121    nrcgi->pLMN_Identity.size = 3 * sizeof(uint8_t);
2122    CU_ALLOC(nrcgi->pLMN_Identity.buf, nrcgi->pLMN_Identity.size);
2123    if(nrcgi->pLMN_Identity.buf == NULLP)
2124    {
2125       return RFAILED;
2126    }
2127    ret = buildPlmnId(cuCb.cuCfgParams.plmn , nrcgi->pLMN_Identity.buf);
2128
2129    if(ret != ROK)
2130    {
2131       return RFAILED;
2132    }
2133    nrcgi->nRCellIdentity.size = byteSize * sizeof(uint8_t);
2134    CU_ALLOC(nrcgi->nRCellIdentity.buf, nrcgi->nRCellIdentity.size);
2135    if(nrcgi->nRCellIdentity.buf == NULLP)
2136    {
2137       return RFAILED;
2138    }
2139    fillBitString(&nrcgi->nRCellIdentity, unused_bits, byteSize, val);
2140
2141    return ROK;
2142 }
2143 /*******************************************************************
2144  *
2145  * @brief Builds Special cell list for UE Setup Request
2146  *
2147  * @details
2148  *
2149  *    Function : BuildSplCellList
2150  *
2151  *    Functionality: Constructs the Special Cell list for UESetReq
2152  *
2153  * @params[in] SCell_ToBeSetup_List_t *spCellLst
2154  *
2155  * @return ROK     - success
2156  *         RFAILED - failure
2157  *
2158  * ****************************************************************/
2159 uint8_t BuildSplCellList(CuUeCb *ueCb, SCell_ToBeSetup_List_t *spCellLst)
2160 {
2161    uint8_t  cellCnt;
2162    uint8_t  idx;
2163    uint8_t  ret;
2164    cellCnt = 1;
2165    spCellLst->list.count = cellCnt;
2166    spCellLst->list.size = cellCnt * sizeof(SCell_ToBeSetup_ItemIEs_t *);
2167    CU_ALLOC(spCellLst->list.array,spCellLst->list.size);
2168    if(spCellLst->list.array == NULLP)
2169    {
2170       return RFAILED;
2171    }
2172    for(idx=0; idx<cellCnt; idx++)
2173    {
2174       CU_ALLOC(spCellLst->list.array[idx],sizeof(SCell_ToBeSetup_ItemIEs_t));
2175       if(spCellLst->list.array[idx] == NULLP)
2176       {
2177          return RFAILED;
2178       }
2179    }
2180    idx = 0;
2181    spCellLst->list.array[idx]->id = ProtocolIE_ID_id_SCell_ToBeSetup_Item;
2182    spCellLst->list.array[idx]->criticality = Criticality_ignore;
2183    spCellLst->list.array[idx]->value.present = SCell_ToBeSetup_ItemIEs__value_PR_SCell_ToBeSetup_Item;
2184
2185    /* Special Cell ID -NRCGI */
2186    ret = BuildNrcgi(&spCellLst->list.array[idx]->value.choice.SCell_ToBeSetup_Item.sCell_ID, ueCb->cellCb->nrCellId);
2187    if(ret != ROK)
2188    {
2189       return RFAILED;
2190    }
2191    /*Special Cell Index*/
2192    spCellLst->list.array[idx]->value.choice.SCell_ToBeSetup_Item.sCellIndex = 1;
2193    return ROK;
2194 }/* End of BuildSplCellList*/
2195
2196 /*******************************************************************
2197  *
2198  * @brief Builds SRBS to be setup
2199  *
2200  * @details
2201  *
2202  *    Function : BuildSRBSetup
2203  *
2204  *    Functionality: Constructs the SRB's for UESetReq
2205  *
2206  * @params[in] SRBs_ToBeSetup_List_t *srbSet
2207  *
2208  * @return ROK     - success
2209  *         RFAILED - failure
2210  *
2211  * ****************************************************************/
2212 uint8_t BuildSRBSetup(CuUeCb *ueCb, SRBs_ToBeSetup_List_t *srbSet)
2213 {
2214    uint8_t idx;
2215    uint8_t srbCnt;
2216
2217    if(ueCb->state == UE_HANDOVER_IN_PROGRESS)
2218       srbCnt = ueCb->numSrb;
2219    else
2220       srbCnt = 1;
2221    srbSet->list.count = srbCnt;
2222    srbSet->list.size = srbCnt*sizeof(SRBs_ToBeSetup_ItemIEs_t *);
2223    CU_ALLOC(srbSet->list.array,srbSet->list.size);
2224    if(srbSet->list.array == NULLP)
2225    {
2226       DU_LOG("\nERROR  --> F1AP : BuildSRBSetup() : Memory allocation failed for SRB to be setup list's array");
2227       return RFAILED;
2228    }
2229
2230    for(idx=0; idx<srbCnt; idx++)
2231    {
2232       CU_ALLOC(srbSet->list.array[idx],sizeof(SRBs_ToBeSetup_ItemIEs_t));
2233       if(srbSet->list.array[idx] == NULLP)
2234       {
2235          DU_LOG("\nERROR  --> F1AP : BuildSRBSetup() : Memory allocation failed for SRB to be setup list's array element");
2236          return RFAILED;
2237       }
2238    }
2239
2240    if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
2241    {
2242       idx = 0;
2243       srbSet->list.array[idx]->id = ProtocolIE_ID_id_SRBs_ToBeSetup_Item;
2244       srbSet->list.array[idx]->criticality = Criticality_ignore;
2245       srbSet->list.array[idx]->value.present = SRBs_ToBeSetup_ItemIEs__value_PR_SRBs_ToBeSetup_Item;
2246       srbSet->list.array[idx]->value.choice.SRBs_ToBeSetup_Item.sRBID = 2;
2247       ueCb->srbList[ueCb->numSrb].srbId = srbSet->list.array[idx]->value.choice.SRBs_ToBeSetup_Item.sRBID;
2248       ueCb->numSrb++;
2249    }
2250    else
2251    {
2252       for(idx=0; idx<srbCnt; idx++)
2253       {
2254          srbSet->list.array[idx]->id = ProtocolIE_ID_id_SRBs_ToBeSetup_Item;
2255          srbSet->list.array[idx]->criticality = Criticality_ignore;
2256          srbSet->list.array[idx]->value.present = SRBs_ToBeSetup_ItemIEs__value_PR_SRBs_ToBeSetup_Item;
2257          srbSet->list.array[idx]->value.choice.SRBs_ToBeSetup_Item.sRBID = ueCb->srbList[idx].srbId;
2258       }
2259    }
2260    return ROK;
2261 }/* End of BuildSRBSetup*/
2262
2263 /*******************************************************************
2264  *
2265  * @brief Builds QOS Info for DRB Setum Item
2266  *
2267  * @details
2268  *
2269  *    Function : BuildQOSInfo
2270  *
2271  *    Functionality: Constructs the QOS Info for DRB Setup Item
2272  *
2273  * @params[in] QoSInformation_t *qosinfo
2274  *             int16_t pduSessionID
2275  *
2276  * @return ROK     - success
2277  *         RFAILED - failure
2278  *
2279  * ****************************************************************/
2280 uint8_t BuildQOSInfo(QosInfo *qosInfo, QoSFlowLevelQoSParameters_t *drbQos, uint8_t actionType, int16_t pduSessionID, bool hoInProgress)
2281 {
2282    uint8_t elementCnt = 0, qosCntIdx = 0;
2283    ProtocolExtensionContainer_4624P74_t *qosIeExt = NULLP;
2284
2285    /* NonDynamic5QIDescriptor */
2286    drbQos->qoS_Characteristics.present = QoS_Characteristics_PR_non_Dynamic_5QI;
2287    CU_ALLOC(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI,sizeof(NonDynamic5QIDescriptor_t));
2288    if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI == NULLP)
2289    {
2290       return RFAILED;
2291    }
2292
2293    if(hoInProgress)
2294       drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->fiveQI = qosInfo->nonDynFiveQI ;
2295    else
2296    {
2297       /*FiveQI*/
2298       if(actionType == ProtocolIE_ID_id_DRBs_ToBeModified_Item)
2299          drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->fiveQI = FIVE_QI_VALUE8;
2300       else
2301          drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->fiveQI = FIVE_QI_VALUE9;
2302
2303       qosInfo->nonDynFiveQI = drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->fiveQI;
2304    }
2305
2306    if(!hoInProgress)
2307    {
2308       /*AveragingWindow*/
2309       CU_ALLOC(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow, sizeof(AveragingWindow_t));
2310       if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow == NULLP)
2311       {
2312          return RFAILED;
2313       }
2314       *(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow) = 0;
2315       qosInfo->avgWindow = *(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow);
2316
2317       /*MaxDataBurstVolume*/
2318       CU_ALLOC(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume, sizeof(MaxDataBurstVolume_t));
2319       if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume == NULLP)
2320       {
2321          return RFAILED;
2322       }
2323       *(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume) = 0;
2324       qosInfo->maxBurstDataVol = *(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume);
2325    }
2326
2327    /*nRGRAN Allocation Retention Priority*/
2328    if(hoInProgress)
2329    {
2330       drbQos->nGRANallocationRetentionPriority.priorityLevel = qosInfo->priorityLevel;
2331       drbQos->nGRANallocationRetentionPriority.pre_emptionCapability = qosInfo->preemptionCapability;
2332       drbQos->nGRANallocationRetentionPriority.pre_emptionVulnerability = qosInfo->preemptionVulnerability;
2333    }
2334    else
2335    {
2336       drbQos->nGRANallocationRetentionPriority.priorityLevel = PriorityLevel_lowest;
2337       drbQos->nGRANallocationRetentionPriority.pre_emptionCapability = Pre_emptionCapability_may_trigger_pre_emption;
2338       drbQos->nGRANallocationRetentionPriority.pre_emptionVulnerability = Pre_emptionVulnerability_not_pre_emptable;
2339
2340       qosInfo->priorityLevel = PriorityLevel_lowest;
2341       qosInfo->preemptionCapability = Pre_emptionCapability_may_trigger_pre_emption;
2342       qosInfo->preemptionVulnerability = Pre_emptionVulnerability_not_pre_emptable;
2343    }
2344
2345    /* PDU session ID */
2346    if(!hoInProgress)
2347    {
2348       /*If PDU Session ID is INVALID thus not to be included in Qos IE, skip the PDU Session IE */
2349       if(pduSessionID <= INVALID_PDU_SESSION_ID)
2350       {
2351          DU_LOG("\nINFO  --> F1AP : Invalid PDU_SESSION_ID");
2352          return ROK;
2353       }
2354
2355       CU_ALLOC(drbQos->iE_Extensions, sizeof(ProtocolExtensionContainer_4624P74_t));
2356       qosIeExt = (ProtocolExtensionContainer_4624P74_t *)drbQos->iE_Extensions;
2357
2358       if(qosIeExt)
2359       {
2360          elementCnt = NUM_QOS_EXT;
2361          qosIeExt->list.count = elementCnt;
2362          qosIeExt->list.size = elementCnt * sizeof(QoSFlowLevelQoSParameters_ExtIEs_t *);
2363
2364          /*Initialize QoSFlowLevelQoSParameters_ExtIEs_t*/
2365          CU_ALLOC(qosIeExt->list.array, qosIeExt->list.size);
2366
2367          if(qosIeExt->list.array == NULLP)
2368          {
2369             DU_LOG("\nERROR  -->        F1AP : Memory allocation for QoSFlowLevelQoSParameters_ExtIEs_t failed");
2370             return  RFAILED;
2371          }
2372
2373          for(qosCntIdx=0; qosCntIdx < elementCnt; qosCntIdx++)
2374          {
2375             CU_ALLOC(qosIeExt->list.array[qosCntIdx], sizeof(QoSFlowLevelQoSParameters_ExtIEs_t));
2376             if(qosIeExt->list.array[qosCntIdx] == NULLP)
2377             {
2378                DU_LOG("\nERROR  -->     F1AP : Memory allocation for QoSFlowLevelQoSParameters_ExtIEs_t array failed");
2379                return  RFAILED;
2380             }
2381             /*Filling QoSFlowLevelQoSParameters_ExtIEs_t*/
2382             qosIeExt->list.array[qosCntIdx]->id = ProtocolIE_ID_id_PDUSessionID;
2383             /*Below Criticality mentioned in Spec38.473, 15.4.1 and later*/
2384             qosIeExt->list.array[qosCntIdx]->criticality = Criticality_ignore;
2385             qosIeExt->list.array[qosCntIdx]->extensionValue.present = \
2386                                                                       QoSFlowLevelQoSParameters_ExtIEs__extensionValue_PR_PDUSessionID;
2387             qosIeExt->list.array[qosCntIdx]->extensionValue.choice.PDUSessionID = (PDUSessionID_t)pduSessionID;
2388             qosInfo->pduSessionId = pduSessionID;
2389          }
2390       }
2391       else
2392       {
2393          DU_LOG("\nERROR  -->   F1AP : Memory allocation for QosIE_extension failed");
2394          return RFAILED;
2395       }
2396    }
2397    return ROK;
2398 }/*End of BuildQOSInfo*/
2399
2400 /*******************************************************************
2401  *
2402  * @brief Builds SNSSAI
2403  *
2404  * @details
2405  *
2406  *    Function : BuildSNSSAI
2407  *
2408  *    Functionality: Constructs the SNSSAI For DRB list
2409  *
2410  * @params[in] SNSSAI_t *snssai
2411  *             Snssai  *snssaiToCopy S-NSSAI from CuCfgParam to be copied
2412  *
2413  * @return ROK     - success
2414  *         RFAILED - failure
2415  *
2416  * ****************************************************************/
2417 uint8_t BuildSNSSAI(DrbInfo *drbInfo, SNSSAI_t *snssai, Snssai *snssaiToCopy, bool hoInProgress)
2418 {
2419    /*SNSSAI*/
2420    /*ssT*/
2421    snssai->sST.size = sizeof(uint8_t);
2422    CU_ALLOC(snssai->sST.buf, snssai->sST.size);
2423    if(snssai->sST.buf == NULLP)
2424    {
2425       return RFAILED;
2426    }
2427    if(!hoInProgress)
2428       memcpy(snssai->sST.buf, &snssaiToCopy->sst, snssai->sST.size);
2429    else
2430       memcpy(snssai->sST.buf, &drbInfo->snssai->sst, snssai->sST.size);
2431
2432    /*sD*/
2433    CU_ALLOC(snssai->sD, sizeof(OCTET_STRING_t));
2434    if(snssai->sD == NULLP)
2435    {
2436       return RFAILED;
2437    }
2438    snssai->sD->size = 3 * sizeof(uint8_t);
2439    CU_ALLOC(snssai->sD->buf, snssai->sD->size);
2440    if(snssai->sD->buf == NULLP)
2441    {
2442       return RFAILED;
2443    }
2444    if(!hoInProgress)
2445       memcpy(snssai->sD->buf, snssaiToCopy->sd, snssai->sD->size);
2446    else
2447       memcpy(snssai->sD->buf, drbInfo->snssai->sd, snssai->sD->size);
2448
2449    if(!hoInProgress)
2450       drbInfo->snssai = snssaiToCopy;
2451    return ROK;
2452 }/*End of BuildSNSSAI*/
2453
2454 /*******************************************************************
2455  *
2456  * @brief Builds the flow map.
2457  *
2458  * @details
2459  *
2460  *    Function : BuildFlowsMap
2461  *
2462  *    Functionality: Constructs the flowmap For DRB list
2463  *
2464  * @params[in] Flows_Mapped_To_DRB_List_t *flowMap
2465  *
2466  * @return ROK     - success
2467  *         RFAILED - failure
2468  *
2469  * ****************************************************************/
2470 uint8_t BuildFlowsMap(DrbInfo *drbInfo, Flows_Mapped_To_DRB_List_t *flowMap , uint8_t actionType, bool hoInProgress)
2471 {
2472    uint8_t  ret = ROK, idx = 0, flowCnt = 0, flowIdx = 0;
2473    FlowsMapped *qosFlow;
2474
2475    if(!hoInProgress)
2476       flowCnt = 1;
2477    else
2478       flowCnt = drbInfo->numFlowMap;
2479    flowMap->list.count = flowCnt;
2480    flowMap->list.size = flowCnt * sizeof(Flows_Mapped_To_DRB_Item_t *);
2481    CU_ALLOC(flowMap->list.array,flowMap->list.size);
2482    if(flowMap->list.array == NULLP)
2483    {
2484       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed for array in BuildFlowsMap()");
2485       return RFAILED;
2486    }
2487    for(idx=0; idx<flowCnt; idx++)
2488    {
2489       CU_ALLOC(flowMap->list.array[idx],sizeof(Flows_Mapped_To_DRB_Item_t));
2490       if(flowMap->list.array[idx] == NULLP)
2491       {
2492          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed for arrayIdx[%d] in BuildFlowsMap()", idx);
2493          return RFAILED;
2494       }
2495
2496       if(!hoInProgress)
2497       {
2498          flowMap->list.array[idx]->qoSFlowIdentifier = 0;
2499          if(actionType == ProtocolIE_ID_id_DRBs_ToBeModified_Item)
2500          {
2501             for(flowIdx =0; flowIdx < drbInfo->numFlowMap; flowIdx++)
2502             {
2503                if(drbInfo->flowMapList[flowIdx].qosFlowId == flowMap->list.array[idx]->qoSFlowIdentifier)
2504                {
2505                   qosFlow = &drbInfo->flowMapList[flowIdx];
2506                   break;
2507                }
2508             }
2509          }
2510          else
2511          {
2512             qosFlow = &drbInfo->flowMapList[drbInfo->numFlowMap];
2513             qosFlow->qosFlowId = flowMap->list.array[idx]->qoSFlowIdentifier;
2514          }
2515       }
2516       else
2517       {
2518          qosFlow = &drbInfo->flowMapList[idx];
2519          flowMap->list.array[idx]->qoSFlowIdentifier = qosFlow->qosFlowId;
2520       }
2521
2522       ret = BuildQOSInfo(&qosFlow->qos, &flowMap->list.array[idx]->qoSFlowLevelQoSParameters,\
2523             actionType, INVALID_PDU_SESSION_ID, hoInProgress);
2524       if(ret != ROK)
2525       {
2526          DU_LOG("\nERROR  -->  F1AP : Failed to Build QOS Info in BuildFlowsMap()");
2527          return RFAILED;
2528       }
2529
2530       if((!hoInProgress) && (actionType != ProtocolIE_ID_id_DRBs_ToBeModified_Item))
2531          drbInfo->numFlowMap++;
2532    }
2533    return ROK;
2534 }/*End of BuildFlowsMap*/
2535
2536 /*******************************************************************
2537  *
2538  * @brief Builds the Uplink Tunnel Info
2539  *
2540  * @details
2541  *
2542  *    Function : BuildULTnlInfo
2543  *
2544  *    Functionality: Constructs the UL TnlInfo For DRB list
2545  *
2546  * @params[in]  UPTNLInformation_ToBeSetup_List_t *ulInfo
2547  *
2548  * @return ROK     - success
2549  *         RFAILED - failure
2550  *
2551  * ****************************************************************/
2552 uint8_t BuildULTnlInfo(TnlInfo *ulUpTnlInfo, ULUPTNLInformation_ToBeSetup_List_t *ulInfo, bool hoInProgress)
2553 {
2554    uint8_t idx;
2555    uint8_t ulCnt;
2556
2557    ulCnt = 1;
2558    ulInfo->list.count = ulCnt;
2559    ulInfo->list.size = ulCnt * sizeof(ULUPTNLInformation_ToBeSetup_Item_t *);
2560    CU_ALLOC(ulInfo->list.array,ulInfo->list.size);
2561    if(ulInfo->list.array == NULLP)
2562    {
2563       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed for array in BuildULTnlInfo()");
2564       return RFAILED;
2565    }
2566    for(idx=0; idx<ulCnt; idx++)
2567    {
2568       CU_ALLOC(ulInfo->list.array[idx],sizeof(ULUPTNLInformation_ToBeSetup_Item_t));
2569       if(ulInfo->list.array[idx] == NULLP)
2570       {
2571          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed for arrayIdx [%d] in BuildULTnlInfo()", idx);
2572               return RFAILED;
2573       }
2574    }
2575    idx = 0;
2576    ulInfo->list.array[idx]->uLUPTNLInformation.present = UPTransportLayerInformation_PR_gTPTunnel;
2577    /*GTP TUNNEL*/
2578    CU_ALLOC(ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel, sizeof(GTPTunnel_t));
2579    if(ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel == NULLP)
2580    {
2581       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed for gTPTunnel in BuildULTnlInfo()");
2582       return RFAILED;
2583    }
2584    ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.size     = 4*sizeof(uint8_t);
2585    CU_ALLOC(ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf, \
2586       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.size);
2587    if(ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf == NULLP)
2588    {
2589       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed for gtp tunnel arrayIdx[%d] in BuildULTnlInfo()", idx);
2590       return RFAILED;
2591    }
2592
2593    if(!hoInProgress)
2594    {
2595       /* NOTE: Below IP address must be changed if running on different IP configuration */
2596       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[0] = 192;
2597       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[1] = 168;
2598       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[2] = 130;
2599       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[3] = 82;
2600       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.bits_unused = 0;
2601
2602       ulUpTnlInfo->address[0] = ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[0];
2603       ulUpTnlInfo->address[1] = ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[1];
2604       ulUpTnlInfo->address[2] = ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[2];
2605       ulUpTnlInfo->address[3] = ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[3];
2606    }
2607    else
2608    {
2609       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[0] = ulUpTnlInfo->address[0];
2610       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[1] = ulUpTnlInfo->address[1];
2611       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[2] = ulUpTnlInfo->address[2];
2612       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[3] = ulUpTnlInfo->address[3];
2613       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.bits_unused = 0;
2614    }
2615
2616    /*GTP TEID*/
2617    ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.size = 4 * sizeof(uint8_t);
2618    CU_ALLOC(ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf, \
2619       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.size);
2620    if(ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf == NULLP)
2621    {
2622       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed for gtp tunnel buffer in BuildULTnlInfo()");
2623       return RFAILED;
2624    }
2625
2626    if(!hoInProgress)
2627    {
2628       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[0] = 0;
2629       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[1] = 0;
2630       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[2] = 0;
2631       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[3] = cuCb.cuCfgParams.egtpParams.currTunnelId++;
2632
2633       ulUpTnlInfo->teId[0] = ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[0];
2634       ulUpTnlInfo->teId[1] = ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[1];
2635       ulUpTnlInfo->teId[2] = ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[2];
2636       ulUpTnlInfo->teId[3] = ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[3];
2637    }
2638    else
2639    {
2640       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[0] = ulUpTnlInfo->teId[0];
2641       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[1] = ulUpTnlInfo->teId[1];
2642       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[2] = ulUpTnlInfo->teId[2];
2643       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[3] = ulUpTnlInfo->teId[3];
2644    }
2645    return ROK;
2646 }/*End of BuildULTnlInfo*/
2647
2648 /*******************************************************************
2649  *
2650  * @brief Builds DRBS to be setup
2651  *
2652  * @details
2653  *
2654  *    Function : BuildDRBSetup
2655  *
2656  *    Functionality: Constructs the DRB's for UESetReq
2657  *
2658  * @params[in] DRBs_ToBeSetup_List_t *drbSet
2659  *
2660  * @return ROK     - success
2661  *         RFAILED - failure
2662  *
2663  * ****************************************************************/
2664 uint8_t BuildDRBSetup(CuUeCb *ueCb, DRBs_ToBeSetup_List_t *drbSet)
2665 {
2666    uint8_t idx = 0, extIeIdx = 0;
2667    uint8_t elementCnt = 0, drbCnt = 0;
2668    uint8_t BuildQOSInforet = 0,BuildSNSSAIret = 0;
2669    uint8_t BuildFlowsMapret =0, BuildULTnlInforet =0;
2670    DRBs_ToBeSetup_Item_t *drbSetItem;
2671    ProtocolExtensionContainer_4624P33_t *drbToBeSetupExt;
2672    DRBs_ToBeSetup_ItemExtIEs_t *drbToBeSetupExtIe = NULLP;
2673
2674    if(ueCb->state == UE_HANDOVER_IN_PROGRESS)
2675       drbCnt = ueCb->numDrb;
2676    else
2677       drbCnt = MAX_DRB_SET_UE_CONTEXT_SETUP_REQ;
2678    drbSet->list.count = drbCnt;
2679
2680    drbSet->list.size = drbCnt*sizeof(DRBs_ToBeSetup_ItemIEs_t *);
2681    CU_ALLOC(drbSet->list.array,drbSet->list.size);
2682    if(drbSet->list.array == NULLP)
2683    {
2684       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDRBSetup");
2685       return RFAILED;
2686    }
2687
2688    for(idx=0; idx<drbCnt; idx++)
2689    {
2690       CU_ALLOC(drbSet->list.array[idx],sizeof(DRBs_ToBeSetup_ItemIEs_t));
2691       if(drbSet->list.array[idx] == NULLP)
2692       {
2693          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDRBSetup for arry idx [%d]", idx);
2694          return RFAILED;
2695       }
2696
2697       drbSet->list.array[idx]->id = ProtocolIE_ID_id_DRBs_ToBeSetup_Item;
2698       drbSet->list.array[idx]->criticality = Criticality_ignore;
2699       drbSet->list.array[idx]->value.present = DRBs_ToBeSetup_ItemIEs__value_PR_DRBs_ToBeSetup_Item;
2700       drbSetItem = &drbSet->list.array[idx]->value.choice.DRBs_ToBeSetup_Item;
2701       /*dRBID*/
2702       if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
2703       {
2704          drbSetItem->dRBID = idx + 1;
2705          ueCb->drbList[ueCb->numDrb].drbId = drbSetItem->dRBID;
2706       }
2707       else
2708          drbSetItem->dRBID = ueCb->drbList[idx].drbId;
2709
2710       /*qoSInformation*/
2711       drbSetItem->qoSInformation.present = QoSInformation_PR_choice_extension;
2712       CU_ALLOC(drbSetItem->qoSInformation.choice.choice_extension,sizeof(QoSInformation_ExtIEs_t));
2713       if(drbSetItem->qoSInformation.choice.choice_extension == NULLP)
2714       {
2715          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed for QOS choice extension in BuildDRBSetup");
2716          return RFAILED;
2717       }
2718       drbSetItem->qoSInformation.choice.choice_extension->id = ProtocolIE_ID_id_DRB_Information;
2719       drbSetItem->qoSInformation.choice.choice_extension->criticality = Criticality_ignore;
2720       drbSetItem->qoSInformation.choice.choice_extension->value.present = QoSInformation_ExtIEs__value_PR_DRB_Information;
2721       if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
2722          BuildQOSInforet =  BuildQOSInfo(&ueCb->drbList[ueCb->numDrb].qos, &drbSetItem->qoSInformation.choice.\
2723                choice_extension->value.choice.DRB_Information.dRB_QoS, ProtocolIE_ID_id_DRBs_ToBeSetup_Item, PDU_SESSION_ID_1, FALSE);
2724       else
2725          BuildQOSInforet =  BuildQOSInfo(&ueCb->drbList[idx].qos, &drbSetItem->qoSInformation.choice.\
2726                choice_extension->value.choice.DRB_Information.dRB_QoS, ProtocolIE_ID_id_DRBs_ToBeSetup_Item, PDU_SESSION_ID_1, TRUE);
2727       if(BuildQOSInforet != ROK)
2728       {
2729          DU_LOG("\nERROR  -->  F1AP : Failed to build QOS Info in BuildDRBSetup");
2730          return RFAILED;
2731       }
2732
2733       /*SNSSAI*/
2734       if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
2735          BuildSNSSAIret = BuildSNSSAI(&ueCb->drbList[ueCb->numDrb], &drbSetItem->qoSInformation.choice.\
2736                choice_extension->value.choice.DRB_Information.sNSSAI, cuCb.snssaiList[0], FALSE);
2737       else
2738          BuildSNSSAIret = BuildSNSSAI(&ueCb->drbList[idx], &drbSetItem->qoSInformation.choice.\
2739                choice_extension->value.choice.DRB_Information.sNSSAI, cuCb.snssaiList[0], TRUE);
2740       if(BuildSNSSAIret != ROK)
2741       {
2742          DU_LOG("\nERROR  -->  F1AP : Failed to build SNSSAI Info in BuildDRBSetup");
2743          return RFAILED;
2744       }
2745
2746       /*Flows mapped to DRB List*/
2747       if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
2748          BuildFlowsMapret = BuildFlowsMap(&ueCb->drbList[ueCb->numDrb], &drbSetItem->qoSInformation.choice.choice_extension->\
2749                value.choice.DRB_Information.flows_Mapped_To_DRB_List, ProtocolIE_ID_id_DRBs_ToBeSetup_Item, FALSE);
2750       else
2751          BuildFlowsMapret = BuildFlowsMap(&ueCb->drbList[idx], &drbSetItem->qoSInformation.choice.choice_extension->\
2752                value.choice.DRB_Information.flows_Mapped_To_DRB_List, ProtocolIE_ID_id_DRBs_ToBeSetup_Item, TRUE);
2753       if(BuildFlowsMapret != ROK)
2754       {
2755          DU_LOG("\nERROR  -->  F1AP : Failed to build Flow Map Info in BuildDRBSetup");
2756          return RFAILED;
2757       }
2758
2759       /*ULUPTNLInformation To Be Setup List*/
2760       if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
2761          BuildULTnlInforet = BuildULTnlInfo(&ueCb->drbList[ueCb->numDrb].ulUpTnlInfo, &drbSetItem->uLUPTNLInformation_ToBeSetup_List,\
2762                FALSE);
2763       else
2764          BuildULTnlInforet = BuildULTnlInfo(&ueCb->drbList[idx].ulUpTnlInfo, &drbSetItem->uLUPTNLInformation_ToBeSetup_List,\
2765                TRUE);
2766       if(BuildULTnlInforet != ROK)
2767       {
2768          DU_LOG("\nERROR  -->  F1AP : Failed to build tunnel Info in BuildDRBSetup");
2769          return RFAILED;
2770       }
2771
2772       /*RLCMode*/
2773       if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
2774       {
2775          drbSetItem->rLCMode = RLCMode_rlc_um_bidirectional;
2776          ueCb->drbList[ueCb->numDrb].rlcMode = drbSetItem->rLCMode;
2777       }
2778       else
2779          drbSetItem->rLCMode = ueCb->drbList[idx].rlcMode;
2780
2781       /* DL PDCP SN Length */
2782       if(ueCb->state == UE_HANDOVER_IN_PROGRESS)
2783       {
2784          CU_ALLOC(drbToBeSetupExt, sizeof(ProtocolExtensionContainer_4624P33_t));
2785          if(!drbToBeSetupExt)
2786          {
2787             DU_LOG("\nERROR  -->  F1AP : Failed to allocate memory for extension IE list in BuildDRBSetup");
2788             return RFAILED;
2789          }
2790
2791          elementCnt = 1;
2792          drbToBeSetupExt->list.count = elementCnt;
2793          drbToBeSetupExt->list.size = drbToBeSetupExt->list.count * sizeof(DRBs_ToBeSetup_ItemExtIEs_t *);
2794
2795          CU_ALLOC(drbToBeSetupExt->list.array, drbToBeSetupExt->list.size);
2796          if(!drbToBeSetupExt->list.array)
2797          {
2798              DU_LOG("\nERROR  -->  F1AP : Failed to allocated memory for extension array in BuildDRBSetup");
2799              return RFAILED;
2800          }
2801
2802          for(extIeIdx=0; extIeIdx < drbToBeSetupExt->list.count; extIeIdx++)
2803          {
2804             CU_ALLOC(drbToBeSetupExt->list.array[extIeIdx], sizeof(DRBs_ToBeSetup_ItemExtIEs_t));
2805             if(!drbToBeSetupExt->list.array[extIeIdx])
2806             {
2807                DU_LOG("\nERROR  -->  F1AP : Failed to allocated memory for extension array element in BuildDRBSetup");
2808                return RFAILED;
2809             }
2810          }
2811
2812          extIeIdx = 0;
2813          drbToBeSetupExtIe = drbToBeSetupExt->list.array[extIeIdx];
2814
2815          drbToBeSetupExtIe->id = ProtocolIE_ID_id_DLPDCPSNLength;
2816          drbToBeSetupExtIe->criticality = Criticality_ignore;
2817          drbToBeSetupExtIe->extensionValue.present = DRBs_ToBeSetup_ItemExtIEs__extensionValue_PR_PDCPSNLength;
2818          drbToBeSetupExtIe->extensionValue.choice.PDCPSNLength = PDCPSNLength_twelve_bits;
2819          drbSetItem->iE_Extensions = drbToBeSetupExt;
2820       }
2821
2822       if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
2823          ueCb->numDrb++;
2824    }
2825    return ROK;
2826 }/* End of BuildDRBSetup*/
2827
2828 /*******************************************************************
2829  *
2830  * @brief Deallocating memory of function BuildAndSendUESetReq
2831  *
2832  * @details
2833  *
2834  *    Function : FreeNrcgi
2835  *
2836  *    Functionality: Deallocating memory for function BuildNrcgi
2837  *
2838  * @params[in] NRCGI_t *nrcgi
2839  *
2840  * @return void
2841  *
2842  *******************************************************************/
2843 void FreeNrcgi(NRCGI_t *nrcgi)
2844 {
2845    if(nrcgi->pLMN_Identity.buf != NULLP)
2846    {
2847       if(nrcgi->nRCellIdentity.buf != NULLP)
2848       {
2849          CU_FREE(nrcgi->nRCellIdentity.buf, nrcgi->nRCellIdentity.size);
2850       }
2851       CU_FREE(nrcgi->pLMN_Identity.buf, nrcgi->pLMN_Identity.size);
2852    }
2853 }
2854 /*******************************************************************
2855  *
2856  * @brief  Deallocating memory of function BuildAndSendUESetReq
2857  *
2858  * @details
2859  *
2860  *    Function : FreeSplCellList
2861  *
2862  *    Functionality: Deallocating memory for function BuildSplCellList
2863  *
2864  * @params[in] SCell_ToBeSetup_List_t *spCellLst
2865  *
2866  * @return void
2867  *
2868  *
2869  * *****************************************************************/
2870 void FreeSplCellList(SCell_ToBeSetup_List_t *spCellLst)
2871 {
2872    uint8_t  cellidx;
2873    if(spCellLst->list.array != NULLP)
2874    {
2875       for(cellidx=0; cellidx<spCellLst->list.count; cellidx++)
2876       {
2877          if(cellidx==0&&spCellLst->list.array[cellidx]!=NULLP)
2878          {
2879             FreeNrcgi(&spCellLst->list.array[cellidx]->value.choice.SCell_ToBeSetup_Item.sCell_ID);
2880          }
2881          if(spCellLst->list.array[cellidx]!=NULLP)
2882          {
2883             CU_FREE(spCellLst->list.array[cellidx],sizeof(SCell_ToBeSetup_ItemIEs_t));
2884          }
2885       }
2886       CU_FREE(spCellLst->list.array,spCellLst->list.size);
2887    }
2888 }
2889 /*******************************************************************
2890  *
2891  * @brief Deallocating memory of function BuildAndSendUESetReq
2892  *
2893  * @details
2894  *
2895  *    Function : FreeSRBSetup
2896  *
2897  *    Functionality: Deallocating memory for function BuildSRBSetup
2898  *
2899  * @params[in] SRBs_ToBeSetup_List_t *srbSet
2900  *
2901  * @return void
2902  *
2903  *
2904  * ******************************************************************/
2905 void FreeSRBSetup(SRBs_ToBeSetup_List_t *srbSet)
2906 {
2907    uint8_t srbidx;
2908    if(srbSet->list.array != NULLP)
2909    {
2910       for(srbidx=0; srbidx<srbSet->list.count; srbidx++)
2911       {
2912          if(srbSet->list.array[srbidx]!=NULLP)
2913          {
2914             CU_FREE(srbSet->list.array[srbidx],sizeof(SRBs_ToBeSetup_ItemIEs_t));
2915          }
2916       }
2917       CU_FREE(srbSet->list.array,srbSet->list.size);
2918    }
2919 }
2920 /*******************************************************************
2921  *
2922  * @brief Deallocating memory of function BuildAndSendUESetReq
2923  *
2924  * @details
2925  *
2926  *    Function : FreeQOSInfo
2927  *
2928  *    Functionality:  Deallocating memory for function BuildQOSInfo
2929  *
2930  * @params[in] QoSFlowLevelQoSParameters_t *drbQos
2931  *
2932  * @return void
2933  *
2934  * ****************************************************************/
2935 void FreeQOSInfo(QoSFlowLevelQoSParameters_t *drbQos)
2936 {
2937    ProtocolExtensionContainer_4624P74_t *qosIeExt = NULLP;
2938    uint8_t qosCntIdx = 0;
2939
2940    if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI != NULLP)
2941    {
2942       if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow!=NULLP)
2943       {
2944          if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume!=NULLP)
2945          {
2946             CU_FREE(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume,\
2947                   sizeof(MaxDataBurstVolume_t));
2948          }
2949          CU_FREE(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow,\
2950                sizeof(AveragingWindow_t));
2951       }
2952       CU_FREE(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI,\
2953             sizeof(NonDynamic5QIDescriptor_t));
2954    }
2955    if(drbQos->iE_Extensions)
2956    {
2957       qosIeExt = (ProtocolExtensionContainer_4624P74_t *)drbQos->iE_Extensions;
2958       if(qosIeExt->list.array != NULLP)
2959       {
2960          for(qosCntIdx=0; qosCntIdx <  qosIeExt->list.count; qosCntIdx++)
2961          {
2962             if(qosIeExt->list.array[qosCntIdx])
2963             {
2964                CU_FREE(qosIeExt->list.array[qosCntIdx], sizeof(QoSFlowLevelQoSParameters_ExtIEs_t));
2965             }
2966          }
2967          CU_FREE(qosIeExt->list.array, qosIeExt->list.size);
2968       }
2969
2970       CU_FREE(drbQos->iE_Extensions, sizeof(ProtocolExtensionContainer_4624P74_t));
2971    }
2972 }
2973 /*******************************************************************
2974  *
2975  * @brief Deallocating memory of function BuildAndSendUESetReq
2976  *
2977  * @details
2978  *
2979  *    Function : FreeULTnlInfo
2980  *
2981  *    Functionality:  Deallocating memory for function BuildULTnlInfo
2982  *
2983  * @params[in] ULUPTNLInformation_ToBeSetup_List_t *ulInfo
2984  *
2985  * @return void
2986  *
2987
2988  * ****************************************************************/
2989 void FreeULTnlInfo(ULUPTNLInformation_ToBeSetup_List_t *ulInfo)
2990 {
2991    uint8_t ulidx=0;
2992    if(ulInfo->list.array != NULLP)
2993    {
2994       for(ulidx=0; ulidx<ulInfo->list.count; ulidx++)
2995       {
2996          if(ulidx==0&&ulInfo->list.array[ulidx]!=NULLP)
2997          {
2998             if(ulInfo->list.array[ulidx]->uLUPTNLInformation.choice.gTPTunnel!=NULLP)
2999             {
3000                if(ulInfo->list.array[ulidx]->uLUPTNLInformation.choice.gTPTunnel->\
3001                      transportLayerAddress.buf != NULLP)
3002                {
3003                   if(ulInfo->list.array[ulidx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf\
3004                         !=NULLP)
3005                   {
3006                      CU_FREE(ulInfo->list.array[ulidx]->uLUPTNLInformation.choice.gTPTunnel->\
3007                            gTP_TEID.buf,ulInfo->list.array[ulidx]->uLUPTNLInformation.choice.\
3008                            gTPTunnel->gTP_TEID.size);
3009                   }
3010                   CU_FREE(ulInfo->list.array[ulidx]->uLUPTNLInformation.choice.gTPTunnel->\
3011                         transportLayerAddress.buf,ulInfo->list.array[ulidx]->\
3012                         uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.size);
3013                }
3014                CU_FREE(ulInfo->list.array[ulidx]->uLUPTNLInformation.choice.gTPTunnel,\
3015                      sizeof(GTPTunnel_t));
3016             }
3017          }
3018          if(ulInfo->list.array[ulidx]!=NULLP)
3019          {
3020             CU_FREE(ulInfo->list.array[ulidx],sizeof(ULUPTNLInformation_ToBeSetup_Item_t));
3021          }
3022       }
3023       CU_FREE(ulInfo->list.array,ulInfo->list.size);
3024    }
3025 }
3026 /*******************************************************************
3027  *
3028  * @brief Deallocating memory for BuildAndSendUESetReq
3029  *
3030  * @details
3031  *
3032  *    Function : FreeDRBSetup
3033  *
3034  *    Functionality:  Deallocating memory for BuildDRBSetup
3035  *
3036  * @params[in] DRBs_ToBeSetup_List_t *drbSet
3037  *
3038  * @return void
3039  *
3040  * ****************************************************************/
3041 void FreeDRBSetup(DRBs_ToBeSetup_List_t *drbSet)
3042 {
3043    DRBs_ToBeSetup_Item_t *drbSetItem;
3044    ProtocolExtensionContainer_4624P74_t *qosIeExt = NULLP;
3045
3046    uint8_t  flowidx = 0, drbidx = 0, qosCntIdx = 0;
3047
3048    /*BUG: Need to check drbSet->list.array is not Empty to procced with Deletion*/
3049    if(drbSet->list.array != NULLP)
3050    {
3051       for(drbidx=0; drbidx<drbSet->list.count; drbidx++)
3052       {
3053               if(drbSet->list.array[drbidx] != NULLP)
3054               {
3055                  drbSetItem =&drbSet->list.array[drbidx]->value.choice.DRBs_ToBeSetup_Item;
3056                  if(drbSetItem->qoSInformation.choice.choice_extension != NULLP)
3057                  {
3058                     if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
3059                                   qoS_Characteristics.choice.non_Dynamic_5QI !=NULLP)
3060                {
3061                    if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
3062                                           qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow!=NULLP)
3063                             {
3064                                if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
3065                                           qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume!=NULLP)
3066                                {
3067                                        if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sST.buf!=NULLP)
3068                                        {
3069                                           if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD!=NULLP)
3070                                           {
3071                                              if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD->buf!=NULLP)
3072                                              {
3073                                                      if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.\
3074                                                             flows_Mapped_To_DRB_List.list.array != NULLP)
3075                                                      {
3076                                                          for(flowidx=0;flowidx<drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.\
3077                                                                       flows_Mapped_To_DRB_List.list.count; flowidx++)
3078                                                          {
3079                                                              if(flowidx==0&&drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
3080                                                                            DRB_Information.flows_Mapped_To_DRB_List.list.array[flowidx]!=NULLP)
3081                                                              {
3082                                                                      if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
3083                                                                                 DRB_Information.flows_Mapped_To_DRB_List.list.array[flowidx]->qoSFlowLevelQoSParameters.\
3084                                                                                 qoS_Characteristics.choice.non_Dynamic_5QI!=NULLP)
3085                                                                      {
3086                                                                          if(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!=NULLP)
3089                                                                          {
3090                                                                                  if(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->maxDataBurstVolume!=NULLP)
3093                                                                                   {
3094                                                                                       FreeULTnlInfo(&drbSetItem->uLUPTNLInformation_ToBeSetup_List);
3095                                                                                       CU_FREE(drbSetItem->uLConfiguration,sizeof(ULConfiguration_t));
3096
3097                                                                                       CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
3098                                                                                                    DRB_Information.flows_Mapped_To_DRB_List.list.array[flowidx]->qoSFlowLevelQoSParameters.\
3099                                                                                                    qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume,\
3100                                                                                                    sizeof(MaxDataBurstVolume_t));
3101                                                                                   }
3102                                                          CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
3103                                                                                            DRB_Information.flows_Mapped_To_DRB_List.list.array[flowidx]->qoSFlowLevelQoSParameters.\
3104                                                                                            qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow,sizeof(AveragingWindow_t));
3105                                                                          }
3106                                                                          CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
3107                                                                                        DRB_Information.flows_Mapped_To_DRB_List.list.array[flowidx]->qoSFlowLevelQoSParameters.\
3108                                                                                        qoS_Characteristics.choice.non_Dynamic_5QI,sizeof(NonDynamic5QIDescriptor_t));
3109                                                                      }
3110                                                             }
3111                                                             if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
3112                                                                      DRB_Information.flows_Mapped_To_DRB_List.list.array[flowidx]!=NULLP)
3113                                                             {
3114                                                                     CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
3115                                                                                   DRB_Information.flows_Mapped_To_DRB_List.list.array[flowidx],sizeof(Flows_Mapped_To_DRB_Item_t));
3116                                                             }
3117                                                         }
3118                                                         CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.\
3119                                                                       flows_Mapped_To_DRB_List.list.array,drbSetItem->qoSInformation.choice.choice_extension->value.\
3120                                                                       choice.DRB_Information.flows_Mapped_To_DRB_List.list.size);
3121                                                      }
3122                                                      CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD->buf,\
3123                                                              drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD->size);
3124                                             }
3125                                             CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD,\
3126                                                               sizeof(OCTET_STRING_t));
3127                                        }
3128                                        CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sST.buf,\
3129                                                     drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sST.size);
3130                                     }
3131                                     CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
3132                                             qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume,sizeof(MaxDataBurstVolume_t));
3133                             }
3134                        CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
3135                                          qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow,sizeof(AveragingWindow_t));
3136                          }
3137                          CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
3138                                        qoS_Characteristics.choice.non_Dynamic_5QI, sizeof(NonDynamic5QIDescriptor_t));
3139              }
3140              if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
3141                         iE_Extensions != NULLP)
3142              {
3143                 qosIeExt = (ProtocolExtensionContainer_4624P74_t *)drbSetItem->qoSInformation.choice.\
3144                                     choice_extension->value.choice.DRB_Information.dRB_QoS.iE_Extensions;
3145                  if(qosIeExt->list.array != NULLP)
3146                  {
3147                    for(qosCntIdx=0; qosCntIdx < qosIeExt->list.count; qosCntIdx++)
3148                    {
3149                       if(qosIeExt->list.array[qosCntIdx] != NULLP)
3150                       {
3151                          CU_FREE(qosIeExt->list.array[qosCntIdx], sizeof(QoSFlowLevelQoSParameters_ExtIEs_t));
3152                       }
3153                     }
3154                     CU_FREE(qosIeExt->list.array, qosIeExt->list.size);
3155                   }
3156                   CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
3157                                    iE_Extensions, sizeof(ProtocolExtensionContainer_4624P74_t));
3158               }
3159
3160                   CU_FREE(drbSetItem->qoSInformation.choice.choice_extension,sizeof(QoSInformation_ExtIEs_t));
3161                 }
3162                 CU_FREE(drbSet->list.array[drbidx],sizeof(DRBs_ToBeSetup_ItemIEs_t));
3163               }
3164       }
3165       CU_FREE(drbSet->list.array,drbSet->list.size);
3166    }
3167 }
3168
3169
3170 /*******************************************************************
3171  *
3172  * @brief Free the UE Setup Request
3173  *
3174  * @details
3175  *
3176  *    Function : FreeUeContextSetupReq
3177  *
3178  *    Functionality: Deallocate the memory of BuildUESetReq
3179  *
3180  * @params[in]  F1AP_PDU_t  *f1apMsg
3181  *
3182  * @return void
3183  *
3184  *
3185  * ****************************************************************/
3186 void FreeUeContextSetupReq(F1AP_PDU_t  *f1apMsg)
3187 {
3188    uint8_t idx, ieId;
3189    UEContextSetupRequest_t  *ueSetReq = NULLP;
3190
3191    if(f1apMsg != NULLP)
3192    {
3193       if(f1apMsg->choice.initiatingMessage != NULLP)
3194       {
3195          ueSetReq = &f1apMsg->choice.initiatingMessage->value.choice.UEContextSetupRequest;
3196          if(ueSetReq->protocolIEs.list.array != NULLP)
3197          {
3198             for(idx = 0; idx < ueSetReq->protocolIEs.list.count; idx++)
3199             {
3200                if(ueSetReq->protocolIEs.list.array[idx])
3201                {
3202                   switch(ueSetReq->protocolIEs.list.array[idx]->id)
3203                   {
3204                      case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
3205                         break;
3206                      case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
3207                         break;
3208                      case ProtocolIE_ID_id_SpCell_ID:
3209                         FreeNrcgi(&ueSetReq->protocolIEs.list.array[idx]->value.choice.NRCGI);
3210                         break;
3211                      case ProtocolIE_ID_id_ServCellIndex:
3212                         break;
3213                      case ProtocolIE_ID_id_SpCellULConfigured:
3214                         break;
3215                      case ProtocolIE_ID_id_CUtoDURRCInformation:
3216                         FreeCuToDuInfo(&ueSetReq->protocolIEs.list.array[idx]->value.choice.CUtoDURRCInformation);
3217                         break;
3218                      case ProtocolIE_ID_id_SCell_ToBeSetup_List:
3219                         FreeSplCellList(&ueSetReq->protocolIEs.list.array[idx]->value.choice.SCell_ToBeSetup_List);
3220                         break;
3221                      case ProtocolIE_ID_id_SRBs_ToBeSetup_List:
3222                         FreeSRBSetup(&ueSetReq->protocolIEs.list.array[idx]->value.choice.SRBs_ToBeSetup_List);
3223                         break;
3224                      case ProtocolIE_ID_id_DRBs_ToBeSetup_List:
3225                         FreeDRBSetup(&ueSetReq->protocolIEs.list.array[idx]->value.choice.DRBs_ToBeSetup_List);
3226                         break;
3227                      case ProtocolIE_ID_id_RRCContainer:
3228                         if(ueSetReq->protocolIEs.list.array[idx]->value.choice.RRCContainer.buf != NULLP)
3229                         {
3230                            CU_FREE(ueSetReq->protocolIEs.list.array[idx]->value.choice.RRCContainer.buf, \
3231                                  ueSetReq->protocolIEs.list.array[idx]->value.choice.RRCContainer.size);
3232                         }
3233                         break;
3234                      case ProtocolIE_ID_id_GNB_DU_UE_AMBR_UL:
3235                         CU_FREE(ueSetReq->protocolIEs.list.array[idx]->value.choice.BitRate.buf,\
3236                               ueSetReq->protocolIEs.list.array[idx]->value.choice.BitRate.size);
3237                         break;
3238                      default:
3239                         DU_LOG("\nERROR  -->  F1AP: Invalid event type %ld", ueSetReq->protocolIEs.list.array[idx]->id);
3240                         break;
3241                   }
3242                }
3243                /*BUG: Break is causing to exit the for Loop before complete traversing and freeing of each IE*/
3244             }
3245             for(ieId=0; ieId<idx; ieId++)
3246             {
3247                if(ueSetReq->protocolIEs.list.array[ieId] != NULLP)
3248                {
3249                   CU_FREE(ueSetReq->protocolIEs.list.array[ieId],sizeof(UEContextSetupRequestIEs_t));
3250                }
3251             }
3252             CU_FREE(ueSetReq->protocolIEs.list.array,ueSetReq->protocolIEs.list.size);
3253          }
3254          CU_FREE(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
3255       }
3256       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
3257    }
3258 }
3259
3260 /**Filling cell group info **/
3261 /*******************************************************************
3262  *
3263  * @brief Build Control resource set to add/modify list
3264  *
3265  * @details
3266  *
3267  *    Function : BuildControlRSetToAddModList
3268  *
3269  *    Functionality: Build Control resource set to add/modify list
3270  *
3271  * @params[in]
3272  * struct PDCCH_Config__controlResourceSetToAddModList *controlRSetList
3273  *
3274  * @return ROK     - success
3275  *         RFAILED - failure
3276  *
3277  * ****************************************************************/
3278    uint8_t BuildControlRSetToAddModList
3279 (
3280  struct PDCCH_Config__controlResourceSetToAddModList *controlRSetList
3281  )
3282 {
3283    uint8_t idx;
3284    uint8_t elementCnt;
3285    uint8_t numBytes, bitsUnused;
3286    struct ControlResourceSet *controlRSet;
3287    uint8_t freqDomainResource[FREQ_DOM_RSRC_SIZE] = {0};
3288    uint8_t coreset0EndPrb, coreset1StartPrb, coreset1NumPrb;
3289
3290    elementCnt = 1;
3291    controlRSetList->list.count = elementCnt;
3292    controlRSetList->list.size = \
3293                                 elementCnt * sizeof(struct ControlResourceSet *);
3294
3295    controlRSetList->list.array = NULLP;
3296    CU_ALLOC(controlRSetList->list.array, controlRSetList->list.size);
3297    if(!controlRSetList->list.array)
3298    {
3299       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3300       return RFAILED;
3301    }
3302
3303    for(idx = 0; idx < elementCnt; idx++)
3304    {
3305       controlRSetList->list.array[idx] = NULLP;
3306       CU_ALLOC(controlRSetList->list.array[idx], sizeof(struct ControlResourceSet));
3307       if(!controlRSetList->list.array[idx])
3308       {
3309          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3310          return RFAILED;
3311       }
3312    }
3313
3314    idx=0;
3315    controlRSet = controlRSetList->list.array[idx];
3316    controlRSet->controlResourceSetId = PDCCH_CTRL_RSRC_SET_ONE_ID;
3317
3318    /* Values harcoded according to our design:
3319     * size 6 bytes
3320     * 3 LSBs unsued
3321     * Bit string stored ff0000000000
3322     */
3323    numBytes = 6;
3324    bitsUnused = 3;
3325    controlRSet->frequencyDomainResources.size = numBytes * sizeof(uint8_t);
3326    controlRSet->frequencyDomainResources.buf = NULLP;
3327    CU_ALLOC(controlRSet->frequencyDomainResources.buf, \
3328          controlRSet->frequencyDomainResources.size);
3329    if(!controlRSet->frequencyDomainResources.buf)
3330    {
3331       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3332       return RFAILED;
3333    }
3334
3335    memset(controlRSet->frequencyDomainResources.buf, 0, FREQ_DOM_RSRC_SIZE);
3336    coreset0EndPrb = CORESET0_END_PRB;
3337    coreset1StartPrb = coreset0EndPrb + 6;
3338    coreset1NumPrb = CORESET1_NUM_PRB;
3339    /* calculate the PRBs */
3340    fillCoresetFeqDomAllocMap(((coreset1StartPrb)/6), (coreset1NumPrb/6), freqDomainResource);
3341    memcpy(controlRSet->frequencyDomainResources.buf, freqDomainResource, FREQ_DOM_RSRC_SIZE);
3342    controlRSet->frequencyDomainResources.bits_unused = bitsUnused;
3343
3344    controlRSet->duration = PDCCH_CTRL_RSRC_SET_ONE_DURATION;
3345    controlRSet->cce_REG_MappingType.present = \
3346                                               ControlResourceSet__cce_REG_MappingType_PR_nonInterleaved;
3347
3348    controlRSet->precoderGranularity = PDCCH_CTRL_RSRC_SET_ONE_PRECOD_GRANULARITY;
3349    controlRSet->tci_StatesPDCCH_ToAddList = NULLP;
3350    controlRSet->tci_StatesPDCCH_ToReleaseList = NULLP;
3351    controlRSet->tci_PresentInDCI = NULLP;
3352 #if 0
3353    uint8_t tciStateIdx;
3354
3355    CU_ALLOC(controlRset->tci_StatesPDCCH_ToAddList, \
3356          sizeof(struct ControlResourceSet__tci_StatesPDCCH_ToAddList));
3357    if(!controlRset->tci_StatesPDCCH_ToAddList)
3358    {
3359       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3360       return RFAILED;
3361    }
3362
3363    elementCnt = 1;
3364    controlRset->tci_StatesPDCCH_ToAddList->list.count = elementCnt;
3365    controlRset->tci_StatesPDCCH_ToAddList->list.size = elementCnt * sizeof(TCI_StateId_t *);
3366    CU_ALLOC(controlRset->tci_StatesPDCCH_ToAddList->list.array, \
3367          controlRset->tci_StatesPDCCH_ToAddList->list.size)
3368       if(!controlRset->tci_StatesPDCCH_ToAddList->list.array)
3369       {
3370          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3371          return RFAILED;
3372       }
3373
3374    for(tciStateIdx = 0; tciStateIdx <elementCntl; tciStateIdx++)
3375    {
3376       CU_ALLOC(controlRset->tci_StatesPDCCH_ToAddList->list.array[tciStateIdx], sizeof(TCI_StateId_t));
3377       if(!controlRset->tci_StatesPDCCH_ToAddList->list.array[tciStateIdx])
3378       {
3379          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3380          return RFAILED;
3381       }
3382    }
3383
3384    tciStateIdx = 0;
3385    /* TODO */
3386    *(controlRset->tci_StatesPDCCH_ToAddList->list.array[tciStateIdx]);
3387
3388    CU_ALLOC(controlRset->tci_PresentInDCI, sizeof(long));
3389    if(!controlRset->tci_PresentInDCI)
3390    {
3391       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3392       return RFAILED;
3393    }
3394    /* TODO */
3395    *(controlRset->tci_PresentInDCI);
3396 #endif
3397
3398    controlRSet->pdcch_DMRS_ScramblingID = NULLP;
3399    CU_ALLOC(controlRSet->pdcch_DMRS_ScramblingID, sizeof(long));
3400    if(!controlRSet->pdcch_DMRS_ScramblingID)
3401    {
3402       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3403       return RFAILED;
3404    }
3405    *(controlRSet->pdcch_DMRS_ScramblingID) = SCRAMBLING_ID;
3406
3407    return ROK;
3408 } /* End BuildControlRSetToAddModList */
3409
3410 /*******************************************************************
3411  *
3412  * @brief Build search space to add/modify list
3413  *
3414  * @details
3415  *
3416  *    Function : BuildSearchSpcToAddModList
3417  *
3418  *    Functionality: Build search space to add/modify list
3419  *
3420  * @params[in]
3421  * @return ROK     - success
3422  *         RFAILED - failure
3423  *
3424  * ****************************************************************/
3425    uint8_t BuildSearchSpcToAddModList
3426 (
3427  struct PDCCH_Config__searchSpacesToAddModList *searchSpcList
3428  )
3429 {
3430    uint8_t idx;
3431    uint8_t numBytes;
3432    uint8_t byteIdx;
3433    uint8_t bitsUnused;
3434    uint8_t elementCnt;
3435    struct SearchSpace *searchSpc;
3436
3437    elementCnt = 1;
3438    searchSpcList->list.count = elementCnt;
3439    searchSpcList->list.size = elementCnt * sizeof(struct SearchSpace *);
3440
3441    searchSpcList->list.array = NULLP;
3442    CU_ALLOC(searchSpcList->list.array, searchSpcList->list.size);
3443    if(!searchSpcList->list.array)
3444    {
3445       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3446       return RFAILED;
3447    }
3448
3449    for(idx = 0; idx < elementCnt; idx++)
3450    {
3451       searchSpcList->list.array[idx] = NULLP;
3452       CU_ALLOC(searchSpcList->list.array[idx], sizeof(struct SearchSpace));
3453       if(!searchSpcList->list.array[idx])
3454       {
3455          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3456          return RFAILED;
3457       }
3458    }
3459
3460    idx = 0;
3461    searchSpc = searchSpcList->list.array[idx];
3462
3463    searchSpc->searchSpaceId = PDCCH_SRCH_SPC_TWO_ID;
3464
3465    searchSpc->controlResourceSetId = NULLP;
3466    CU_ALLOC(searchSpc->controlResourceSetId, sizeof(ControlResourceSetId_t));
3467    if(!searchSpc->controlResourceSetId)
3468    {
3469       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3470       return RFAILED;
3471    }
3472    *(searchSpc->controlResourceSetId) = PDCCH_CTRL_RSRC_SET_ONE_ID;
3473
3474    searchSpc->monitoringSlotPeriodicityAndOffset = NULLP;
3475    CU_ALLOC(searchSpc->monitoringSlotPeriodicityAndOffset, \
3476          sizeof(struct SearchSpace__monitoringSlotPeriodicityAndOffset));
3477    if(!searchSpc->monitoringSlotPeriodicityAndOffset)
3478    {
3479       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3480       return RFAILED;
3481    }
3482    searchSpc->monitoringSlotPeriodicityAndOffset->present = \
3483                                                             SearchSpace__monitoringSlotPeriodicityAndOffset_PR_sl1;
3484
3485    searchSpc->duration = NULLP;
3486    searchSpc->monitoringSymbolsWithinSlot = NULLP;
3487    CU_ALLOC(searchSpc->monitoringSymbolsWithinSlot, sizeof(BIT_STRING_t));
3488    if(!searchSpc->monitoringSymbolsWithinSlot)
3489    {
3490       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3491       return RFAILED;
3492    }
3493
3494    /* Values taken from reference logs :
3495     * size 2 bytes
3496     * 2 LSBs unsued
3497     * Bit string stores 8000
3498     */
3499    numBytes = 2;
3500    bitsUnused = 2;
3501
3502    searchSpc->monitoringSymbolsWithinSlot->size = numBytes * sizeof(uint8_t);
3503    searchSpc->monitoringSymbolsWithinSlot->buf = NULLP;
3504    CU_ALLOC(searchSpc->monitoringSymbolsWithinSlot->buf, \
3505          searchSpc->monitoringSymbolsWithinSlot->size);
3506    if(!searchSpc->monitoringSymbolsWithinSlot->buf)
3507    {
3508       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3509       return RFAILED;
3510    }
3511
3512    byteIdx = 0;
3513    searchSpc->monitoringSymbolsWithinSlot->buf[byteIdx++] = \
3514                                                             PDCCH_SYMBOL_WITHIN_SLOT /* setting MSB to 128 i.e. 0x80 */;
3515    searchSpc->monitoringSymbolsWithinSlot->buf[byteIdx++] = 0;
3516    searchSpc->monitoringSymbolsWithinSlot->bits_unused = bitsUnused;
3517
3518    searchSpc->nrofCandidates = NULLP;
3519    CU_ALLOC(searchSpc->nrofCandidates, sizeof(struct SearchSpace__nrofCandidates));
3520    if(!searchSpc->nrofCandidates)
3521    {
3522       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3523       return RFAILED;
3524    }
3525
3526    searchSpc->nrofCandidates->aggregationLevel1 = \
3527                                                   PDCCH_SRCH_SPC_TWO_AGG_LVL1_CANDIDATE;
3528    searchSpc->nrofCandidates->aggregationLevel2 = \
3529                                                   PDCCH_SRCH_SPC_TWO_AGG_LVL2_CANDIDATE;
3530    searchSpc->nrofCandidates->aggregationLevel4 = \
3531                                                   PDCCH_SRCH_SPC_TWO_AGG_LVL4_CANDIDATE;
3532    searchSpc->nrofCandidates->aggregationLevel8 = \
3533                                                   PDCCH_SRCH_SPC_TWO_AGG_LVL8_CANDIDATE;
3534    searchSpc->nrofCandidates->aggregationLevel16 = \
3535                                                    PDCCH_SRCH_SPC_TWO_AGG_LVL16_CANDIDATE;
3536
3537    searchSpc->searchSpaceType = NULLP;
3538    CU_ALLOC(searchSpc->searchSpaceType, sizeof(struct SearchSpace__searchSpaceType));
3539    if(!searchSpc->searchSpaceType)
3540    {
3541       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3542       return RFAILED;
3543    }
3544
3545    searchSpc->searchSpaceType->present = SearchSpace__searchSpaceType_PR_ue_Specific;
3546
3547    searchSpc->searchSpaceType->choice.ue_Specific = NULLP;
3548    CU_ALLOC(searchSpc->searchSpaceType->choice.ue_Specific, \
3549          sizeof(struct SearchSpace__searchSpaceType__ue_Specific));
3550    if(!searchSpc->searchSpaceType->choice.ue_Specific)
3551    {
3552       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3553       return RFAILED;
3554    }
3555    searchSpc->searchSpaceType->choice.ue_Specific->dci_Formats = \
3556                                                                  PDCCH_SRCH_SPC_TWO_UE_SPEC_DCI_FORMAT;
3557
3558    return ROK;
3559 }/* End BuildSearchSpcToAddModList */
3560
3561 /*******************************************************************
3562  *
3563  * @brief Builds BWP DL dedicated PDCCH config
3564  *
3565  * @details
3566  *
3567  *    Function : BuildBWPDlDedPdcchCfg
3568  *
3569  *    Functionality: Builds BWP DL dedicated PDCCH config
3570  *
3571  * @params[in] struct PDCCH_Config *pdcchCfg
3572  *
3573  * @return ROK     - success
3574  *         RFAILED - failure
3575  *
3576  * ****************************************************************/
3577 uint8_t BuildBWPDlDedPdcchCfg(struct PDCCH_Config *pdcchCfg)
3578 {
3579    pdcchCfg->controlResourceSetToAddModList = NULLP;
3580    CU_ALLOC(pdcchCfg->controlResourceSetToAddModList, \
3581          sizeof(struct PDCCH_Config__controlResourceSetToAddModList));
3582    if(!pdcchCfg->controlResourceSetToAddModList)
3583    {
3584       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdcchCfg");
3585       return RFAILED;
3586    }
3587
3588    if(BuildControlRSetToAddModList(pdcchCfg->controlResourceSetToAddModList) != ROK)
3589    {
3590       return RFAILED;
3591    }
3592
3593    pdcchCfg->controlResourceSetToReleaseList = NULLP;
3594
3595    pdcchCfg->searchSpacesToAddModList = NULLP;
3596    CU_ALLOC(pdcchCfg->searchSpacesToAddModList, \
3597          sizeof(struct PDCCH_Config__searchSpacesToAddModList));
3598    if(!pdcchCfg->searchSpacesToAddModList)
3599    {
3600       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdcchCfg");
3601       return RFAILED;
3602    }
3603
3604    if(BuildSearchSpcToAddModList(pdcchCfg->searchSpacesToAddModList) != ROK)
3605    {
3606       return RFAILED;
3607    }
3608
3609    pdcchCfg->searchSpacesToReleaseList = NULLP;
3610    pdcchCfg->downlinkPreemption = NULLP;
3611    pdcchCfg->tpc_PUSCH = NULLP;
3612    pdcchCfg->tpc_PUCCH = NULLP;
3613    pdcchCfg->tpc_SRS = NULLP;
3614
3615    return ROK;
3616 }
3617
3618 /*******************************************************************
3619  *
3620  * @brief Builds DMRS DL PDSCH Mapping type A
3621  *
3622  * @details
3623  *
3624  *    Function : BuildDMRSDLPdschMapTypeA
3625  *
3626  *    Functionality: Builds DMRS DL PDSCH Mapping type A
3627  *
3628  * @params[in]
3629  * struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA *dmrsDlCfg
3630  * @return ROK     - success
3631  *         RFAILED - failure
3632  *
3633  * ****************************************************************/
3634    uint8_t BuildDMRSDLPdschMapTypeA
3635 (
3636  struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA *dmrsDlCfg
3637  )
3638 {
3639    dmrsDlCfg->present = PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA_PR_setup;
3640    dmrsDlCfg->choice.setup = NULLP;
3641    CU_ALLOC(dmrsDlCfg->choice.setup, sizeof(struct DMRS_DownlinkConfig));
3642    if(!dmrsDlCfg->choice.setup)
3643    {
3644       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
3645       return RFAILED;
3646    }
3647
3648    dmrsDlCfg->choice.setup->dmrs_Type = NULLP;
3649    dmrsDlCfg->choice.setup->dmrs_AdditionalPosition = NULLP;
3650    CU_ALLOC(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition, sizeof(long));
3651    if(!dmrsDlCfg->choice.setup->dmrs_AdditionalPosition)
3652    {
3653       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSDLPdschMapTypeA");
3654       return RFAILED;
3655    }
3656    *(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition) = DMRS_ADDITIONAL_POS;
3657
3658    dmrsDlCfg->choice.setup->maxLength = NULLP;
3659    dmrsDlCfg->choice.setup->scramblingID0 = NULLP;
3660    dmrsDlCfg->choice.setup->scramblingID1 = NULLP;
3661    dmrsDlCfg->choice.setup->phaseTrackingRS = NULLP;
3662
3663    return ROK;
3664 }
3665
3666 /*******************************************************************
3667  *
3668  * @brief Builds TCI states to add/modify list
3669  *
3670  * @details
3671  *
3672  *    Function : BuildTCIStatesToAddModList
3673  *
3674  *    Functionality:Builds TCI states to add/modify list
3675  *
3676  * @params[in]
3677  * struct PDSCH_Config__tci_StatesToAddModList *tciStatesList
3678  *
3679  * @return ROK     - success
3680  *         RFAILED - failure
3681  *
3682  * ****************************************************************/
3683 uint8_t BuildTCIStatesToAddModList(struct PDSCH_Config__tci_StatesToAddModList *tciStatesList)
3684 {
3685    return ROK;
3686 }
3687
3688 /*******************************************************************
3689  *
3690  * @brief Builds PDSCH time domain allocation list
3691  *
3692  * @details
3693  *
3694  *    Function : BuildPdschTimeDomAllocList
3695  *
3696  *    Functionality: Builds PDSCH time domain allocation list
3697  *
3698  * @params[in]
3699  * struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList
3700  *
3701  * @return ROK     - success
3702  *         RFAILED - failure
3703  *
3704  * ****************************************************************/
3705    uint8_t BuildPdschTimeDomAllocList
3706 (
3707  struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList
3708  )
3709 {
3710    uint8_t idx;
3711    uint8_t elementCnt;
3712    struct PDSCH_TimeDomainResourceAllocation *timeDomAlloc;
3713
3714    timeDomAllocList->present = \
3715                                PDSCH_Config__pdsch_TimeDomainAllocationList_PR_setup;
3716
3717    timeDomAllocList->choice.setup = NULLP;
3718    CU_ALLOC(timeDomAllocList->choice.setup, \
3719          sizeof(struct PDSCH_TimeDomainResourceAllocationList));
3720    if(!timeDomAllocList->choice.setup)
3721    {
3722       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
3723       return RFAILED;
3724    }
3725
3726    elementCnt = 2;
3727    timeDomAllocList->choice.setup->list.count = elementCnt;
3728    timeDomAllocList->choice.setup->list.size = \
3729                                                elementCnt * sizeof(struct PDSCH_TimeDomainResourceAllocation *);
3730
3731    timeDomAllocList->choice.setup->list.array = NULLP;
3732    CU_ALLOC(timeDomAllocList->choice.setup->list.array, \
3733          timeDomAllocList->choice.setup->list.size);
3734    if(!timeDomAllocList->choice.setup->list.array)
3735    {
3736       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
3737       return RFAILED;
3738    }
3739
3740    for(idx = 0; idx < elementCnt; idx++)
3741    {
3742       timeDomAllocList->choice.setup->list.array[idx] = NULLP;
3743       CU_ALLOC(timeDomAllocList->choice.setup->list.array[idx], \
3744             sizeof(struct PDSCH_TimeDomainResourceAllocation));
3745       if(!timeDomAllocList->choice.setup->list.array[idx])
3746       {
3747          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
3748          return RFAILED;
3749       }
3750    }
3751
3752    idx = 0;
3753    timeDomAlloc = timeDomAllocList->choice.setup->list.array[idx];
3754    CU_ALLOC(timeDomAlloc->k0, sizeof(long));
3755    if(!timeDomAlloc->k0)
3756    {
3757        DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
3758        return RFAILED;
3759    }
3760    *(timeDomAlloc->k0) = 0;
3761    timeDomAlloc->mappingType = PDSCH_MAPPING_TYPE_A;
3762    timeDomAlloc->startSymbolAndLength = 66;
3763
3764    idx++;
3765    timeDomAlloc = timeDomAllocList->choice.setup->list.array[idx];
3766    CU_ALLOC(timeDomAlloc->k0, sizeof(long));
3767    if(!timeDomAlloc->k0)
3768    {
3769       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
3770       return RFAILED;
3771    }
3772    *(timeDomAlloc->k0) = 1;
3773    timeDomAlloc->mappingType = PDSCH_MAPPING_TYPE_A;
3774    timeDomAlloc->startSymbolAndLength = 66;
3775
3776    return ROK;
3777 }
3778
3779 /*******************************************************************
3780  *
3781  * @brief Builds PDSCH PRB Bundling type
3782  *
3783  * @details
3784  *
3785  *    Function : BuildPdschPrbBundlingType
3786  *
3787  *    Functionality: Builds PDSCH PRB Bundling type
3788  *
3789  * @params[in]
3790  * struct PDSCH_Config__prb_BundlingType *prbBndlType
3791  *
3792  * @return ROK     - success
3793  *         RFAILED - failure
3794  *
3795  * ****************************************************************/
3796    uint8_t BuildPdschPrbBundlingType
3797 (
3798  struct PDSCH_Config__prb_BundlingType *prbBndlType
3799  )
3800 {
3801    prbBndlType->present = PDSCH_Config__prb_BundlingType_PR_staticBundling;
3802
3803    prbBndlType->choice.staticBundling = NULLP;
3804    CU_ALLOC(prbBndlType->choice.staticBundling, \
3805          sizeof(struct PDSCH_Config__prb_BundlingType__staticBundling));
3806    if(!prbBndlType->choice.staticBundling)
3807    {
3808       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschPrbBundlingType");
3809       return RFAILED;
3810    }
3811    prbBndlType->choice.staticBundling->bundleSize = NULLP;
3812
3813    return ROK;
3814 }
3815
3816 /*******************************************************************
3817  *
3818  * @brief Builds BWP DL dedicated PDSCH config
3819  *
3820  * @details
3821  *
3822  *    Function : BuildBWPDlDedPdschCfg
3823  *
3824  *    Functionality: Builds BWP DL dedicated PDSCH config
3825  *
3826  * @params[in] struct PDSCH_Config *pdschCfg
3827  *
3828  * @return ROK     - success
3829  *         RFAILED - failure
3830  *
3831  * ****************************************************************/
3832 uint8_t BuildBWPDlDedPdschCfg(struct PDSCH_Config *pdschCfg)
3833 {
3834    pdschCfg->dataScramblingIdentityPDSCH = NULLP;
3835
3836    pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA = NULLP;
3837    CU_ALLOC(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA, \
3838          sizeof(struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA));
3839    if(!pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA)
3840    {
3841       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
3842       return RFAILED;
3843    }
3844
3845    if(BuildDMRSDLPdschMapTypeA(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA) != ROK)
3846    {
3847       return RFAILED;
3848    }
3849
3850    pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeB = NULLP;
3851    pdschCfg->tci_StatesToAddModList = NULLP;
3852    pdschCfg->tci_StatesToReleaseList = NULLP;
3853    pdschCfg->vrb_ToPRB_Interleaver = NULLP;
3854 #if 0
3855    CU_ALLOC(pdschCfg->tci_StatesToAddModList, sizeof(struct PDSCH_Config__tci_StatesToAddModList));
3856    if(!pdschCfg->tci_StatesToAddModList)
3857    {
3858       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
3859       return RFAILED;
3860    }
3861    if(BuildTCIStatesToAddModList(pdschCfg->tci_StatesToAddModList) != ROK)
3862    {
3863       return RFAILED;
3864    }
3865 #endif
3866
3867    pdschCfg->resourceAllocation = RES_ALLOC_TYPE;
3868
3869    pdschCfg->pdsch_TimeDomainAllocationList = NULLP;
3870    CU_ALLOC(pdschCfg->pdsch_TimeDomainAllocationList, \
3871          sizeof(struct PDSCH_Config__pdsch_TimeDomainAllocationList));
3872    if(!pdschCfg->pdsch_TimeDomainAllocationList)
3873    {
3874       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
3875       return RFAILED;
3876    }
3877    if(BuildPdschTimeDomAllocList(pdschCfg->pdsch_TimeDomainAllocationList) != ROK)
3878    {
3879       return RFAILED;
3880    }
3881    pdschCfg->pdsch_AggregationFactor = NULLP;
3882    pdschCfg->rateMatchPatternToAddModList = NULLP;
3883    pdschCfg->rateMatchPatternToReleaseList = NULLP;
3884    pdschCfg->rateMatchPatternGroup1 = NULLP;
3885    pdschCfg->rateMatchPatternGroup2 = NULLP;
3886    pdschCfg->rbg_Size = PDSCH_RBG_SIZE;
3887    pdschCfg->mcs_Table = NULLP;
3888
3889    pdschCfg->maxNrofCodeWordsScheduledByDCI = NULLP;
3890    CU_ALLOC(pdschCfg->maxNrofCodeWordsScheduledByDCI, sizeof(long));
3891    if(!pdschCfg->maxNrofCodeWordsScheduledByDCI)
3892    {
3893       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
3894       return RFAILED;
3895    }
3896    *(pdschCfg->maxNrofCodeWordsScheduledByDCI) = PDSCH_MAX_CODEWORD_SCH_BY_DCI;
3897
3898    if(BuildPdschPrbBundlingType(&pdschCfg->prb_BundlingType) != ROK)
3899    {
3900       return RFAILED;
3901    }
3902
3903    pdschCfg->zp_CSI_RS_ResourceToAddModList = NULLP;
3904    pdschCfg->zp_CSI_RS_ResourceToReleaseList = NULLP;
3905    pdschCfg->aperiodic_ZP_CSI_RS_ResourceSetsToAddModList = NULLP;
3906    pdschCfg->aperiodic_ZP_CSI_RS_ResourceSetsToReleaseList = NULLP;
3907    pdschCfg->sp_ZP_CSI_RS_ResourceSetsToAddModList = NULLP;
3908    pdschCfg->sp_ZP_CSI_RS_ResourceSetsToReleaseList = NULLP;
3909    pdschCfg->p_ZP_CSI_RS_ResourceSet = NULLP;
3910
3911    return ROK;
3912 }
3913
3914 /*******************************************************************
3915  *
3916  * @brief Builds intitial DL BWP
3917  * @details
3918  *
3919  *    Function : BuildInitialDlBWP
3920  *
3921  *    Functionality: Builds intitial DL BWP in spCellCfgDed
3922  *
3923  * @params[in] BWP_DownlinkDedicated_t *dlBwp
3924  *
3925  * @return ROK     - success
3926  *         RFAILED - failure
3927  *
3928  * ****************************************************************/
3929 uint8_t BuildInitialDlBWP(BWP_DownlinkDedicated_t *dlBwp)
3930 {
3931    dlBwp->pdcch_Config = NULLP;
3932    CU_ALLOC(dlBwp->pdcch_Config, sizeof(struct BWP_DownlinkDedicated__pdcch_Config));
3933    if(!dlBwp->pdcch_Config)
3934    {
3935       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failure in BuildInitialDlBWP");
3936       return RFAILED;
3937    }
3938    dlBwp->pdcch_Config->present = BWP_DownlinkDedicated__pdcch_Config_PR_setup;
3939
3940    dlBwp->pdcch_Config->choice.setup = NULLP;
3941    CU_ALLOC(dlBwp->pdcch_Config->choice.setup, sizeof(struct PDCCH_Config));
3942    if(!dlBwp->pdcch_Config->choice.setup)
3943    {
3944       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failure in BuildInitialDlBWP");
3945       return RFAILED;
3946    }
3947    if(BuildBWPDlDedPdcchCfg(dlBwp->pdcch_Config->choice.setup) != ROK)
3948    {
3949       return RFAILED;
3950    }
3951
3952    dlBwp->pdsch_Config = NULLP;
3953    CU_ALLOC(dlBwp->pdsch_Config, sizeof(struct BWP_DownlinkDedicated__pdsch_Config));
3954    if(!dlBwp->pdsch_Config)
3955    {
3956       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failure in BuildInitialDlBWP");
3957       return RFAILED;
3958    }
3959    dlBwp->pdsch_Config->present = BWP_DownlinkDedicated__pdsch_Config_PR_setup;
3960
3961    dlBwp->pdsch_Config->choice.setup = NULLP;
3962    CU_ALLOC(dlBwp->pdsch_Config->choice.setup, sizeof(struct PDSCH_Config));
3963    if(!dlBwp->pdsch_Config->choice.setup)
3964    {
3965       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failure in BuildInitialDlBWP");
3966       return RFAILED;
3967    }
3968
3969    if(BuildBWPDlDedPdschCfg(dlBwp->pdsch_Config->choice.setup) != ROK)
3970    {
3971       return RFAILED;
3972    }
3973
3974    dlBwp->sps_Config = NULLP;
3975    dlBwp->radioLinkMonitoringConfig = NULLP;
3976    return ROK;
3977 }
3978
3979 /*******************************************************************
3980  *
3981  * @brief Builds DMRS UL Pusch Mapping type A
3982  *
3983  * @details
3984  *
3985  *    Function : BuildDMRSULPuschMapTypeA
3986  *
3987  *    Functionality: Builds DMRS UL Pusch Mapping type A
3988  *
3989  * @params[in]
3990  *    struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA *dmrsUlCfg
3991  * @return ROK     - success
3992  *         RFAILED - failure
3993  *
3994  * ****************************************************************/
3995    uint8_t BuildDMRSULPuschMapTypeA
3996 (
3997  struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA *dmrsUlCfg
3998  )
3999 {
4000    dmrsUlCfg->present = PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA_PR_setup;
4001    dmrsUlCfg->choice.setup= NULLP;
4002    CU_ALLOC(dmrsUlCfg->choice.setup, sizeof(DMRS_UplinkConfig_t));
4003    if(!dmrsUlCfg->choice.setup)
4004    {
4005       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
4006       return RFAILED;
4007    }
4008
4009    dmrsUlCfg->choice.setup->dmrs_Type = NULLP;
4010    dmrsUlCfg->choice.setup->dmrs_AdditionalPosition = NULLP;
4011    CU_ALLOC(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition, sizeof(long));
4012    if(!dmrsUlCfg->choice.setup->dmrs_AdditionalPosition)
4013    {
4014       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
4015       return RFAILED;
4016    }
4017    *(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition) = DMRS_ADDITIONAL_POS;
4018
4019    dmrsUlCfg->choice.setup->phaseTrackingRS = NULLP;
4020    dmrsUlCfg->choice.setup->maxLength = NULLP;
4021    dmrsUlCfg->choice.setup->transformPrecodingDisabled = NULLP;
4022    CU_ALLOC(dmrsUlCfg->choice.setup->transformPrecodingDisabled, \
4023          sizeof(struct DMRS_UplinkConfig__transformPrecodingDisabled));
4024    if(!dmrsUlCfg->choice.setup->transformPrecodingDisabled)
4025    {
4026       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
4027       return RFAILED;
4028    }
4029
4030    dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0 = NULLP;
4031    CU_ALLOC(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0,\
4032          sizeof(long));
4033    if(!dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0)
4034    {
4035       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
4036       return RFAILED;
4037    }
4038    *(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0) = SCRAMBLING_ID;
4039
4040    dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID1 = NULLP;
4041    dmrsUlCfg->choice.setup->transformPrecodingEnabled = NULLP;
4042    return ROK;
4043 }
4044
4045 /*******************************************************************
4046  *
4047  * @brief Build PUSCH time domain allocation list
4048  *
4049  * @details
4050  *
4051  *    Function : BuildPuschTimeDomAllocList
4052  *
4053  *    Functionality: Build PUSCH time domain allocation list
4054  *
4055  * @params[in]
4056  * struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList
4057  *
4058  * @return ROK     - success
4059  *         RFAILED - failure
4060  *
4061  * ****************************************************************/
4062    uint8_t BuildPuschTimeDomAllocList
4063 (
4064  struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList
4065  )
4066 {
4067    uint8_t idx;
4068    uint8_t elementCnt;
4069    PUSCH_TimeDomainResourceAllocation_t  *timeDomAlloc;
4070
4071    timeDomAllocList->present = PUSCH_Config__pusch_TimeDomainAllocationList_PR_setup;
4072    timeDomAllocList->choice.setup = NULLP;
4073    CU_ALLOC(timeDomAllocList->choice.setup, \
4074          sizeof(struct PUSCH_TimeDomainResourceAllocationList));
4075    if(!timeDomAllocList->choice.setup)
4076    {
4077       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
4078       return RFAILED;
4079    }
4080
4081    elementCnt = 2;
4082    timeDomAllocList->choice.setup->list.count = elementCnt;
4083    timeDomAllocList->choice.setup->list.size = \
4084                                                elementCnt * sizeof(PUSCH_TimeDomainResourceAllocation_t *);
4085    timeDomAllocList->choice.setup->list.array = NULLP;
4086    CU_ALLOC(timeDomAllocList->choice.setup->list.array, \
4087          timeDomAllocList->choice.setup->list.size);
4088    if(!timeDomAllocList->choice.setup->list.array)
4089    {
4090       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
4091       return RFAILED;
4092    }
4093
4094    for(idx = 0; idx < elementCnt; idx++)
4095    {
4096       timeDomAllocList->choice.setup->list.array[idx] = NULLP;
4097       CU_ALLOC(timeDomAllocList->choice.setup->list.array[idx],\
4098             sizeof(PUSCH_TimeDomainResourceAllocation_t));
4099       if(!timeDomAllocList->choice.setup->list.array[idx])
4100       {
4101          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
4102          return RFAILED;
4103       }
4104    }
4105
4106    idx = 0;
4107    timeDomAlloc = timeDomAllocList->choice.setup->list.array[idx];
4108    CU_ALLOC(timeDomAlloc->k2, sizeof(long));
4109    if(!timeDomAlloc->k2)
4110    {
4111       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
4112       return RFAILED;
4113    }
4114    *(timeDomAlloc->k2) = PUSCH_K2_CFG1;
4115    timeDomAlloc->mappingType = PUSCH_MAPPING_TYPE_A;
4116    timeDomAlloc->startSymbolAndLength = 66;
4117
4118    idx++;
4119    timeDomAlloc = timeDomAllocList->choice.setup->list.array[idx];
4120    CU_ALLOC(timeDomAlloc->k2, sizeof(long));
4121    if(!timeDomAlloc->k2)
4122    {
4123        DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
4124        return RFAILED;
4125    }
4126    *(timeDomAlloc->k2) = PUSCH_K2_CFG2;
4127    timeDomAlloc->mappingType = PUSCH_MAPPING_TYPE_A;
4128    timeDomAlloc->startSymbolAndLength = 66;
4129
4130    return ROK;
4131 }
4132
4133 /*******************************************************************
4134  *
4135  * @brief Builds BWP UL dedicated PUSCH Config
4136  *
4137  * @details
4138  *
4139  *    Function : BuildBWPUlDedPuschCfg
4140  *
4141  *    Functionality:
4142  *      Builds BWP UL dedicated PUSCH Config
4143  *
4144  * @params[in] : PUSCH_Config_t *puschCfg
4145  *
4146  * @return ROK     - success
4147  *         RFAILED - failure
4148  *
4149  * ****************************************************************/
4150 uint8_t BuildBWPUlDedPuschCfg(PUSCH_Config_t *puschCfg)
4151 {
4152    puschCfg->dataScramblingIdentityPUSCH = NULLP;
4153    CU_ALLOC(puschCfg->dataScramblingIdentityPUSCH, sizeof(long));
4154    if(!puschCfg->dataScramblingIdentityPUSCH)
4155    {
4156       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
4157       return RFAILED;
4158    }
4159    *(puschCfg->dataScramblingIdentityPUSCH) = SCRAMBLING_ID;
4160
4161    puschCfg->txConfig = NULLP;
4162    puschCfg->dmrs_UplinkForPUSCH_MappingTypeA = NULLP;
4163    CU_ALLOC(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA, \
4164          sizeof(struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA));
4165    if(!puschCfg->dmrs_UplinkForPUSCH_MappingTypeA)
4166    {
4167       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
4168       return RFAILED;
4169    }
4170
4171    if(BuildDMRSULPuschMapTypeA(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA) != ROK)
4172    {
4173       return RFAILED;
4174    }
4175
4176    puschCfg->dmrs_UplinkForPUSCH_MappingTypeB = NULLP;
4177    puschCfg->pusch_PowerControl = NULLP;
4178    puschCfg->frequencyHopping = NULLP;
4179    puschCfg->frequencyHoppingOffsetLists = NULLP;
4180    puschCfg->resourceAllocation = RES_ALLOC_TYPE;
4181
4182    puschCfg->pusch_TimeDomainAllocationList = NULLP;
4183    CU_ALLOC(puschCfg->pusch_TimeDomainAllocationList, \
4184          sizeof(struct PUSCH_Config__pusch_TimeDomainAllocationList));
4185    if(!puschCfg->pusch_TimeDomainAllocationList)
4186    {
4187       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
4188       return RFAILED;
4189    }
4190
4191    if(BuildPuschTimeDomAllocList(puschCfg->pusch_TimeDomainAllocationList) != ROK)
4192    {
4193       return RFAILED;
4194    }
4195
4196    puschCfg->pusch_AggregationFactor = NULLP;
4197    puschCfg->mcs_Table = NULLP;
4198    puschCfg->mcs_TableTransformPrecoder = NULLP;
4199    puschCfg->transformPrecoder = NULLP;
4200    CU_ALLOC(puschCfg->transformPrecoder, sizeof(long));
4201    if(!puschCfg->transformPrecoder)
4202    {
4203       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
4204       return RFAILED;
4205    }
4206    *(puschCfg->transformPrecoder) = PUSCH_TRANSFORM_PRECODER;
4207
4208    puschCfg->codebookSubset = NULLP;
4209    puschCfg->maxRank = NULLP;
4210    puschCfg->rbg_Size = NULLP;
4211    puschCfg->uci_OnPUSCH = NULLP;
4212    puschCfg->tp_pi2BPSK = NULLP;
4213
4214    return ROK;
4215 }
4216
4217 /*******************************************************************
4218  *
4219  * @brief Builds BWP UL dedicated PUCCH Config
4220  *
4221  * @details
4222  *
4223  *    Function : BuildBWPUlDedPucchCfg
4224  *
4225  *    Functionality:
4226  *      Builds BWP UL dedicated PUCCH Config
4227  *
4228  * @params[in] : PUCCH_Config_t *pucchCfg
4229  *
4230  * @return ROK     - success
4231  *         RFAILED - failure
4232  *
4233  * ****************************************************************/
4234 uint8_t BuildBWPUlDedPucchCfg(PUCCH_Config_t *pucchCfg)
4235 {
4236    uint8_t arrIdx, elementCnt;
4237    uint8_t rsrcIdx, rsrcSetIdx;
4238    PUCCH_ResourceSet_t *rsrcSet = NULLP;
4239    PUCCH_Resource_t *rsrc = NULLP;
4240
4241    //RESOURCE SET
4242    elementCnt = 1;
4243    CU_ALLOC(pucchCfg->resourceSetToAddModList, sizeof(struct PUCCH_Config__resourceSetToAddModList));
4244    pucchCfg->resourceSetToAddModList->list.count = elementCnt;
4245    pucchCfg->resourceSetToAddModList->list.size = elementCnt * sizeof(PUCCH_ResourceSet_t *);
4246    CU_ALLOC(pucchCfg->resourceSetToAddModList->list.array, pucchCfg->resourceSetToAddModList->list.size);
4247    for(rsrcSetIdx=0; rsrcSetIdx < pucchCfg->resourceSetToAddModList->list.count; rsrcSetIdx++)
4248    {
4249       CU_ALLOC(pucchCfg->resourceSetToAddModList->list.array[rsrcSetIdx], sizeof(PUCCH_ResourceSet_t));
4250    }
4251    rsrcSetIdx = 0;
4252    rsrcSet = pucchCfg->resourceSetToAddModList->list.array[rsrcSetIdx];
4253    rsrcSet->pucch_ResourceSetId = 1;
4254    elementCnt = 1;
4255    rsrcSet->resourceList.list.count = elementCnt;
4256    rsrcSet->resourceList.list.size = elementCnt * sizeof(PUCCH_ResourceId_t *);
4257    CU_ALLOC(rsrcSet->resourceList.list.array, rsrcSet->resourceList.list.size);
4258    for(rsrcIdx=0; rsrcIdx < rsrcSet->resourceList.list.count; rsrcIdx++)
4259    {
4260       CU_ALLOC(rsrcSet->resourceList.list.array[rsrcIdx], sizeof(PUCCH_ResourceId_t));
4261    }
4262    rsrcIdx = 0;
4263    *(rsrcSet->resourceList.list.array[rsrcIdx]) = 1;
4264
4265    //RESOURCE
4266    elementCnt = 1;
4267    CU_ALLOC(pucchCfg->resourceToAddModList, sizeof(struct PUCCH_Config__resourceToAddModList));
4268    pucchCfg->resourceToAddModList->list.count = elementCnt;
4269    pucchCfg->resourceToAddModList->list.size = elementCnt * sizeof(PUCCH_Resource_t *);
4270    CU_ALLOC(pucchCfg->resourceToAddModList->list.array, pucchCfg->resourceToAddModList->list.size);
4271    for(rsrcIdx=0; rsrcIdx < pucchCfg->resourceToAddModList->list.count; rsrcIdx++)
4272    {
4273       CU_ALLOC(pucchCfg->resourceToAddModList->list.array[rsrcIdx], sizeof(PUCCH_Resource_t));
4274    }
4275    rsrcIdx = 0;
4276    rsrc = pucchCfg->resourceToAddModList->list.array[rsrcIdx];
4277    rsrc->pucch_ResourceId = 1;
4278    rsrc->startingPRB = 0;
4279    rsrc->format.present = PUCCH_Resource__format_PR_format1;
4280    CU_ALLOC(rsrc->format.choice.format1, sizeof(PUCCH_format1_t));
4281    rsrc->format.choice.format1->initialCyclicShift = 0;
4282    rsrc->format.choice.format1->nrofSymbols = 4;
4283    rsrc->format.choice.format1->startingSymbolIndex = 0;
4284    rsrc->format.choice.format1->timeDomainOCC = 0;
4285
4286    //PUCCH Format 1
4287    CU_ALLOC(pucchCfg->format1, sizeof(struct PUCCH_Config__format1));
4288    pucchCfg->format1->present = PUCCH_Config__format1_PR_setup;
4289    CU_ALLOC(pucchCfg->format1->choice.setup, sizeof(PUCCH_FormatConfig_t));
4290    CU_ALLOC(pucchCfg->format1->choice.setup->nrofSlots, sizeof(long));
4291    *(pucchCfg->format1->choice.setup->nrofSlots) = PUCCH_FormatConfig__nrofSlots_n4;
4292
4293    //DL DATA TO UL ACK
4294    CU_ALLOC(pucchCfg->dl_DataToUL_ACK, sizeof(struct PUCCH_Config__dl_DataToUL_ACK));
4295    if(pucchCfg->dl_DataToUL_ACK == NULLP)
4296    {
4297       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
4298       return RFAILED;
4299    }
4300
4301    elementCnt = 2;
4302    pucchCfg->dl_DataToUL_ACK->list.count = elementCnt;
4303    pucchCfg->dl_DataToUL_ACK->list.size = elementCnt * sizeof(long *);
4304    CU_ALLOC(pucchCfg->dl_DataToUL_ACK->list.array, pucchCfg->dl_DataToUL_ACK->list.size);
4305    if(pucchCfg->dl_DataToUL_ACK->list.array == NULLP)
4306    {
4307       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
4308       return RFAILED;
4309    }
4310
4311    for(arrIdx = 0; arrIdx <  pucchCfg->dl_DataToUL_ACK->list.count; arrIdx++)
4312    {
4313       CU_ALLOC(pucchCfg->dl_DataToUL_ACK->list.array[arrIdx], sizeof(long));
4314       if(pucchCfg->dl_DataToUL_ACK->list.array[arrIdx] == NULLP)
4315       {
4316           DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
4317           return RFAILED;
4318       }
4319    }
4320
4321    arrIdx = 0;
4322    *(pucchCfg->dl_DataToUL_ACK->list.array[arrIdx++]) = 4;
4323    *(pucchCfg->dl_DataToUL_ACK->list.array[arrIdx]) = 5;
4324
4325    return ROK;
4326 }
4327
4328 /*******************************************************************
4329  *
4330  * @brief Fills SRS resource to add/modify list
4331  *
4332  * @details
4333  *
4334  *    Function : BuildSrsRsrcAddModList
4335  *
4336  *    Functionality: Fills SRS resource to add/modify list
4337  *
4338  * @params[in]
4339  * @return ROK     - success
4340  *         RFAILED - failure
4341  *
4342  * ****************************************************************/
4343 uint8_t BuildSrsRsrcAddModList(struct SRS_Config__srs_ResourceToAddModList *resourceList)
4344 {
4345    uint8_t   elementCnt;
4346    uint8_t   rsrcIdx;
4347
4348    elementCnt = 1;
4349    resourceList->list.count = elementCnt;
4350    resourceList->list.size = elementCnt * sizeof(SRS_Resource_t *);
4351    resourceList->list.array = NULLP;
4352    CU_ALLOC(resourceList->list.array, resourceList->list.size);
4353    if(!resourceList->list.array)
4354    {
4355       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed in BuildSrsRsrcAddModList");
4356       return RFAILED;
4357    }
4358
4359    for(rsrcIdx = 0; rsrcIdx < resourceList->list.count; rsrcIdx++)
4360    {
4361       CU_ALLOC(resourceList->list.array[rsrcIdx], sizeof(SRS_Resource_t));
4362       if(!resourceList->list.array[rsrcIdx])
4363       {
4364          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed in BuildSrsRsrcAddModList");
4365          return RFAILED;
4366       }
4367    }
4368
4369    rsrcIdx = 0;
4370    resourceList->list.array[rsrcIdx]->srs_ResourceId = SRS_RSRC_ID;
4371    resourceList->list.array[rsrcIdx]->nrofSRS_Ports = SRS_Resource__nrofSRS_Ports_port1;
4372    resourceList->list.array[rsrcIdx]->transmissionComb.present = SRS_Resource__transmissionComb_PR_n2;
4373
4374    resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2 = NULLP;
4375    CU_ALLOC(resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2, \
4376          sizeof(struct SRS_Resource__transmissionComb__n2));
4377    if(!resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2)
4378    {
4379       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed in BuildSrsRsrcAddModList");
4380       return RFAILED;
4381    }
4382    resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2->combOffset_n2\
4383       = SRS_COMB_OFFSET_N2;
4384    resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2->cyclicShift_n2\
4385       = SRS_CYCLIC_SHIFT_N2;
4386
4387    resourceList->list.array[rsrcIdx]->resourceMapping.startPosition = PUSCH_START_SYMBOL;
4388    resourceList->list.array[rsrcIdx]->resourceMapping.nrofSymbols =  \
4389                                                                      SRS_Resource__resourceMapping__nrofSymbols_n1;
4390    resourceList->list.array[rsrcIdx]->resourceMapping.repetitionFactor = \
4391                                                                          SRS_Resource__resourceMapping__repetitionFactor_n1;
4392
4393    resourceList->list.array[rsrcIdx]->freqDomainPosition = SRS_FREQ_DOM_POS;
4394    resourceList->list.array[rsrcIdx]->freqDomainShift = SRS_FREQ_DOM_SHIFT;
4395    resourceList->list.array[rsrcIdx]->freqHopping.c_SRS = C_SRS;
4396    resourceList->list.array[rsrcIdx]->freqHopping.b_SRS = B_SRS;
4397    resourceList->list.array[rsrcIdx]->freqHopping.b_hop = B_HOP;
4398    resourceList->list.array[rsrcIdx]->groupOrSequenceHopping = \
4399                                                                SRS_Resource__groupOrSequenceHopping_neither;
4400
4401    /* Setting resource type to aperiodic for intergration purposes */
4402    resourceList->list.array[rsrcIdx]->resourceType.present = \
4403                                                              SRS_Resource__resourceType_PR_aperiodic;
4404    resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic = NULLP;
4405    CU_ALLOC(resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic,
4406          sizeof(struct SRS_Resource__resourceType__aperiodic));
4407    if(!resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic)
4408    {
4409       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed in BuildSrsRsrcAddModList");
4410       return RFAILED;
4411    }
4412    resourceList->list.array[rsrcIdx]->sequenceId = SRS_SEQ_ID;
4413
4414    return ROK;
4415 }
4416
4417 /*******************************************************************
4418  *
4419  * @brief Build SRS resource set Add/mod list
4420  *
4421  * @details
4422  *
4423  *    Function : BuildSrsRsrcSetAddModList
4424  *
4425  *    Functionality: Build SRS resource set Add/mod list
4426  *
4427  * @params[in]
4428  * @return ROK     - success
4429  *         RFAILED - failure
4430  *
4431  * ****************************************************************/
4432    uint8_t BuildSrsRsrcSetAddModList
4433 (
4434  struct SRS_Config__srs_ResourceSetToAddModList *rsrcSetList
4435  )
4436 {
4437    uint8_t  elementCnt;
4438    uint8_t  rSetIdx;
4439    uint8_t  rsrcIdx;
4440    struct SRS_ResourceSet__srs_ResourceIdList *rsrcIdList;
4441
4442    elementCnt = 1;
4443    rsrcSetList->list.count = elementCnt;
4444    rsrcSetList->list.size = elementCnt * sizeof(SRS_ResourceSet_t *);
4445    rsrcSetList->list.array = NULLP;
4446    CU_ALLOC(rsrcSetList->list.array, rsrcSetList->list.size);
4447    if(!rsrcSetList->list.array)
4448    {
4449       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed in BuildSrsRsrcSetAddModList");
4450       return RFAILED;
4451    }
4452
4453    for(rSetIdx = 0; rSetIdx < rsrcSetList->list.count; rSetIdx++)
4454    {
4455       CU_ALLOC(rsrcSetList->list.array[rSetIdx], sizeof(SRS_ResourceSet_t));
4456       if(!rsrcSetList->list.array[rSetIdx])
4457       {
4458          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed in BuildSrsRsrcSetAddModList");
4459          return RFAILED;
4460       }
4461    }
4462
4463    rSetIdx = 0;
4464    rsrcSetList->list.array[rSetIdx]->srs_ResourceSetId = SRS_RSET_ID;
4465
4466    /* Fill Resource Id list in resource set */
4467    rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList = NULLP;
4468    CU_ALLOC(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList,\
4469          sizeof(struct SRS_ResourceSet__srs_ResourceIdList));
4470    if(!rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList)
4471    {
4472       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
4473       return RFAILED;
4474    }
4475
4476    elementCnt = 1;
4477    rsrcIdList = rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList;
4478    rsrcIdList->list.count = elementCnt;
4479    rsrcIdList->list.size = elementCnt * sizeof(SRS_ResourceId_t *);
4480    rsrcIdList->list.array = NULLP;
4481    CU_ALLOC(rsrcIdList->list.array, rsrcIdList->list.size);
4482    if(!rsrcIdList->list.array)
4483    {
4484       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed in BuildSrsRsrcSetAddModList");
4485       return RFAILED;
4486    }
4487
4488    for(rsrcIdx = 0; rsrcIdx < rsrcIdList->list.count; rsrcIdx++)
4489    {
4490       CU_ALLOC(rsrcIdList->list.array[rsrcIdx], sizeof(SRS_ResourceId_t));
4491       if(!rsrcIdList->list.array[rsrcIdx])
4492       {
4493          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed in BuildSrsRsrcSetAddModList");
4494          return RFAILED;
4495       }
4496    }
4497
4498    rsrcIdx = 0;
4499    *rsrcIdList->list.array[rsrcIdx] = SRS_RSRC_ID;
4500
4501    /* Fill resource type */
4502    rsrcSetList->list.array[rSetIdx]->resourceType.present = \
4503                                                             SRS_ResourceSet__resourceType_PR_aperiodic;
4504
4505    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic = NULLP;
4506    CU_ALLOC(rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic, \
4507          sizeof(struct SRS_ResourceSet__resourceType__aperiodic));
4508    if(!rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic)
4509    {
4510       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed in BuildSrsRsrcSetAddModList");
4511       return RFAILED;
4512    }
4513    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic->aperiodicSRS_ResourceTrigger \
4514       = APERIODIC_SRS_RESRC_TRIGGER;
4515
4516    /* TODO : Fill values for below IEs as expected by Viavi */
4517    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic->csi_RS = NULLP;
4518    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic->slotOffset = NULLP;
4519
4520
4521    rsrcSetList->list.array[rSetIdx]->usage = SRS_ResourceSet__usage_codebook;
4522    rsrcSetList->list.array[rSetIdx]->alpha = NULLP;
4523    rsrcSetList->list.array[rSetIdx]->p0 = NULLP;
4524    rsrcSetList->list.array[rSetIdx]->pathlossReferenceRS = NULLP;
4525    rsrcSetList->list.array[rSetIdx]->srs_PowerControlAdjustmentStates = NULLP;
4526
4527    return ROK;
4528 }
4529
4530 /*******************************************************************
4531  *
4532  * @brief Builds BWP UL dedicated SRS Config
4533  *
4534  * @details
4535  *
4536  *    Function : BuildBWPUlDedSrsCfg
4537  *
4538  *    Functionality: Builds BWP UL dedicated SRS Config
4539  *
4540  * @params[in] SRS Config
4541  * @return ROK     - success
4542  *         RFAILED - failure
4543  *
4544  * ****************************************************************/
4545 uint8_t BuildBWPUlDedSrsCfg(SRS_Config_t *srsCfg)
4546 {
4547    srsCfg->srs_ResourceSetToReleaseList = NULLP;
4548    srsCfg->srs_ResourceSetToAddModList = NULLP;
4549    CU_ALLOC(srsCfg->srs_ResourceSetToAddModList, \
4550          sizeof(struct SRS_Config__srs_ResourceSetToAddModList));
4551    if(!srsCfg->srs_ResourceSetToAddModList)
4552    {
4553       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed in BuildBWPUlDedSrsCfg");
4554       return RFAILED;
4555    }
4556    if(BuildSrsRsrcSetAddModList(srsCfg->srs_ResourceSetToAddModList) != ROK)
4557    {
4558       return RFAILED;
4559    }
4560
4561    srsCfg->srs_ResourceToReleaseList = NULLP;
4562
4563    /* Resource to Add/Modify list */
4564    srsCfg->srs_ResourceToAddModList = NULLP;
4565    CU_ALLOC(srsCfg->srs_ResourceToAddModList, \
4566          sizeof(struct SRS_Config__srs_ResourceToAddModList));
4567    if(!srsCfg->srs_ResourceToAddModList)
4568    {
4569       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed in BuildBWPUlDedSrsCfg");
4570       return RFAILED;
4571    }
4572
4573    if(BuildSrsRsrcAddModList(srsCfg->srs_ResourceToAddModList) != ROK)
4574    {
4575       return RFAILED;
4576    }
4577
4578    srsCfg->tpc_Accumulation = NULLP;
4579
4580    return ROK;
4581 }
4582
4583 /*******************************************************************
4584  *
4585  * @brief Builds inital UL BWP
4586  *
4587  * @details
4588  *
4589  *    Function : BuildInitialUlBWP
4590  *
4591  *    Functionality: Builds initial UL BWP
4592  *
4593  * @params[in] BWP_UplinkDedicated_t *ulBwp
4594  * @return ROK     - success
4595  *         RFAILED - failure
4596  *
4597  * ****************************************************************/
4598 uint8_t BuildInitialUlBWP(BWP_UplinkDedicated_t *ulBwp)
4599 {
4600    ulBwp->pucch_Config = NULLP;
4601    ulBwp->pucch_Config = NULLP;
4602    CU_ALLOC(ulBwp->pucch_Config, sizeof(struct BWP_UplinkDedicated__pucch_Config));
4603    if(!ulBwp->pucch_Config)
4604    {
4605       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
4606       return RFAILED;
4607    }
4608
4609    ulBwp->pucch_Config->present = BWP_UplinkDedicated__pucch_Config_PR_setup;
4610    ulBwp->pucch_Config->choice.setup = NULLP;
4611    CU_ALLOC(ulBwp->pucch_Config->choice.setup, sizeof(PUCCH_Config_t));
4612    if(!ulBwp->pucch_Config->choice.setup)
4613    {
4614       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
4615       return RFAILED;
4616    }
4617
4618    if(BuildBWPUlDedPucchCfg(ulBwp->pucch_Config->choice.setup) != ROK)
4619    {
4620       return RFAILED;
4621    }
4622
4623    /* Fill BWP UL dedicated PUSCH config */
4624    ulBwp->pusch_Config = NULLP;
4625    CU_ALLOC(ulBwp->pusch_Config, sizeof(struct BWP_UplinkDedicated__pusch_Config));
4626    if(!ulBwp->pusch_Config)
4627    {
4628       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
4629       return RFAILED;
4630    }
4631
4632    ulBwp->pusch_Config->present = BWP_UplinkDedicated__pusch_Config_PR_setup;
4633    ulBwp->pusch_Config->choice.setup = NULLP;
4634    CU_ALLOC(ulBwp->pusch_Config->choice.setup, sizeof(PUSCH_Config_t));
4635    if(!ulBwp->pusch_Config->choice.setup)
4636    {
4637       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
4638       return RFAILED;
4639    }
4640
4641    if(BuildBWPUlDedPuschCfg(ulBwp->pusch_Config->choice.setup) != ROK)
4642    {
4643       return RFAILED;
4644    }
4645
4646    ulBwp->configuredGrantConfig = NULLP;
4647
4648    /* Fill BPW UL dedicated SRS config */
4649    ulBwp->srs_Config = NULLP;
4650    CU_ALLOC(ulBwp->srs_Config, sizeof(struct BWP_UplinkDedicated__srs_Config));
4651    if(!ulBwp->srs_Config)
4652    {
4653       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
4654       return RFAILED;
4655    }
4656
4657    ulBwp->srs_Config->present = BWP_UplinkDedicated__srs_Config_PR_setup;
4658    ulBwp->srs_Config->choice.setup = NULLP;
4659    CU_ALLOC(ulBwp->srs_Config->choice.setup, sizeof(SRS_Config_t));
4660    if(!ulBwp->srs_Config->choice.setup)
4661    {
4662       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
4663       return RFAILED;
4664    }
4665
4666    if(BuildBWPUlDedSrsCfg(ulBwp->srs_Config->choice.setup) != ROK)
4667    {
4668       return RFAILED;
4669    }
4670
4671    ulBwp->beamFailureRecoveryConfig = NULLP;
4672
4673    return ROK;
4674 }
4675
4676 /*******************************************************************
4677  *
4678  * @brief Builds Pusch Serving cell Config
4679  *
4680  * @details
4681  *
4682  *    Function : BuildPuschSrvCellCfg
4683  *
4684  *    Functionality: Builds Pusch Serving cell Config
4685  *
4686  * @params[in] struct UplinkConfig__pusch_ServingCellConfig *puschCfg
4687  *
4688  * @return ROK     - success
4689  *         RFAILED - failure
4690  *
4691  * ****************************************************************/
4692 uint8_t BuildPuschSrvCellCfg(struct UplinkConfig__pusch_ServingCellConfig *puschCfg)
4693 {
4694    puschCfg->present = UplinkConfig__pusch_ServingCellConfig_PR_setup;
4695    puschCfg->choice.setup = NULLP;
4696    CU_ALLOC(puschCfg->choice.setup, sizeof(struct PUSCH_ServingCellConfig));
4697    if(!puschCfg->choice.setup)
4698    {
4699       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
4700       return RFAILED;
4701    }
4702
4703    puschCfg->choice.setup->codeBlockGroupTransmission = NULLP;
4704    puschCfg->choice.setup->rateMatching = NULLP;
4705    puschCfg->choice.setup->xOverhead = NULLP;
4706    puschCfg->choice.setup->ext1 = NULLP;
4707    CU_ALLOC(puschCfg->choice.setup->ext1, sizeof(struct PUSCH_ServingCellConfig__ext1));
4708    if(!puschCfg->choice.setup->ext1)
4709    {
4710       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
4711       return RFAILED;
4712    }
4713
4714    puschCfg->choice.setup->ext1->maxMIMO_Layers = NULLP;
4715    CU_ALLOC(puschCfg->choice.setup->ext1->maxMIMO_Layers, sizeof(long));
4716    if(!puschCfg->choice.setup->ext1->maxMIMO_Layers)
4717    {
4718       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
4719       return RFAILED;
4720    }
4721    *(puschCfg->choice.setup->ext1->maxMIMO_Layers) = PUSCH_MAX_MIMO_LAYERS;
4722
4723    puschCfg->choice.setup->ext1->processingType2Enabled= NULLP;
4724    CU_ALLOC(puschCfg->choice.setup->ext1->processingType2Enabled,sizeof(BOOLEAN_t));
4725    if(!puschCfg->choice.setup->ext1->processingType2Enabled)
4726    {
4727       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
4728       return RFAILED;
4729    }
4730    *(puschCfg->choice.setup->ext1->processingType2Enabled) = PUSCH_PROCESS_TYPE2_ENABLED;
4731    return ROK;
4732 }
4733
4734 /*******************************************************************
4735  *
4736  * @brief Builds UL config
4737  * @details
4738  *
4739  *    Function : BuildUlCfg
4740  *
4741  *    Functionality: Builds UL config in spCellCfgDed
4742  *
4743  * @params[in] UplinkConfig_t *ulCfg
4744  *
4745  * @return ROK     - success
4746  *         RFAILED - failure
4747  *
4748  * ****************************************************************/
4749 uint8_t BuildUlCfg(UplinkConfig_t *ulCfg)
4750 {
4751    ulCfg->initialUplinkBWP = NULLP;
4752    CU_ALLOC(ulCfg->initialUplinkBWP, sizeof(BWP_UplinkDedicated_t));
4753    if(!ulCfg->initialUplinkBWP)
4754    {
4755       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failed in BuildUlCfg");
4756       return RFAILED;
4757    }
4758
4759    if(BuildInitialUlBWP(ulCfg->initialUplinkBWP) != ROK)
4760    {
4761       return RFAILED;
4762    }
4763
4764    ulCfg->uplinkBWP_ToReleaseList = NULLP;
4765    ulCfg->uplinkBWP_ToAddModList = NULLP;
4766    ulCfg->firstActiveUplinkBWP_Id = NULLP;
4767    CU_ALLOC(ulCfg->firstActiveUplinkBWP_Id, sizeof(BWP_Id_t));
4768    if(!ulCfg->firstActiveUplinkBWP_Id)
4769    {
4770       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failed in BuildUlCfg");
4771       return RFAILED;
4772    }
4773    *(ulCfg->firstActiveUplinkBWP_Id) = ACTIVE_UL_BWP_ID;
4774
4775    ulCfg->pusch_ServingCellConfig = NULLP;
4776    CU_ALLOC(ulCfg->pusch_ServingCellConfig, \
4777          sizeof(struct UplinkConfig__pusch_ServingCellConfig));
4778    if(!ulCfg->pusch_ServingCellConfig)
4779    {
4780       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failed in BuildUlCfg");
4781       return RFAILED;
4782    }
4783
4784    if(BuildPuschSrvCellCfg(ulCfg->pusch_ServingCellConfig) != ROK)
4785    {
4786       return RFAILED;
4787    }
4788
4789    ulCfg->carrierSwitching = NULLP;
4790    ulCfg->ext1 = NULLP;
4791    return ROK;
4792 }
4793
4794 /*******************************************************************
4795  *
4796  * @brief Builds PDSCH serving cell config
4797  * @details
4798  *
4799  *    Function : BuildPdschSrvCellCfg
4800  *
4801  *    Functionality: Builds PDSCH serving cell config in spCellCfgDed
4802  *
4803  * @params[in] struct ServingCellConfig__pdsch_ServingCellConfig *pdschCfg
4804  *
4805  * @return ROK     - success
4806  *         RFAILED - failure
4807  *
4808  * ****************************************************************/
4809 uint8_t BuildPdschSrvCellCfg(struct ServingCellConfig__pdsch_ServingCellConfig *pdschCfg)
4810 {
4811    pdschCfg->present =  ServingCellConfig__pdsch_ServingCellConfig_PR_setup;
4812    pdschCfg->choice.setup = NULLP;
4813    CU_ALLOC(pdschCfg->choice.setup, sizeof( struct PDSCH_ServingCellConfig));
4814    if(!pdschCfg->choice.setup)
4815    {
4816       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschSrvCellCfg");
4817       return RFAILED;
4818    }
4819
4820    pdschCfg->choice.setup->codeBlockGroupTransmission = NULLP;
4821    pdschCfg->choice.setup->xOverhead = NULLP;
4822    pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH = NULLP;
4823    CU_ALLOC(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH, sizeof(long));
4824    if(!pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH)
4825    {
4826       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschSrvCellCfg");
4827       return RFAILED;
4828    }
4829    *(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH)= PDSCH_NUM_HARQ_PROC;
4830    pdschCfg->choice.setup->pucch_Cell = NULLP;
4831    pdschCfg->choice.setup->ext1 = NULLP;
4832
4833    return ROK;
4834 }
4835
4836 /*******************************************************************
4837  *
4838  * @brief Builds CSI Meas config
4839  * @details
4840  *
4841  *    Function : BuildCsiMeasCfg
4842  *
4843  *    Functionality: Builds CSI Meas config in spCellCfgDed
4844  *
4845  * @params[in] struct ServingCellConfig__csi_MeasConfig *csiMeasCfg
4846  *
4847  * @return ROK     - success
4848  *         RFAILED - failure
4849  *
4850  * ****************************************************************/
4851 uint8_t BuildCsiMeasCfg(struct ServingCellConfig__csi_MeasConfig *csiMeasCfg)
4852 {
4853
4854    return ROK;
4855 }
4856
4857 /*******************************************************************
4858  *
4859  * @brief Builds Spcell config dedicated
4860  * @details
4861  *
4862  *    Function : BuildSpCellCfgDed
4863  *
4864  *    Functionality: Builds sp cell config dedicated in spCellCfg
4865  *
4866  * @params[in] ServingCellConfig_t srvCellCfg
4867  *
4868  * @return ROK     - success
4869  *         RFAILED - failure
4870  *
4871  * ****************************************************************/
4872 uint8_t BuildSpCellCfgDed(ServingCellConfig_t *srvCellCfg)
4873 {
4874    srvCellCfg->tdd_UL_DL_ConfigurationDedicated = NULLP;
4875
4876    srvCellCfg->initialDownlinkBWP = NULLP;
4877    CU_ALLOC(srvCellCfg->initialDownlinkBWP, sizeof(BWP_DownlinkDedicated_t));
4878    if(!srvCellCfg->initialDownlinkBWP)
4879    {
4880       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
4881       return RFAILED;
4882    }
4883
4884    if(BuildInitialDlBWP(srvCellCfg->initialDownlinkBWP) != ROK)
4885    {
4886       DU_LOG("\nERROR  -->  F1AP : BuildInitialDlBWP failed");
4887       return RFAILED;
4888    }
4889    srvCellCfg->downlinkBWP_ToReleaseList = NULLP;
4890    srvCellCfg->downlinkBWP_ToAddModList = NULLP;
4891
4892    srvCellCfg->firstActiveDownlinkBWP_Id = NULLP;
4893    CU_ALLOC(srvCellCfg->firstActiveDownlinkBWP_Id, sizeof(long));
4894    if(!srvCellCfg->firstActiveDownlinkBWP_Id)
4895    {
4896       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
4897       return RFAILED;
4898    }
4899    *(srvCellCfg->firstActiveDownlinkBWP_Id) = ACTIVE_DL_BWP_ID;
4900
4901    srvCellCfg->bwp_InactivityTimer = NULLP;
4902
4903    srvCellCfg->defaultDownlinkBWP_Id = NULLP;
4904    CU_ALLOC(srvCellCfg->defaultDownlinkBWP_Id, sizeof(long));
4905    if(!srvCellCfg->defaultDownlinkBWP_Id)
4906    {
4907       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
4908       return RFAILED;
4909    }
4910    *(srvCellCfg->defaultDownlinkBWP_Id) = ACTIVE_DL_BWP_ID;
4911
4912    srvCellCfg->uplinkConfig = NULLP;
4913    CU_ALLOC(srvCellCfg->uplinkConfig, sizeof(UplinkConfig_t));
4914    if(!srvCellCfg->uplinkConfig)
4915    {
4916       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
4917       return RFAILED;
4918    }
4919
4920    if(BuildUlCfg(srvCellCfg->uplinkConfig) != ROK)
4921    {
4922       DU_LOG("\nERROR  -->  F1AP : BuildUlCfg failed");
4923       return RFAILED;
4924    }
4925    srvCellCfg->supplementaryUplink = NULLP;
4926    srvCellCfg->pdcch_ServingCellConfig = NULLP;
4927
4928    srvCellCfg->pdsch_ServingCellConfig = NULLP;
4929    CU_ALLOC(srvCellCfg->pdsch_ServingCellConfig, sizeof(struct  ServingCellConfig__pdsch_ServingCellConfig));
4930    if(!srvCellCfg->pdsch_ServingCellConfig)
4931    {
4932       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
4933       return RFAILED;
4934    }
4935
4936    if(BuildPdschSrvCellCfg(srvCellCfg->pdsch_ServingCellConfig) != ROK)
4937    {
4938       DU_LOG("\nERROR  -->  F1AP : BuildPdschSrvCellCfg failed");
4939       return RFAILED;
4940    }
4941
4942    srvCellCfg->csi_MeasConfig = NULLP;
4943 #if 0
4944    CU_ALLOC(srvCellCfg->csi_MeasConfig, sizeof(struct   ServingCellConfig__csi_MeasConfig))
4945       if(!srvCellCfg->csi_MeasConfig)
4946       {
4947          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
4948          return RFAILED;
4949       }
4950
4951    if(BuildCsiMeasCfg(srvCellCfg->csi_MeasConfig) != ROK)
4952    {
4953       DU_LOG("\nF1AP : BuildCsiMeasCfg failed");
4954       return RFAILED;
4955    }
4956 #endif
4957    srvCellCfg->sCellDeactivationTimer = NULLP;
4958    srvCellCfg->crossCarrierSchedulingConfig = NULLP;
4959    srvCellCfg->tag_Id = TAG_ID;
4960    srvCellCfg->dummy = NULLP;
4961    srvCellCfg->pathlossReferenceLinking = NULLP;
4962    srvCellCfg->servingCellMO = NULLP;
4963    srvCellCfg->ext1 = NULLP;
4964
4965    return ROK;
4966 }
4967 /*******************************************************************
4968  *
4969  * @brief Builds Spcell config
4970  *
4971  * @details
4972  *
4973  *    Function : BuildSpCellCfg
4974  *
4975  *    Functionality: Builds sp cell config in DuToCuRrcContainer
4976  *
4977  * @params[in] SpCellConfig_t spCellCfg
4978  *
4979  * @return ROK     - success
4980  *         RFAILED - failure
4981  *
4982  * ****************************************************************/
4983 uint8_t BuildSpCellCfg(SpCellConfig_t *spCellCfg)
4984 {
4985
4986    spCellCfg->servCellIndex = NULLP;
4987    CU_ALLOC(spCellCfg->servCellIndex, sizeof(long));
4988    if(!spCellCfg->servCellIndex)
4989    {
4990       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfg");
4991       return RFAILED;
4992    }
4993    *(spCellCfg->servCellIndex) = SERV_CELL_IDX;
4994
4995    spCellCfg->reconfigurationWithSync = NULLP;
4996    spCellCfg->rlf_TimersAndConstants = NULLP;
4997    spCellCfg->rlmInSyncOutOfSyncThreshold = NULLP;
4998    CU_ALLOC(spCellCfg->rlmInSyncOutOfSyncThreshold, sizeof(long));
4999    if(!spCellCfg->rlmInSyncOutOfSyncThreshold)
5000    {
5001       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfg");
5002       return RFAILED;
5003    }
5004    *(spCellCfg->rlmInSyncOutOfSyncThreshold) = RLM_SYNC_OUT_SYNC_THRESHOLD;
5005
5006    spCellCfg->spCellConfigDedicated = NULLP;
5007    CU_ALLOC(spCellCfg->spCellConfigDedicated, sizeof(ServingCellConfig_t));
5008    if(!spCellCfg->spCellConfigDedicated)
5009    {
5010       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfg");
5011       return RFAILED;
5012    }
5013    if(BuildSpCellCfgDed(spCellCfg->spCellConfigDedicated) != ROK)
5014    {
5015       DU_LOG("\nERROR  -->  F1AP : BuildSpCellCfgDed failed");
5016       return RFAILED;
5017    }
5018    return ROK;
5019 }
5020 /*******************************************************************
5021  *
5022  * @brief Builds Phy cell group config
5023  *
5024  * @details
5025  *
5026  *    Function : BuildPhyCellGrpCfg
5027  *
5028  *    Functionality: Builds Phy cell group config in DuToCuRrcContainer
5029  *
5030  * @params[in] PhysicalCellGroupConfig_t *phyCellGrpCfg
5031  *
5032  * @return ROK     - success
5033  *         RFAILED - failure
5034  *
5035  * ****************************************************************/
5036 uint8_t BuildPhyCellGrpCfg(PhysicalCellGroupConfig_t *phyCellGrpCfg)
5037 {
5038    phyCellGrpCfg->harq_ACK_SpatialBundlingPUCCH = NULLP;
5039    phyCellGrpCfg->harq_ACK_SpatialBundlingPUSCH = NULLP;
5040
5041    phyCellGrpCfg->p_NR_FR1 = NULLP;
5042    CU_ALLOC(phyCellGrpCfg->p_NR_FR1, sizeof(long));
5043    if(!phyCellGrpCfg->p_NR_FR1)
5044    {
5045       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildPhyCellGrpCfg");
5046       return RFAILED;
5047    }
5048    *(phyCellGrpCfg->p_NR_FR1)             = P_NR_FR1;
5049    phyCellGrpCfg->pdsch_HARQ_ACK_Codebook = PDSCH_HARQ_ACK_CODEBOOK;
5050    phyCellGrpCfg->tpc_SRS_RNTI = NULLP;
5051    phyCellGrpCfg->tpc_PUCCH_RNTI = NULLP;
5052    phyCellGrpCfg->tpc_PUSCH_RNTI = NULLP;
5053    phyCellGrpCfg->sp_CSI_RNTI = NULLP;
5054    phyCellGrpCfg->cs_RNTI = NULLP;
5055    phyCellGrpCfg->ext1 = NULLP;
5056    phyCellGrpCfg->ext2 = NULLP;
5057
5058    return ROK;
5059 }
5060
5061 /*******************************************************************
5062  *
5063  * @brief Builds tag config
5064  *
5065  * @details
5066  *
5067  *    Function : BuildTagConfig
5068  *
5069  *    Functionality: Builds tag config in MacCellGroupConfig
5070  *
5071  * @params[in] TAG_Config *tag_Config
5072  *
5073  * @return ROK     - success
5074  *         RFAILED - failure
5075  *
5076  * ****************************************************************/
5077 uint8_t BuildTagConfig(struct TAG_Config *tagConfig)
5078 {
5079    struct TAG_Config__tag_ToAddModList *tagList;
5080    uint8_t                     idx, elementCnt;
5081
5082    tagConfig->tag_ToReleaseList = NULLP;
5083    tagConfig->tag_ToAddModList = NULLP;
5084    CU_ALLOC(tagConfig->tag_ToAddModList, sizeof(struct TAG_Config__tag_ToAddModList));
5085    if(!tagConfig->tag_ToAddModList)
5086    {
5087       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildTagConfig");
5088       return RFAILED;
5089    }
5090
5091    elementCnt = 1; //ODU_VALUE_ONE;
5092    tagList = tagConfig->tag_ToAddModList;
5093    tagList->list.count = elementCnt;
5094    tagList->list.size  =  elementCnt * sizeof(struct TAG *);
5095
5096    tagList->list.array = NULLP;
5097    CU_ALLOC(tagList->list.array, tagList->list.size);
5098    if(!tagList->list.array)
5099    {
5100       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildTagConfig");
5101       return RFAILED;
5102    }
5103
5104    for(idx=0; idx<tagList->list.count; idx++)
5105    {
5106       tagList->list.array[idx] = NULLP;
5107       CU_ALLOC(tagList->list.array[idx], sizeof(struct TAG));
5108       if(!tagList->list.array[idx])
5109       {
5110          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildTagConfig");
5111          return RFAILED;
5112       }
5113    }
5114
5115    idx = 0;
5116    tagList->list.array[idx]->tag_Id = TAG_ID;
5117    tagList->list.array[idx]->timeAlignmentTimer = TIME_ALIGNMENT_TMR;
5118
5119    return ROK;
5120 }
5121
5122 /*******************************************************************
5123  *
5124  * @brief Builds PHR Config
5125  *
5126  * @details
5127  *
5128  *    Function : BuildPhrConfig
5129  *
5130  *    Functionality: Builds phrConfig in MacCellGroupConfig
5131  *
5132  * @params[in] PHR Config *
5133  *
5134  * @return ROK     - success
5135  *         RFAILED - failure
5136  *
5137  * ****************************************************************/
5138 uint8_t BuildPhrConfig(struct MAC_CellGroupConfig__phr_Config *phrConfig)
5139 {
5140
5141    phrConfig->present = MAC_CellGroupConfig__phr_Config_PR_setup;
5142    phrConfig->choice.setup = NULLP;
5143    CU_ALLOC(phrConfig->choice.setup, sizeof(struct PHR_Config));
5144    if(!phrConfig->choice.setup)
5145    {
5146       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildPhrConfig");
5147       return RFAILED;
5148    }
5149
5150    phrConfig->choice.setup->phr_PeriodicTimer        = PHR_PERIODIC_TMR;
5151    phrConfig->choice.setup->phr_ProhibitTimer        = PHR_PROHIBHIT_TMR;
5152    phrConfig->choice.setup->phr_Tx_PowerFactorChange = PHR_PWR_FACTOR_CHANGE;
5153    phrConfig->choice.setup->multiplePHR              = false;
5154    phrConfig->choice.setup->dummy                    = false;
5155    phrConfig->choice.setup->phr_Type2OtherCell       = false;
5156    phrConfig->choice.setup->phr_ModeOtherCG          = PHR_MODE_OTHER_CG;
5157
5158    return ROK;
5159 }
5160
5161 /*******************************************************************
5162  *
5163  * @brief Builds BSR Config
5164  *
5165  * @details
5166  *
5167  *    Function : BuildBsrConfig
5168  *
5169  *    Functionality: Builds BuildBsrConfig in MacCellGroupConfig
5170  *
5171  * @params[in] BSR_Config *bsrConfig
5172  *
5173  * @return ROK     - success
5174  *         RFAILED - failure
5175  *
5176  * ****************************************************************/
5177 uint8_t BuildBsrConfig(struct BSR_Config *bsrConfig)
5178 {
5179    bsrConfig->periodicBSR_Timer = PERIODIC_BSR_TMR;
5180    bsrConfig->retxBSR_Timer     = RETX_BSR_TMR;
5181    bsrConfig->logicalChannelSR_DelayTimer = NULLP;
5182
5183    return ROK;
5184 }
5185
5186 /*******************************************************************
5187  *
5188  * @brief Builds scheduling request config
5189  *
5190  * @details
5191  *
5192  *    Function : BuildSchedulingReqConfig
5193  *
5194  *    Functionality: Builds BuildSchedulingReqConfig in MacCellGroupConfig
5195  *
5196  * @params[in] SchedulingRequestConfig *schedulingRequestConfig
5197  *
5198  * @return ROK     - success
5199  *         RFAILED - failure
5200  *
5201  * ****************************************************************/
5202 uint8_t BuildSchedulingReqConfig(struct SchedulingRequestConfig *schedulingRequestConfig)
5203 {
5204    struct SchedulingRequestConfig__schedulingRequestToAddModList *schReqList;
5205    uint8_t                     idx, elementCnt;
5206
5207    schedulingRequestConfig->schedulingRequestToAddModList = NULLP;
5208    CU_ALLOC(schedulingRequestConfig->schedulingRequestToAddModList,
5209          sizeof(struct SchedulingRequestConfig__schedulingRequestToAddModList));
5210    if(!schedulingRequestConfig->schedulingRequestToAddModList)
5211    {
5212       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSchedulingReqConfig");
5213       return RFAILED;
5214    }
5215
5216    elementCnt = 1; //ODU_VALUE_ONE;
5217    schReqList = schedulingRequestConfig->schedulingRequestToAddModList;
5218    schReqList->list.count = elementCnt;
5219    schReqList->list.size  = elementCnt * sizeof(struct SchedulingRequestToAddMod *);
5220
5221    schReqList->list.array = NULLP;
5222    CU_ALLOC(schReqList->list.array, schReqList->list.size);
5223    if(!schReqList->list.array)
5224    {
5225       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSchedulingReqConfig");
5226       return RFAILED;
5227    }
5228
5229    for(idx=0;idx<schReqList->list.count; idx++)
5230    {
5231       schReqList->list.array[idx] = NULLP;
5232       CU_ALLOC(schReqList->list.array[idx], sizeof(struct SchedulingRequestToAddMod));
5233       if(!schReqList->list.array[idx])
5234       {
5235          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSchedulingReqConfig");
5236          return RFAILED;
5237       }
5238    }
5239
5240    idx = 0;
5241    schReqList->list.array[idx]->schedulingRequestId = SCH_REQ_ID;
5242
5243    schReqList->list.array[idx]->sr_ProhibitTimer = NULLP;
5244    CU_ALLOC(schReqList->list.array[idx]->sr_ProhibitTimer, sizeof(long));
5245    if(!schReqList->list.array[idx]->sr_ProhibitTimer)
5246    {
5247       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSchedulingReqConfig");
5248       return RFAILED;
5249    }
5250    *(schReqList->list.array[idx]->sr_ProhibitTimer) = SR_PROHIBIT_TMR;
5251    schReqList->list.array[idx]->sr_TransMax = SR_TRANS_MAX;
5252    schedulingRequestConfig->schedulingRequestToReleaseList = NULLP;
5253
5254    return ROK;
5255 }
5256 /*******************************************************************
5257  *
5258  * @brief Builds Mac cell group config
5259  *
5260  * @details
5261  *
5262  *    Function : BuildMacCellGrpCfg
5263  *
5264  *    Functionality: Builds Mac cell group config in DuToCuRrcContainer
5265  *
5266  * @params[in] MAC_CellGroupConfig_t *macCellGrpCfg
5267  *
5268  * @return ROK     - success
5269  *         RFAILED - failure
5270  *
5271  * ****************************************************************/
5272 uint8_t BuildMacCellGrpCfg(MAC_CellGroupConfig_t *macCellGrpCfg)
5273 {
5274    macCellGrpCfg->drx_Config = NULLP;
5275    macCellGrpCfg->schedulingRequestConfig = NULLP;
5276    CU_ALLOC(macCellGrpCfg->schedulingRequestConfig, sizeof(struct SchedulingRequestConfig));
5277    if(!macCellGrpCfg->schedulingRequestConfig)
5278    {
5279       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacCellGrpCfg");
5280       return RFAILED;
5281    }
5282
5283    if(BuildSchedulingReqConfig(macCellGrpCfg->schedulingRequestConfig) != ROK)
5284    {
5285       DU_LOG("\nERROR  -->  F1AP : BuildSchedulingReqConfig failed");
5286       return RFAILED;
5287    }
5288
5289    macCellGrpCfg->bsr_Config = NULLP;
5290    CU_ALLOC(macCellGrpCfg->bsr_Config, sizeof(struct BSR_Config));
5291    if(!macCellGrpCfg->bsr_Config)
5292    {
5293       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacCellGrpCfg");
5294       return RFAILED;
5295    }
5296
5297    if(BuildBsrConfig(macCellGrpCfg->bsr_Config) != ROK)
5298    {
5299       DU_LOG("\nERROR  -->  F1AP : BuildBsrConfig failed");
5300       return RFAILED;
5301    }
5302
5303    macCellGrpCfg->tag_Config = NULLP;
5304    CU_ALLOC(macCellGrpCfg->tag_Config, sizeof(struct TAG_Config));
5305    if(!macCellGrpCfg->tag_Config)
5306    {
5307       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacCellGrpCfg");
5308       return RFAILED;
5309    }
5310
5311    if(BuildTagConfig(macCellGrpCfg->tag_Config) != ROK)
5312    {
5313       DU_LOG("\nERROR  -->  F1AP : BuildTagConfig failed");
5314       return RFAILED;
5315    }
5316
5317    macCellGrpCfg->phr_Config = NULLP;
5318    CU_ALLOC(macCellGrpCfg->phr_Config, sizeof(struct MAC_CellGroupConfig__phr_Config));
5319    if(!macCellGrpCfg->phr_Config)
5320    {
5321       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacCellGrpCfg");
5322       return RFAILED;
5323    }
5324
5325    if(BuildPhrConfig(macCellGrpCfg->phr_Config) != ROK)
5326    {
5327       DU_LOG("\nERROR  -->  F1AP : BuildPhrConfig failed");
5328       return RFAILED;
5329    }
5330
5331    macCellGrpCfg->skipUplinkTxDynamic = false;
5332    macCellGrpCfg->ext1 = NULLP;
5333
5334    return ROK;
5335 }
5336 /*******************************************************************
5337  *
5338  * @brief Frees memeory allocated for SearchSpcToAddModList
5339  *
5340  * @details
5341  *
5342  *    Function : FreeSearchSpcToAddModList
5343  *
5344  *    Functionality: Deallocating memory of SearchSpcToAddModList
5345  *
5346  * @params[in] struct PDCCH_Config__searchSpacesToAddModList *searchSpcList
5347  *
5348  * @return void
5349  *
5350  4221 * ****************************************************************/
5351 void FreeSearchSpcToAddModList(struct PDCCH_Config__searchSpacesToAddModList *searchSpcList)
5352 {
5353    uint8_t idx1=0;
5354    uint8_t idx2=0;
5355    struct  SearchSpace *searchSpc=NULLP;
5356
5357    if(searchSpcList->list.array)
5358    {
5359       if(searchSpcList->list.array[idx2])
5360       {
5361          searchSpc = searchSpcList->list.array[idx2];
5362          if(searchSpc->controlResourceSetId)
5363          {
5364             if(searchSpc->monitoringSlotPeriodicityAndOffset)
5365             {
5366                if(searchSpc->monitoringSymbolsWithinSlot)
5367                {
5368                   if(searchSpc->monitoringSymbolsWithinSlot->buf)
5369                   {
5370                      if(searchSpc->nrofCandidates)
5371                      {
5372                         if(searchSpc->searchSpaceType)
5373                         {
5374                            CU_FREE(searchSpc->searchSpaceType->choice.ue_Specific,\
5375                                  sizeof(struct SearchSpace__searchSpaceType__ue_Specific));
5376                            CU_FREE(searchSpc->searchSpaceType, sizeof(struct
5377                                     SearchSpace__searchSpaceType));
5378                         }
5379                         CU_FREE(searchSpc->nrofCandidates,
5380                               sizeof(struct SearchSpace__nrofCandidates));
5381                      }
5382                      CU_FREE(searchSpc->monitoringSymbolsWithinSlot->buf, \
5383                            searchSpc->monitoringSymbolsWithinSlot->size);
5384                   }
5385                   CU_FREE(searchSpc->monitoringSymbolsWithinSlot,
5386                         sizeof(BIT_STRING_t));
5387                }
5388                CU_FREE(searchSpc->monitoringSlotPeriodicityAndOffset, \
5389                      sizeof(struct SearchSpace__monitoringSlotPeriodicityAndOffset));
5390             }
5391             CU_FREE(searchSpc->controlResourceSetId,
5392                   sizeof(ControlResourceSetId_t));
5393          }
5394       }
5395       for(idx1 = 0; idx1 < searchSpcList->list.count; idx1++)
5396       {
5397          CU_FREE(searchSpcList->list.array[idx1],
5398                sizeof(struct SearchSpace));
5399       }
5400       CU_FREE(searchSpcList->list.array,searchSpcList->list.size);
5401    }
5402 }
5403 /*******************************************************************
5404  *
5405  * @brief Frees memory allocated for PdschTimeDomAllocList
5406  *
5407  * @details
5408  *
5409  *    Function : FreePdschTimeDomAllocList
5410  *
5411  *    Functionality: Deallocating memory of PdschTimeDomAllocList
5412  *
5413  * @params[in] struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList
5414  *
5415  * @return void
5416  *
5417  4221 * ****************************************************************/
5418 void FreePdschTimeDomAllocList( struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList)
5419 {
5420    uint8_t idx1=0;
5421
5422    if(timeDomAllocList->choice.setup)
5423    {
5424       if(timeDomAllocList->choice.setup->list.array)
5425       {
5426          for(idx1 = 0; idx1 <timeDomAllocList->choice.setup->list.count ; idx1++)
5427          {
5428             CU_FREE(timeDomAllocList->choice.setup->list.array[idx1],
5429                   sizeof(struct PDSCH_TimeDomainResourceAllocation));
5430          }
5431          CU_FREE(timeDomAllocList->choice.setup->list.array, \
5432                timeDomAllocList->choice.setup->list.size);
5433       }
5434       CU_FREE(timeDomAllocList->choice.setup,\
5435             sizeof(struct PDSCH_TimeDomainResourceAllocationList));
5436    }
5437 }
5438 /*******************************************************************
5439  *
5440  * @brief Frees memory allocated for PuschTimeDomAllocList
5441  *
5442  *@details
5443  *
5444  *    Function : FreePuschTimeDomAllocList
5445  *
5446  *    Functionality: Deallocating memory of PuschTimeDomAllocList
5447  *
5448  * @params[in] PUSCH_Config_t *puschCfg
5449  *
5450  * @return void
5451  *
5452  ***********************************************************************/
5453 void FreePuschTimeDomAllocList(PUSCH_Config_t *puschCfg)
5454 {
5455    uint8_t idx1=0;
5456    uint8_t idx2=0;
5457    struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList_t=NULLP;
5458
5459    if(puschCfg->pusch_TimeDomainAllocationList)
5460    {
5461       timeDomAllocList_t=puschCfg->pusch_TimeDomainAllocationList;
5462       if(timeDomAllocList_t->choice.setup)
5463       {
5464          if(timeDomAllocList_t->choice.setup->list.array)
5465          {
5466             CU_FREE(timeDomAllocList_t->choice.setup->list.array[idx2]->k2, sizeof(long));
5467             for(idx1 = 0; idx1<timeDomAllocList_t->choice.setup->list.count; idx1++)
5468             {
5469                CU_FREE(timeDomAllocList_t->choice.setup->list.array[idx1],\
5470                      sizeof(PUSCH_TimeDomainResourceAllocation_t));
5471             }
5472             CU_FREE(timeDomAllocList_t->choice.setup->list.array, \
5473                   timeDomAllocList_t->choice.setup->list.size);
5474          }
5475          CU_FREE(timeDomAllocList_t->choice.setup, \
5476                sizeof(struct PUSCH_TimeDomainResourceAllocationList));
5477       }
5478       CU_FREE(puschCfg->transformPrecoder, sizeof(long));
5479       CU_FREE(puschCfg->pusch_TimeDomainAllocationList, \
5480             sizeof(struct PUSCH_Config__pusch_TimeDomainAllocationList));
5481    }
5482
5483 }
5484
5485 /*******************************************************************
5486  *
5487  * @brief Frees memory allocated for Dedicated PUCCH config
5488  *
5489  * @details
5490  *
5491  *    Function : FreeBWPUlDedPucchCfg
5492  *
5493  *    Functionality: Deallocating memory of Dedicated PUCCH cfg
5494  *
5495  * @params[in] BWP_UplinkDedicated__pucch_Config *ulBwpPucchCfg
5496  *
5497  * @return void
5498  *
5499  * ****************************************************************/
5500 void FreeBWPUlDedPucchCfg(struct BWP_UplinkDedicated__pucch_Config *ulBwpPucchCfg)
5501 {
5502    uint8_t arrIdx, rsrcIdx, rsrcSetIdx;
5503    PUCCH_Config_t *pucchCfg = NULLP;
5504    PUCCH_ResourceSet_t *rsrcSet = NULLP;
5505    PUCCH_Resource_t *rsrc = NULLP;
5506
5507    if(ulBwpPucchCfg)
5508    {
5509       if(ulBwpPucchCfg->choice.setup)
5510       {
5511          pucchCfg = ulBwpPucchCfg->choice.setup;
5512
5513          //Free resource set list
5514          if(pucchCfg->resourceSetToAddModList)
5515          {
5516             if(pucchCfg->resourceSetToAddModList->list.array)
5517             {
5518                for(rsrcSetIdx=0; rsrcSetIdx < pucchCfg->resourceSetToAddModList->list.count; rsrcSetIdx++)
5519                {
5520                   rsrcSet = pucchCfg->resourceSetToAddModList->list.array[rsrcSetIdx];
5521                   if(rsrcSet->resourceList.list.array)
5522                   {
5523                      for(rsrcIdx=0; rsrcIdx < rsrcSet->resourceList.list.count; rsrcIdx++)
5524                      {
5525                         CU_FREE(rsrcSet->resourceList.list.array[rsrcIdx], sizeof(PUCCH_ResourceId_t));
5526                      }
5527                      CU_FREE(rsrcSet->resourceList.list.array, rsrcSet->resourceList.list.size);
5528                   }
5529                   CU_FREE(pucchCfg->resourceSetToAddModList->list.array[rsrcSetIdx], sizeof(PUCCH_ResourceSet_t));
5530                }
5531                CU_FREE(pucchCfg->resourceSetToAddModList->list.array, pucchCfg->resourceSetToAddModList->list.size);
5532             }
5533             CU_FREE(pucchCfg->resourceSetToAddModList, sizeof(struct PUCCH_Config__resourceSetToAddModList));
5534          }
5535
5536          //Free resource list
5537          if(pucchCfg->resourceToAddModList)
5538          {
5539             if(pucchCfg->resourceToAddModList->list.array)
5540             {
5541                for(rsrcIdx=0; rsrcIdx < pucchCfg->resourceToAddModList->list.count; rsrcIdx++)
5542                {
5543                   rsrc = pucchCfg->resourceToAddModList->list.array[rsrcIdx];
5544                   CU_FREE(rsrc->format.choice.format1, sizeof(PUCCH_format1_t));
5545                   CU_FREE(pucchCfg->resourceToAddModList->list.array[rsrcIdx], sizeof(PUCCH_Resource_t));
5546                }
5547                CU_FREE(pucchCfg->resourceToAddModList->list.array, pucchCfg->resourceToAddModList->list.size);
5548             }
5549             CU_FREE(pucchCfg->resourceToAddModList, sizeof(struct PUCCH_Config__resourceToAddModList));
5550          }
5551
5552          //PUCCH Format 1
5553          if(pucchCfg->format1)
5554          {
5555             if(pucchCfg->format1->choice.setup)
5556             {
5557                CU_FREE(pucchCfg->format1->choice.setup->nrofSlots, sizeof(long));
5558                CU_FREE(pucchCfg->format1->choice.setup, sizeof(PUCCH_FormatConfig_t));
5559             }
5560             CU_FREE(pucchCfg->format1, sizeof(struct PUCCH_Config__format1));
5561          }
5562
5563          //DL DATA TO UL ACK
5564          if(pucchCfg->dl_DataToUL_ACK)
5565          {
5566             if(pucchCfg->dl_DataToUL_ACK->list.array)
5567             {
5568                for(arrIdx = 0; arrIdx <  pucchCfg->dl_DataToUL_ACK->list.count; arrIdx++)
5569                {
5570                   CU_FREE(pucchCfg->dl_DataToUL_ACK->list.array[arrIdx], sizeof(long));
5571                }
5572                CU_FREE(pucchCfg->dl_DataToUL_ACK->list.array, pucchCfg->dl_DataToUL_ACK->list.size);
5573             }
5574             CU_FREE(pucchCfg->dl_DataToUL_ACK, sizeof(struct PUCCH_Config__dl_DataToUL_ACK));
5575          }
5576
5577          CU_FREE(ulBwpPucchCfg->choice.setup, sizeof(PUCCH_Config_t));
5578       }
5579       CU_FREE(ulBwpPucchCfg, sizeof(struct BWP_UplinkDedicated__pucch_Config));
5580    }
5581 }
5582
5583 /*******************************************************************
5584  *
5585  * @brief Frees memory allocated for InitialUlBWP
5586  *
5587  * @details
5588  *
5589  *    Function : FreeInitialUlBWP
5590  *
5591  *    Functionality: Deallocating memory of InitialUlBWP
5592  *
5593  * @params[in] BWP_UplinkDedicated_t *ulBwp
5594  *
5595  * @return void
5596  *
5597  * ****************************************************************/
5598 void FreeInitialUlBWP(BWP_UplinkDedicated_t *ulBwp)
5599 {
5600    uint8_t  rSetIdx, rsrcIdx;
5601    SRS_Config_t   *srsCfg = NULLP;
5602    PUSCH_Config_t *puschCfg = NULLP;
5603    struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA *dmrsUlCfg = NULLP;
5604    struct SRS_Config__srs_ResourceSetToAddModList *rsrcSetList = NULLP;
5605    struct SRS_ResourceSet__srs_ResourceIdList *rsrcIdList = NULLP;
5606    struct SRS_Config__srs_ResourceToAddModList *resourceList = NULLP;
5607
5608    FreeBWPUlDedPucchCfg(ulBwp->pucch_Config);
5609
5610    if(ulBwp->pusch_Config)
5611    {
5612       if(ulBwp->pusch_Config->choice.setup)
5613       {
5614          puschCfg=ulBwp->pusch_Config->choice.setup;
5615          if(puschCfg->dataScramblingIdentityPUSCH)
5616          {
5617             if(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA)
5618             {
5619                FreePuschTimeDomAllocList(puschCfg);
5620                dmrsUlCfg=puschCfg->dmrs_UplinkForPUSCH_MappingTypeA;
5621                if(dmrsUlCfg->choice.setup)
5622                {
5623                   if(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition)
5624                   {
5625                      if(dmrsUlCfg->choice.setup->transformPrecodingDisabled)
5626                      {
5627                         CU_FREE(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0,\
5628                               sizeof(long));
5629                         CU_FREE(dmrsUlCfg->choice.setup->transformPrecodingDisabled,
5630                               sizeof(struct DMRS_UplinkConfig__transformPrecodingDisabled));
5631                      }
5632                      CU_FREE(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition,
5633                            sizeof(long));
5634                   }
5635                   CU_FREE(dmrsUlCfg->choice.setup,sizeof(DMRS_UplinkConfig_t));
5636                }
5637                CU_FREE(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA, \
5638                      sizeof(struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA));
5639             }
5640             CU_FREE(puschCfg->dataScramblingIdentityPUSCH, sizeof(long));
5641          }
5642          CU_FREE(ulBwp->pusch_Config->choice.setup, sizeof(PUSCH_Config_t));
5643       }
5644       CU_FREE(ulBwp->pusch_Config, sizeof(struct BWP_UplinkDedicated__pusch_Config));
5645
5646       /* Free SRS-Config */
5647       if(ulBwp->srs_Config)
5648       {
5649          if(ulBwp->srs_Config->choice.setup)
5650          {
5651             srsCfg = ulBwp->srs_Config->choice.setup;
5652
5653             /* Free Resource Set to add/mod list */
5654             if(srsCfg->srs_ResourceSetToAddModList)
5655             {
5656                rsrcSetList = srsCfg->srs_ResourceSetToAddModList;
5657                if(rsrcSetList->list.array)
5658                {
5659                   rSetIdx = 0;
5660
5661                   /* Free SRS resource Id list in this SRS resource set */
5662                   if(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList)
5663                   {
5664                      rsrcIdList = rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList;
5665
5666                      if(rsrcIdList->list.array)
5667                      {
5668                         for(rsrcIdx = 0; rsrcIdx < rsrcIdList->list.count; rsrcIdx++)
5669                         {
5670                            CU_FREE(rsrcIdList->list.array[rsrcIdx], sizeof(SRS_ResourceId_t));
5671                         }
5672                         CU_FREE(rsrcIdList->list.array, rsrcIdList->list.size);
5673                      }
5674                      CU_FREE(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList,\
5675                            sizeof(struct SRS_ResourceSet__srs_ResourceIdList));
5676                   }
5677
5678                   /* Free resource type info for this SRS resource set */
5679                   CU_FREE(rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic, \
5680                         sizeof(struct SRS_ResourceSet__resourceType__aperiodic));
5681
5682                   /* Free memory for each resource set */
5683                   for(rSetIdx = 0; rSetIdx < rsrcSetList->list.count; rSetIdx++)
5684                   {
5685                      CU_FREE(rsrcSetList->list.array[rSetIdx], sizeof(SRS_ResourceSet_t));
5686                   }
5687                   CU_FREE(rsrcSetList->list.array, rsrcSetList->list.size);
5688                }
5689                CU_FREE(srsCfg->srs_ResourceSetToAddModList, \
5690                      sizeof(struct SRS_Config__srs_ResourceSetToAddModList));
5691             }
5692
5693             /* Free resource to add/modd list */
5694             if(srsCfg->srs_ResourceToAddModList)
5695             {
5696                resourceList = srsCfg->srs_ResourceToAddModList;
5697                if(resourceList->list.array)
5698                {
5699                   rsrcIdx = 0;
5700                   CU_FREE(resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2,\
5701                         sizeof(struct SRS_Resource__transmissionComb__n2));
5702                   CU_FREE(resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic,\
5703                         sizeof(struct SRS_Resource__resourceType__aperiodic));
5704
5705                   for(rsrcIdx = 0; rsrcIdx < resourceList->list.count; rsrcIdx++)
5706                   {
5707                      CU_FREE(resourceList->list.array[rsrcIdx], sizeof(SRS_Resource_t));
5708                   }
5709                   CU_FREE(resourceList->list.array, resourceList->list.size);
5710                }
5711                CU_FREE(srsCfg->srs_ResourceToAddModList, \
5712                      sizeof(struct SRS_Config__srs_ResourceToAddModList));
5713             }
5714
5715             CU_FREE(ulBwp->srs_Config->choice.setup, sizeof(SRS_Config_t));
5716          }
5717          CU_FREE(ulBwp->srs_Config, sizeof(struct BWP_UplinkDedicated__srs_Config));
5718       }
5719    }
5720 }
5721 /*******************************************************************
5722  *
5723  * @brief Frees memory allocated for initialUplinkBWP
5724  *
5725  * @details
5726  *
5727  *    Function : FreeinitialUplinkBWP
5728  *
5729  *    Functionality: Deallocating memory of initialUplinkBWP
5730  *
5731  * @params[in] UplinkConfig_t *ulCfg
5732  *
5733  * @return void
5734  *
5735  *
5736  * ****************************************************************/
5737 void FreeinitialUplinkBWP(UplinkConfig_t *ulCfg)
5738 {
5739    BWP_UplinkDedicated_t *ulBwp=NULLP;
5740    struct UplinkConfig__pusch_ServingCellConfig *puschCfg=NULLP;
5741
5742    if(ulCfg->initialUplinkBWP)
5743    {
5744       ulBwp=ulCfg->initialUplinkBWP;
5745       if(ulCfg->firstActiveUplinkBWP_Id)
5746       {
5747          if(ulCfg->pusch_ServingCellConfig)
5748          {
5749             puschCfg=ulCfg->pusch_ServingCellConfig;
5750             if(puschCfg->choice.setup)
5751             {
5752                if(puschCfg->choice.setup->ext1)
5753                {
5754                   CU_FREE(puschCfg->choice.setup->ext1->\
5755                         processingType2Enabled,sizeof(BOOLEAN_t));
5756                   CU_FREE(puschCfg->choice.setup->ext1->\
5757                         maxMIMO_Layers,sizeof(long));
5758                   CU_FREE(puschCfg->choice.setup->ext1, \
5759                         sizeof(struct PUSCH_ServingCellConfig__ext1));
5760                }
5761                CU_FREE(puschCfg->choice.setup, sizeof(struct PUSCH_ServingCellConfig));
5762             }
5763             CU_FREE(ulCfg->pusch_ServingCellConfig, sizeof(struct UplinkConfig__pusch_ServingCellConfig));
5764          }
5765          CU_FREE(ulCfg->firstActiveUplinkBWP_Id, sizeof(BWP_Id_t));
5766       }
5767       FreeInitialUlBWP(ulBwp);
5768       CU_FREE(ulCfg->initialUplinkBWP, sizeof(BWP_UplinkDedicated_t));
5769    }
5770 }
5771 /*******************************************************************
5772  *
5773  * @brief Frees emmory allocated for BWPDlDedPdschCfg
5774  *
5775  * @details
5776  *
5777  *    Function : FreeBWPDlDedPdschCfg
5778  *
5779  *    Functionality: Deallocating memory of BWPDlDedPdschCfg
5780  *
5781  * @params[in] BWP_DownlinkDedicated_t *dlBwp
5782  *
5783  * @return void
5784  *
5785  *
5786  * ****************************************************************/
5787 void FreeBWPDlDedPdschCfg(BWP_DownlinkDedicated_t *dlBwp)
5788 {
5789    struct PDSCH_Config *pdschCfg=NULLP;
5790    struct PDSCH_Config__prb_BundlingType *prbBndlType=NULLP;
5791    struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList=NULLP;
5792    struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA *dmrsDlCfg=NULLP;
5793
5794    if(dlBwp->pdsch_Config->choice.setup)
5795    {
5796       pdschCfg=dlBwp->pdsch_Config->choice.setup;
5797       if(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA)
5798       {
5799          if(pdschCfg->pdsch_TimeDomainAllocationList)
5800          {
5801             timeDomAllocList=pdschCfg->pdsch_TimeDomainAllocationList;
5802             if(pdschCfg->maxNrofCodeWordsScheduledByDCI)
5803             {
5804                prbBndlType=&pdschCfg->prb_BundlingType;
5805                CU_FREE(prbBndlType->choice.staticBundling,\
5806                      sizeof(struct PDSCH_Config__prb_BundlingType__staticBundling));
5807                CU_FREE(pdschCfg->maxNrofCodeWordsScheduledByDCI, sizeof(long));
5808             }
5809             FreePdschTimeDomAllocList(timeDomAllocList);
5810             CU_FREE(pdschCfg->pdsch_TimeDomainAllocationList, \
5811                   sizeof(struct PDSCH_Config__pdsch_TimeDomainAllocationList));
5812          }
5813          dmrsDlCfg=pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA;
5814          if(dmrsDlCfg->choice.setup)
5815          {
5816             CU_FREE(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition,
5817                   sizeof(long));
5818             CU_FREE(dmrsDlCfg->choice.setup, sizeof(struct DMRS_DownlinkConfig));
5819          }
5820          CU_FREE(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA, \
5821                sizeof(struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA));
5822       }
5823       CU_FREE(dlBwp->pdsch_Config->choice.setup, sizeof(struct PDSCH_Config));
5824    }
5825 }
5826 /*******************************************************************
5827  *
5828  * @brief Frees emmory allocated for BWPDlDedPdcchCfg
5829  *
5830  * @details
5831  *
5832  *    Function : FreeBWPDlDedPdcchCfg
5833  *
5834  *    Functionality: Deallocating memory of BWPDlDedPdcchCfg
5835  *
5836  * @params[in] BWP_DownlinkDedicated_t *dlBwp
5837  *
5838  * @return void
5839  *
5840  *
5841  * ****************************************************************/
5842 void FreeBWPDlDedPdcchCfg(BWP_DownlinkDedicated_t *dlBwp)
5843 {
5844    uint8_t idx1=0;
5845    uint8_t idx2=0;
5846    struct PDCCH_Config *pdcchCfg=NULLP;
5847    struct ControlResourceSet *controlRSet=NULLP;
5848    struct PDCCH_Config__controlResourceSetToAddModList *controlRSetList=NULLP;
5849
5850    if(dlBwp->pdcch_Config->choice.setup)
5851    {
5852       pdcchCfg=dlBwp->pdcch_Config->choice.setup;
5853       if(pdcchCfg->controlResourceSetToAddModList)
5854       {
5855          controlRSetList = pdcchCfg->controlResourceSetToAddModList;
5856          if(controlRSetList->list.array)
5857          {
5858             controlRSet = controlRSetList->list.array[idx2];
5859             if(controlRSet)
5860             {
5861                if(controlRSet->frequencyDomainResources.buf)
5862                {
5863                   if(controlRSet->pdcch_DMRS_ScramblingID)
5864                   {
5865                      if(pdcchCfg->searchSpacesToAddModList)
5866                      {
5867                         FreeSearchSpcToAddModList(pdcchCfg->searchSpacesToAddModList);
5868                         CU_FREE(pdcchCfg->searchSpacesToAddModList, \
5869                               sizeof(struct PDCCH_Config__searchSpacesToAddModList));
5870                      }
5871                      CU_FREE(controlRSet->pdcch_DMRS_ScramblingID, sizeof(long));
5872                   }
5873                   CU_FREE(controlRSet->frequencyDomainResources.buf, \
5874                         controlRSet->frequencyDomainResources.size);
5875                }
5876             }
5877             for(idx1 = 0; idx1 <controlRSetList->list.count; idx1++)
5878             {
5879                CU_FREE(controlRSetList->list.array[idx1], sizeof(struct ControlResourceSet));
5880             }
5881             CU_FREE(controlRSetList->list.array, controlRSetList->list.size);
5882          }
5883          CU_FREE(pdcchCfg->controlResourceSetToAddModList, \
5884                sizeof(struct PDCCH_Config__controlResourceSetToAddModList));
5885       }
5886       CU_FREE(dlBwp->pdcch_Config->choice.setup, sizeof(struct PDCCH_Config));
5887    }
5888 }
5889 /*******************************************************************
5890  *
5891  * @brief Builds RLC Config
5892  *
5893  * @details
5894  *
5895  *    Function : BuildRlcConfig
5896  *
5897  *    Functionality: Builds RLC Config in BuildRlcBearerToAddModList
5898  *
5899  * @params[in] RLC_Config *rlcConfig
5900  *
5901  * @return ROK     - success
5902  *         RFAILED - failure
5903  *
5904  * ****************************************************************/
5905 uint8_t BuildRlcConfig(RlcLcCfg rlcLcCfgDb, struct RLC_Config *rlcConfig)
5906 {
5907    rlcConfig->present = rlcLcCfgDb.rlcMode;
5908
5909    switch(rlcConfig->present)
5910    {
5911       case RLC_Config_PR_am:
5912          {
5913             rlcConfig->choice.am = NULLP;
5914             CU_ALLOC(rlcConfig->choice.am, sizeof(struct RLC_Config__am));
5915             if(!rlcConfig->choice.am)
5916             {
5917                DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfig");
5918                return RFAILED;
5919             }
5920
5921             /* UL */
5922             rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength = NULLP;
5923             CU_ALLOC(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
5924             if(!rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength)
5925             {
5926                DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfig");
5927                return RFAILED;
5928             }
5929             *(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength) = rlcLcCfgDb.u.amCfg.ulAmCfg.snLenUl;
5930             rlcConfig->choice.am->ul_AM_RLC.t_PollRetransmit  = rlcLcCfgDb.u.amCfg.ulAmCfg.pollRetxTmr;
5931             rlcConfig->choice.am->ul_AM_RLC.pollPDU           = rlcLcCfgDb.u.amCfg.ulAmCfg.pollPdu;
5932             rlcConfig->choice.am->ul_AM_RLC.pollByte          = rlcLcCfgDb.u.amCfg.ulAmCfg.pollByte;
5933             rlcConfig->choice.am->ul_AM_RLC.maxRetxThreshold  = rlcLcCfgDb.u.amCfg.ulAmCfg.maxRetxTh;
5934
5935             /* DL */
5936             rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength = NULLP;
5937             CU_ALLOC(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
5938             if(!rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength)
5939             {
5940                DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfig");
5941                return RFAILED;
5942             }
5943             *(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength) = rlcLcCfgDb.u.amCfg.dlAmCfg.snLenDl;
5944             rlcConfig->choice.am->dl_AM_RLC.t_Reassembly      = rlcLcCfgDb.u.amCfg.dlAmCfg.reAssemTmr;
5945             rlcConfig->choice.am->dl_AM_RLC.t_StatusProhibit  = rlcLcCfgDb.u.amCfg.dlAmCfg.statProhTmr;
5946
5947             break;
5948          }
5949
5950       case RLC_Config_PR_um_Bi_Directional:
5951          {
5952             rlcConfig->choice.um_Bi_Directional = NULLP;
5953             CU_ALLOC(rlcConfig->choice.um_Bi_Directional, sizeof(struct RLC_Config__um_Bi_Directional));
5954             if(!rlcConfig->choice.um_Bi_Directional)
5955             {
5956                DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfig");
5957                return RFAILED;
5958             }
5959
5960             /* UL */
5961             rlcConfig->choice.um_Bi_Directional->ul_UM_RLC.sn_FieldLength = NULLP;
5962             CU_ALLOC(rlcConfig->choice.um_Bi_Directional->ul_UM_RLC.sn_FieldLength, sizeof(SN_FieldLengthUM_t));
5963             if(!rlcConfig->choice.um_Bi_Directional->ul_UM_RLC.sn_FieldLength)
5964             {
5965                DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfig");
5966                return RFAILED;
5967             }
5968             *(rlcConfig->choice.um_Bi_Directional->ul_UM_RLC.sn_FieldLength) = rlcLcCfgDb.u.umBiDirCfg.ulUmCfg.snLenUlUm;
5969
5970             /* DL */
5971             rlcConfig->choice.um_Bi_Directional->dl_UM_RLC.sn_FieldLength = NULLP;
5972             CU_ALLOC(rlcConfig->choice.um_Bi_Directional->dl_UM_RLC.sn_FieldLength, sizeof(SN_FieldLengthUM_t));
5973             if(!rlcConfig->choice.um_Bi_Directional->dl_UM_RLC.sn_FieldLength)
5974             {
5975                DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfig");
5976                return RFAILED;
5977             }
5978             *(rlcConfig->choice.um_Bi_Directional->dl_UM_RLC.sn_FieldLength) = rlcLcCfgDb.u.umBiDirCfg.dlUmCfg.snLenDlUm;
5979             rlcConfig->choice.um_Bi_Directional->dl_UM_RLC.t_Reassembly = rlcLcCfgDb.u.umBiDirCfg.dlUmCfg.reAssemTmr;
5980             break;
5981          }
5982    }
5983    return ROK;
5984 }
5985
5986 /*******************************************************************
5987  *
5988  * @brief Builds MAC LC Config
5989  *
5990  * @details
5991  *
5992  *    Function : BuildMacLCConfig
5993  *
5994  *    Functionality: Builds MAC LC Config in BuildRlcBearerToAddModList
5995  *
5996  * @params[in] struct LogicalChannelConfig macLcConfig
5997  *
5998  * @return ROK     - success
5999  *         RFAILED - failure
6000  *
6001  * ****************************************************************/
6002 uint8_t BuildMacLCConfig(MacLcCfg macLcCfgDb, struct LogicalChannelConfig *macLcConfig)
6003 {
6004
6005    macLcConfig->ul_SpecificParameters = NULLP;
6006    CU_ALLOC(macLcConfig->ul_SpecificParameters, sizeof(struct LogicalChannelConfig__ul_SpecificParameters));
6007    if(!macLcConfig->ul_SpecificParameters)
6008    {
6009       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacLCConfig");
6010       return RFAILED;
6011    }
6012
6013    macLcConfig->ul_SpecificParameters->priority = macLcCfgDb.priority;
6014    macLcConfig->ul_SpecificParameters->prioritisedBitRate =     macLcCfgDb.pbr;
6015    macLcConfig->ul_SpecificParameters->bucketSizeDuration =     macLcCfgDb.bsd;
6016    macLcConfig->ul_SpecificParameters->allowedServingCells = NULLP;
6017    macLcConfig->ul_SpecificParameters->allowedSCS_List = NULLP;
6018    macLcConfig->ul_SpecificParameters->maxPUSCH_Duration = NULLP;
6019    macLcConfig->ul_SpecificParameters->configuredGrantType1Allowed = NULLP;
6020
6021    macLcConfig->ul_SpecificParameters->logicalChannelGroup = NULLP;
6022    CU_ALLOC(macLcConfig->ul_SpecificParameters->logicalChannelGroup,    sizeof(long));
6023    if(!macLcConfig->ul_SpecificParameters->logicalChannelGroup)
6024    {
6025       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacLCConfig");
6026       return RFAILED;
6027    }
6028    *(macLcConfig->ul_SpecificParameters->logicalChannelGroup) = macLcCfgDb.lcGroup;
6029
6030    macLcConfig->ul_SpecificParameters->schedulingRequestID = NULLP;
6031    CU_ALLOC(macLcConfig->ul_SpecificParameters->schedulingRequestID,    sizeof(SchedulingRequestId_t));
6032    if(!macLcConfig->ul_SpecificParameters->schedulingRequestID)
6033    {
6034       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacLCConfig");
6035       return RFAILED;
6036    }
6037    *(macLcConfig->ul_SpecificParameters->schedulingRequestID) = macLcCfgDb.schReqId;
6038
6039    macLcConfig->ul_SpecificParameters->logicalChannelSR_Mask = false;
6040    macLcConfig->ul_SpecificParameters->logicalChannelSR_DelayTimerApplied = false;
6041    macLcConfig->ul_SpecificParameters->bitRateQueryProhibitTimer = NULLP;
6042
6043    return ROK;
6044 }
6045 /*******************************************************************
6046  *
6047  * @brief Builds RLC Bearer to Add/Mod list
6048  *
6049  * @details
6050  *
6051  *    Function :BuildRlcBearerToAddModList
6052  *
6053  *    Functionality: Builds RLC Bearer to Add/Mod list in DuToCuRrcContainer
6054  *
6055  * @params[in] rlc_BearerToAddModList
6056  *
6057  * @return ROK     - success
6058  *         RFAILED - failure
6059  *
6060  * ****************************************************************/
6061 uint8_t BuildRlcBearerToAddModList(CuUeCb *ueCb, struct CellGroupConfigRrc__rlc_BearerToAddModList *rlcBearerList, bool updateAllRbCfg)
6062 {
6063    uint8_t idx, srbIdx = 0, drbIdx = 0, elementCnt=0;
6064
6065    if(updateAllRbCfg)
6066       elementCnt = ueCb->numSrb + ueCb->numDrb;
6067    else
6068    {
6069       for(srbIdx = 0; srbIdx< ueCb->numSrb; srbIdx++)
6070       {
6071          if(ueCb->srbList[srbIdx].cfgSentToUe == false)
6072             elementCnt++;
6073       }
6074
6075       for(drbIdx = 0; drbIdx< ueCb->numDrb; drbIdx++)
6076       {
6077          if(ueCb->drbList[drbIdx].cfgSentToUe == false)
6078             elementCnt++;
6079       }
6080    }
6081
6082    if(!elementCnt)
6083    {
6084       DU_LOG("INFO  --> F1AP : No  RLC Bearer available to add or modify");
6085       return ROK;
6086    }
6087    CU_ALLOC(rlcBearerList, sizeof(struct CellGroupConfigRrc__rlc_BearerToAddModList));
6088    if(!rlcBearerList)
6089    {
6090       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in CellGrpConfig");
6091       return RFAILED;
6092    }
6093    rlcBearerList->list.count = elementCnt;
6094    rlcBearerList->list.size  = elementCnt * sizeof(struct RLC_BearerConfig *);
6095
6096    rlcBearerList->list.array = NULLP;
6097    CU_ALLOC(rlcBearerList->list.array, rlcBearerList->list.size);
6098    if(!rlcBearerList->list.array)
6099    {
6100       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
6101       return RFAILED;
6102    }
6103
6104    for(idx=0; idx<rlcBearerList->list.count; idx++)
6105    {
6106       rlcBearerList->list.array[idx] = NULLP;
6107       CU_ALLOC(rlcBearerList->list.array[idx], sizeof(struct RLC_BearerConfig));
6108       if(!rlcBearerList->list.array[idx])
6109       {
6110          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
6111          return RFAILED;
6112       }
6113    }
6114
6115    idx = 0;
6116
6117    for(srbIdx=0; srbIdx < ueCb->numSrb; srbIdx++)
6118    {
6119       if(!updateAllRbCfg && ueCb->srbList[srbIdx].cfgSentToUe)
6120          continue;
6121
6122       rlcBearerList->list.array[idx]->logicalChannelIdentity = ueCb->srbList[srbIdx].lcId;
6123
6124       CU_ALLOC(rlcBearerList->list.array[idx]->servedRadioBearer, sizeof(struct RLC_BearerConfig__servedRadioBearer));
6125       if(!rlcBearerList->list.array[idx]->servedRadioBearer)
6126       {
6127          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
6128          return RFAILED;
6129       }
6130
6131       rlcBearerList->list.array[idx]->servedRadioBearer->present = RLC_BearerConfig__servedRadioBearer_PR_srb_Identity;
6132       rlcBearerList->list.array[idx]->servedRadioBearer->choice.srb_Identity = ueCb->srbList[srbIdx].srbId;
6133
6134       rlcBearerList->list.array[idx]->reestablishRLC = NULLP;
6135       rlcBearerList->list.array[idx]->rlc_Config = NULLP;
6136       CU_ALLOC(rlcBearerList->list.array[idx]->rlc_Config, sizeof(struct RLC_Config));
6137       if(!rlcBearerList->list.array[idx]->rlc_Config)
6138       {
6139          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
6140          return RFAILED;
6141       }
6142
6143       if(BuildRlcConfig(ueCb->srbList[srbIdx].rlcLcCfg, rlcBearerList->list.array[idx]->rlc_Config) != ROK)
6144       {
6145          DU_LOG("\nERROR  -->  F1AP : BuildRlcConfig failed");
6146          return RFAILED;
6147       }
6148
6149       rlcBearerList->list.array[idx]->mac_LogicalChannelConfig = NULLP;
6150       CU_ALLOC(rlcBearerList->list.array[idx]->mac_LogicalChannelConfig, sizeof(struct LogicalChannelConfig));
6151       if(!rlcBearerList->list.array[idx]->mac_LogicalChannelConfig)
6152       {
6153          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
6154          return RFAILED;
6155       }
6156
6157       if(BuildMacLCConfig(ueCb->srbList[srbIdx].macLcCfg, rlcBearerList->list.array[idx]->mac_LogicalChannelConfig) != ROK)
6158       {
6159          DU_LOG("\nERROR  -->  F1AP : BuildMacLCConfig failed");
6160          return RFAILED;
6161       }
6162       idx++;
6163    }
6164
6165    for(drbIdx=0; drbIdx < ueCb->numDrb; drbIdx++)
6166    {
6167       if(!updateAllRbCfg && ueCb->drbList[drbIdx].cfgSentToUe)
6168          continue;
6169
6170       rlcBearerList->list.array[idx]->logicalChannelIdentity = ueCb->drbList[drbIdx].lcId;
6171
6172       CU_ALLOC(rlcBearerList->list.array[idx]->servedRadioBearer, sizeof(struct RLC_BearerConfig__servedRadioBearer));
6173       if(!rlcBearerList->list.array[idx]->servedRadioBearer)
6174       {
6175          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
6176          return RFAILED;
6177       }
6178
6179       rlcBearerList->list.array[idx]->servedRadioBearer->present = RLC_BearerConfig__servedRadioBearer_PR_drb_Identity;
6180       rlcBearerList->list.array[idx]->servedRadioBearer->choice.drb_Identity = ueCb->drbList[drbIdx].drbId;
6181
6182       rlcBearerList->list.array[idx]->reestablishRLC = NULLP;
6183       rlcBearerList->list.array[idx]->rlc_Config = NULLP;
6184       CU_ALLOC(rlcBearerList->list.array[idx]->rlc_Config, sizeof(struct RLC_Config));
6185       if(!rlcBearerList->list.array[idx]->rlc_Config)
6186       {
6187          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
6188          return RFAILED;
6189       }
6190
6191       if(BuildRlcConfig(ueCb->drbList[drbIdx].rlcLcCfg, rlcBearerList->list.array[idx]->rlc_Config) != ROK)
6192       {
6193          DU_LOG("\nERROR  -->  F1AP : BuildRlcConfig failed");
6194          return RFAILED;
6195       }
6196
6197       rlcBearerList->list.array[idx]->mac_LogicalChannelConfig = NULLP;
6198       CU_ALLOC(rlcBearerList->list.array[idx]->mac_LogicalChannelConfig, sizeof(struct LogicalChannelConfig));
6199       if(!rlcBearerList->list.array[idx]->mac_LogicalChannelConfig)
6200       {
6201          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
6202          return RFAILED;
6203       }
6204
6205       if(BuildMacLCConfig(ueCb->drbList[drbIdx].macLcCfg, rlcBearerList->list.array[idx]->mac_LogicalChannelConfig) != ROK)
6206       {
6207          DU_LOG("\nERROR  -->  F1AP : BuildMacLCConfig failed");
6208          return RFAILED;
6209       }
6210       idx++;
6211    }
6212    return ROK;
6213 }
6214
6215 /*******************************************************************
6216  *
6217  * @brief Free memory allocated for CellGroupConfig
6218  *
6219  * @details
6220  *
6221  *    Function : FreeMemCellGrpCfg
6222  *
6223  *    Functionality: Deallocating memory of CellGroupConfig
6224  *
6225  * @params[in] pointer to CellGroupConfigRrc_t
6226  *
6227  * @return ROK     - success
6228  *         RFAILED - failure
6229  *
6230  ******************************************************************/
6231 uint8_t FreeMemCellGrpCfg(CellGroupConfigRrc_t *cellGrpCfg)
6232 {
6233    uint8_t idx=0;
6234    SpCellConfig_t *spCellCfg=NULLP;
6235    ServingCellConfig_t *srvCellCfg=NULLP;
6236    BWP_DownlinkDedicated_t *dlBwp=NULLP;
6237    MAC_CellGroupConfig_t *macCellGrpCfg=NULLP;
6238    PhysicalCellGroupConfig_t *phyCellGrpCfg=NULLP;
6239    struct CellGroupConfigRrc__rlc_BearerToAddModList *rlcBearerList=NULLP;
6240    struct RLC_Config *rlcConfig=NULLP;
6241    struct LogicalChannelConfig *macLcConfig=NULLP;
6242    struct SchedulingRequestConfig *schedulingRequestConfig=NULLP;
6243    struct SchedulingRequestConfig__schedulingRequestToAddModList *schReqList=NULLP;
6244    struct TAG_Config *tagConfig=NULLP;
6245    struct TAG_Config__tag_ToAddModList *tagList=NULLP;
6246    struct MAC_CellGroupConfig__phr_Config *phrConfig=NULLP;
6247    struct ServingCellConfig__pdsch_ServingCellConfig *pdschCfg=NULLP;
6248
6249    rlcBearerList = cellGrpCfg->rlc_BearerToAddModList;
6250    if(rlcBearerList)
6251    {
6252       if(rlcBearerList->list.array)
6253       {
6254          for(idx=0; idx<rlcBearerList->list.count; idx++)
6255          {
6256             if(rlcBearerList->list.array[idx])
6257             {
6258                rlcConfig   = rlcBearerList->list.array[idx]->rlc_Config;
6259                macLcConfig = rlcBearerList->list.array[idx]->mac_LogicalChannelConfig;
6260                if(rlcConfig)
6261                {
6262                   if(rlcConfig->choice.am)
6263                   {
6264                      CU_FREE(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
6265                      CU_FREE(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
6266                      CU_FREE(rlcConfig->choice.am, sizeof(struct RLC_Config__am));
6267                   }
6268                   CU_FREE(rlcConfig, sizeof(struct RLC_Config));
6269                }
6270                CU_FREE(rlcBearerList->list.array[idx]->servedRadioBearer, sizeof(struct RLC_BearerConfig__servedRadioBearer));
6271                if(macLcConfig)
6272                {
6273                   if(macLcConfig->ul_SpecificParameters)
6274                   {
6275                      CU_FREE(macLcConfig->ul_SpecificParameters->schedulingRequestID,   sizeof(SchedulingRequestId_t));
6276                      CU_FREE(macLcConfig->ul_SpecificParameters->logicalChannelGroup,   sizeof(long));
6277                      CU_FREE(macLcConfig->ul_SpecificParameters, sizeof(struct LogicalChannelConfig__ul_SpecificParameters));
6278                   }
6279                   CU_FREE(rlcBearerList->list.array[idx]->mac_LogicalChannelConfig, sizeof(struct LogicalChannelConfig));
6280                }
6281                CU_FREE(rlcBearerList->list.array[idx], sizeof(struct RLC_BearerConfig));
6282             }
6283          }
6284          CU_FREE(rlcBearerList->list.array, rlcBearerList->list.size);
6285       }
6286       CU_FREE(cellGrpCfg->rlc_BearerToAddModList, sizeof(struct CellGroupConfigRrc__rlc_BearerToAddModList));
6287    }
6288
6289    macCellGrpCfg = cellGrpCfg->mac_CellGroupConfig;
6290    if(macCellGrpCfg)
6291    {
6292       schedulingRequestConfig = macCellGrpCfg->schedulingRequestConfig;
6293       if(schedulingRequestConfig)
6294       {
6295          schReqList = schedulingRequestConfig->schedulingRequestToAddModList;
6296          if(schReqList)
6297          {
6298             if(schReqList->list.array)
6299             {
6300                for(idx=0;idx<schReqList->list.count; idx++)
6301                {
6302                   if(schReqList->list.array[idx])
6303                   {
6304                      CU_FREE(schReqList->list.array[idx]->sr_ProhibitTimer, sizeof(long));
6305                      CU_FREE(schReqList->list.array[idx], sizeof(struct SchedulingRequestToAddMod));
6306                   }
6307                }
6308                CU_FREE(schReqList->list.array, schReqList->list.size);
6309             }
6310             CU_FREE(schedulingRequestConfig->schedulingRequestToAddModList,\
6311                   sizeof(struct SchedulingRequestConfig__schedulingRequestToAddModList));    }
6312             CU_FREE(macCellGrpCfg->schedulingRequestConfig, sizeof(struct SchedulingRequestConfig));
6313       }
6314       if(macCellGrpCfg->bsr_Config)
6315       {
6316          CU_FREE(macCellGrpCfg->bsr_Config, sizeof(struct BSR_Config));
6317       }
6318       tagConfig = macCellGrpCfg->tag_Config;
6319       if(tagConfig)
6320       {
6321          tagList = tagConfig->tag_ToAddModList;
6322          if(tagList)
6323          {
6324             if(tagList->list.array)
6325             {
6326                for(idx=0; idx<tagList->list.count; idx++)
6327                {
6328                   CU_FREE(tagList->list.array[idx], sizeof(struct TAG));
6329                }
6330                CU_FREE(tagList->list.array, tagList->list.size);
6331             }
6332             CU_FREE(tagConfig->tag_ToAddModList, sizeof(struct TAG_Config__tag_ToAddModList));
6333          }
6334          CU_FREE(tagConfig, sizeof(struct TAG_Config));
6335       }
6336
6337       phrConfig = macCellGrpCfg->phr_Config;
6338       if(phrConfig)
6339       {
6340          CU_FREE(phrConfig->choice.setup, sizeof(struct PHR_Config));
6341          CU_FREE(phrConfig, sizeof(struct MAC_CellGroupConfig__phr_Config));
6342       }
6343
6344       CU_FREE(macCellGrpCfg, sizeof(MAC_CellGroupConfig_t));
6345    }
6346
6347    phyCellGrpCfg = cellGrpCfg->physicalCellGroupConfig;
6348    if(phyCellGrpCfg)
6349    {
6350       CU_FREE(phyCellGrpCfg->p_NR_FR1, sizeof(long));
6351       CU_FREE(phyCellGrpCfg, sizeof(PhysicalCellGroupConfig_t));
6352    }
6353
6354    spCellCfg = cellGrpCfg->spCellConfig;
6355    if(spCellCfg)
6356    {
6357       if(spCellCfg->servCellIndex)
6358       {
6359          if(spCellCfg->rlmInSyncOutOfSyncThreshold)
6360          {
6361             if(spCellCfg->spCellConfigDedicated)
6362             {
6363                srvCellCfg = spCellCfg->spCellConfigDedicated;
6364                if(srvCellCfg->initialDownlinkBWP)
6365                {
6366                   dlBwp = srvCellCfg->initialDownlinkBWP;
6367                   if(srvCellCfg->firstActiveDownlinkBWP_Id)
6368                   {
6369                      if(srvCellCfg->defaultDownlinkBWP_Id)
6370                      {
6371                         if(srvCellCfg->uplinkConfig)
6372                         {
6373                            if(srvCellCfg->pdsch_ServingCellConfig)
6374                            {
6375                               pdschCfg= srvCellCfg->pdsch_ServingCellConfig;
6376                               if(pdschCfg->choice.setup)
6377                               {
6378                                  CU_FREE(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH,sizeof(long));
6379                                  CU_FREE(pdschCfg->choice.setup, sizeof( struct PDSCH_ServingCellConfig));
6380                               }
6381                               CU_FREE(srvCellCfg->pdsch_ServingCellConfig, sizeof(struct
6382                                        ServingCellConfig__pdsch_ServingCellConfig));
6383                            }
6384                            FreeinitialUplinkBWP(srvCellCfg->uplinkConfig);
6385                            CU_FREE(srvCellCfg->uplinkConfig, sizeof(UplinkConfig_t));
6386                         }
6387                         CU_FREE(srvCellCfg->defaultDownlinkBWP_Id, sizeof(long));
6388                      }
6389                      CU_FREE(srvCellCfg->firstActiveDownlinkBWP_Id, sizeof(long));
6390                   }
6391                   if(dlBwp->pdcch_Config)
6392                   {
6393                      if(dlBwp->pdsch_Config)
6394                      {
6395                         FreeBWPDlDedPdschCfg(dlBwp);
6396                         CU_FREE(dlBwp->pdsch_Config, sizeof(struct BWP_DownlinkDedicated__pdsch_Config));
6397                      }
6398                      FreeBWPDlDedPdcchCfg(dlBwp);
6399                      CU_FREE(dlBwp->pdcch_Config, sizeof(struct BWP_DownlinkDedicated__pdcch_Config));
6400                   }
6401                   CU_FREE(srvCellCfg->initialDownlinkBWP, sizeof(BWP_DownlinkDedicated_t));
6402                }
6403                CU_FREE(spCellCfg->spCellConfigDedicated, sizeof(ServingCellConfig_t));
6404             }
6405             CU_FREE(spCellCfg->rlmInSyncOutOfSyncThreshold, sizeof(long));
6406          }
6407          CU_FREE(spCellCfg->servCellIndex, sizeof(long));
6408       }
6409       CU_FREE(spCellCfg,sizeof(SpCellConfig_t));
6410    }
6411    return ROK;
6412 }
6413
6414 /*******************************************************************
6415  *
6416  * @brief Fills CellGroupConfig
6417  *
6418  * @details
6419  *
6420  *    Function : fillCellGrpCfg
6421  *
6422  *    Functionality: Fills CellGroupConfig
6423  *
6424  * @params[in] pointer to CellGroupConfigRrc_t
6425  *
6426  * @return ROK     - success
6427  *         RFAILED - failure
6428  *
6429  ******************************************************************/
6430
6431 uint8_t fillCellGrpCfg(CuUeCb *ueCb, OCTET_STRING_t *cellGrp, bool updateAllRbCfg)
6432 {
6433    uint8_t               ret = RFAILED;
6434    CellGroupConfigRrc_t  cellGrpCfg;
6435    asn_enc_rval_t        encRetVal;
6436
6437    while(true)
6438    {
6439       cellGrpCfg.cellGroupId = CELL_GRP_ID;
6440
6441       cellGrpCfg.rlc_BearerToAddModList = NULLP;
6442
6443       if(BuildRlcBearerToAddModList(ueCb, cellGrpCfg.rlc_BearerToAddModList, updateAllRbCfg) != ROK)
6444       {
6445          DU_LOG("\nERROR  -->  F1AP : fillCellGrpCfg failed");
6446          break;
6447       }
6448
6449       cellGrpCfg.rlc_BearerToReleaseList = NULLP;
6450       cellGrpCfg.mac_CellGroupConfig = NULLP;
6451       CU_ALLOC(cellGrpCfg.mac_CellGroupConfig, sizeof(MAC_CellGroupConfig_t));
6452       if(!cellGrpCfg.mac_CellGroupConfig)
6453       {
6454          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in fillCellGrpCfg");
6455          break;
6456       }
6457       if(BuildMacCellGrpCfg(cellGrpCfg.mac_CellGroupConfig) != ROK)
6458       {
6459          DU_LOG("\nERROR  -->  F1AP : BuildMacCellGrpCfg failed");
6460          break;
6461       }
6462
6463       cellGrpCfg.physicalCellGroupConfig = NULLP;
6464       CU_ALLOC(cellGrpCfg.physicalCellGroupConfig, sizeof(PhysicalCellGroupConfig_t));
6465       if(!cellGrpCfg.physicalCellGroupConfig)
6466       {
6467          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildDuToCuRrcContainer");
6468          break;
6469       }
6470       if(BuildPhyCellGrpCfg(cellGrpCfg.physicalCellGroupConfig) != ROK)
6471       {
6472          DU_LOG("\nERROR  -->  F1AP : BuildPhyCellGrpCfg failed");
6473          break;
6474       }
6475
6476       cellGrpCfg.spCellConfig = NULLP;
6477       CU_ALLOC(cellGrpCfg.spCellConfig, sizeof(SpCellConfig_t));
6478       if(!cellGrpCfg.spCellConfig)
6479       {
6480          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildDuToCuRrcContainer");
6481          break;
6482       }
6483       if(BuildSpCellCfg(cellGrpCfg.spCellConfig) != ROK)
6484       {
6485          DU_LOG("\nERROR  -->  F1AP : BuildSpCellCfg failed");
6486          break;
6487       }
6488
6489       cellGrpCfg.sCellToAddModList = NULLP;
6490       cellGrpCfg.sCellToReleaseList = NULLP;
6491       cellGrpCfg.ext1 = NULLP;
6492
6493       /* encode cellGrpCfg into duToCuRrcContainer */
6494       xer_fprint(stdout, &asn_DEF_CellGroupConfigRrc, &cellGrpCfg);
6495       cmMemset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
6496       encBufSize = 0;
6497       encRetVal = aper_encode(&asn_DEF_CellGroupConfigRrc, 0, &cellGrpCfg, PrepFinalEncBuf, encBuf);
6498       /* Encode results */
6499       if(encRetVal.encoded == ENCODE_FAIL)
6500       {
6501          DU_LOG( "\nERROR  -->  F1AP : Could not encode DuToCuRrcContainer (at %s)\n",\
6502                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
6503          break;
6504       }
6505       else
6506       {
6507          DU_LOG("\nDEBUG  -->  F1AP : Created APER encodedbuffer for DuToCuRrcContainer\n");
6508          for(int i=0; i< encBufSize; i++)
6509          {
6510             DU_LOG("%x",encBuf[i]);
6511          }
6512       }
6513
6514       cellGrp->size = encBufSize;
6515       CU_ALLOC(cellGrp->buf, cellGrp->size);
6516       if(!cellGrp->buf)
6517       {
6518          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDuToCuRrcContainer");
6519          break;
6520       }
6521       memcpy(cellGrp->buf, encBuf, cellGrp->size);
6522       ret = ROK;
6523       break;
6524    }
6525    FreeMemCellGrpCfg(&cellGrpCfg);
6526    return ret;
6527 }
6528
6529 /*******************************************************************
6530  *
6531  * @brief Free UE Capability RAT container
6532  *
6533  * @details
6534  *
6535  *    Function : freeUeCapRatCont
6536  *
6537  *    Functionality:
6538  *       Free UE Capability RAT conatiner
6539  *
6540  * @params[in]
6541  * @return ROK     - success
6542  *         RFAILED - failure
6543  *
6544  * ****************************************************************/
6545 void freeUeCapRatCont(UE_NR_Capability_t *ueNrCap)
6546 {
6547    uint8_t idx;
6548    FeatureSets_t *featureSets;
6549
6550    if(ueNrCap->rf_Parameters.supportedBandListNR.list.array)
6551    {
6552       for(idx = 0; idx < ueNrCap->rf_Parameters.supportedBandListNR.list.count; idx++)
6553       {
6554          if(ueNrCap->rf_Parameters.supportedBandListNR.list.array[idx])
6555             CU_FREE(ueNrCap->rf_Parameters.supportedBandListNR.list.array[idx], sizeof(struct BandNR));
6556       }
6557       CU_FREE(ueNrCap->rf_Parameters.supportedBandListNR.list.array, ueNrCap->rf_Parameters.supportedBandListNR.list.size);
6558    }
6559
6560    if(ueNrCap->featureSets)
6561    {
6562       featureSets = ueNrCap->featureSets;
6563       if(featureSets->featureSetsDownlinkPerCC)
6564       {
6565          if(featureSets->featureSetsDownlinkPerCC->list.array)
6566          {
6567             for(idx = 0; idx < featureSets->featureSetsDownlinkPerCC->list.count; idx++)
6568             {
6569                   if(featureSets->featureSetsDownlinkPerCC->list.array[idx]->supportedModulationOrderDL)
6570                      CU_FREE(featureSets->featureSetsDownlinkPerCC->list.array[idx]->supportedModulationOrderDL, \
6571                         sizeof(ModulationOrder_t));
6572                   CU_FREE(featureSets->featureSetsDownlinkPerCC->list.array[idx], sizeof(struct FeatureSetDownlinkPerCC));
6573             }
6574             CU_FREE(featureSets->featureSetsDownlinkPerCC->list.array, featureSets->featureSetsDownlinkPerCC->list.size);
6575          }
6576          CU_FREE(featureSets->featureSetsDownlinkPerCC, sizeof(struct FeatureSets__featureSetsDownlinkPerCC));
6577       }
6578
6579       if(featureSets->featureSetsUplinkPerCC)
6580       {
6581          if(featureSets->featureSetsUplinkPerCC->list.array)
6582          {
6583             for(idx = 0; idx < featureSets->featureSetsUplinkPerCC->list.count; idx++)
6584             {
6585                if(featureSets->featureSetsUplinkPerCC->list.array[idx])
6586                {
6587                   if(featureSets->featureSetsUplinkPerCC->list.array[idx]->supportedModulationOrderUL)
6588                      CU_FREE(featureSets->featureSetsUplinkPerCC->list.array[idx]->supportedModulationOrderUL,\
6589                          sizeof(ModulationOrder_t));
6590                   CU_FREE(featureSets->featureSetsUplinkPerCC->list.array[idx], sizeof(struct FeatureSetUplinkPerCC));
6591                }
6592             }
6593             CU_FREE(featureSets->featureSetsUplinkPerCC->list.array,  featureSets->featureSetsUplinkPerCC->list.size);
6594          }
6595          CU_FREE(featureSets->featureSetsUplinkPerCC, sizeof(struct FeatureSets__featureSetsUplinkPerCC));
6596       }
6597       CU_FREE(ueNrCap->featureSets, sizeof(struct FeatureSets));
6598    }
6599 }
6600
6601 /*******************************************************************
6602  *
6603  * @brief Free UE capability RAT container list
6604  *
6605  * @details
6606  *
6607  *    Function : freeUeCapRatContList
6608  *
6609  *    Functionality: Free UE capability RAT container list
6610  *
6611  * @params[in]
6612  * @return ROK     - success
6613  *         RFAILED - failure
6614  *
6615  * ****************************************************************/
6616 void freeUeCapRatContList(UE_CapabilityRAT_ContainerListRRC_t *ueCapablityList)
6617 {
6618    uint8_t idx;
6619    if(ueCapablityList->list.array)
6620    {
6621       for(idx = 0; idx < ueCapablityList->list.count; idx++)
6622       {
6623          if(ueCapablityList->list.array[idx])
6624             CU_FREE(ueCapablityList->list.array[idx], sizeof(UE_CapabilityRAT_Container_t));
6625       }
6626       CU_FREE(ueCapablityList->list.array, ueCapablityList->list.size);
6627    }
6628 }
6629
6630 /*******************************************************************
6631  *
6632  * @brief Free Handover preparation information
6633  *
6634  * @details
6635  *
6636  *    Function : freeHOPreparationInfo
6637  *
6638  *    Functionality: Free Handover preparation information
6639  *
6640  * @params[in]
6641  * @return ROK     - success
6642  *         RFAILED - failure
6643  *
6644  * ****************************************************************/
6645 void freeHOPreparationInfo(HandoverPreparationInformationRrc_t *hoPrep)
6646 {
6647    HandoverPreparationInformationRrc_IEs_t *hoPrepInfoIe;
6648
6649    if(hoPrep->criticalExtensions.choice.c1)
6650    {
6651       if(hoPrep->criticalExtensions.choice.c1->choice.handoverPreparationInformation)
6652       {
6653          hoPrepInfoIe = hoPrep->criticalExtensions.choice.c1->choice.handoverPreparationInformation;
6654          freeUeCapRatContList(&hoPrepInfoIe->ue_CapabilityRAT_List);
6655          CU_FREE(hoPrep->criticalExtensions.choice.c1->choice.handoverPreparationInformation , \
6656                sizeof(HandoverPreparationInformationRrc_IEs_t));
6657       }
6658       CU_FREE(hoPrep->criticalExtensions.choice.c1, sizeof(struct HandoverPreparationInformationRrc__criticalExtensions__c1));
6659    }
6660 }
6661
6662 /*******************************************************************
6663  *
6664  * @brief Fill feature sets
6665  *
6666  * @details
6667  *
6668  *    Function : fillFeatureSets
6669  *
6670  *    Functionality: Fill feature sets
6671  *
6672  * @params[in]
6673  * @return ROK     - success
6674  *         RFAILED - failure
6675  *
6676  * ****************************************************************/
6677 uint8_t fillFeatureSets(FeatureSets_t *featureSets)
6678 {
6679    uint8_t idx, elementCnt;
6680
6681    featureSets->featureSetsDownlink = NULLP;
6682    CU_ALLOC(featureSets->featureSetsDownlinkPerCC, sizeof(struct FeatureSets__featureSetsDownlinkPerCC));
6683    if(!featureSets->featureSetsDownlinkPerCC)
6684    {
6685       DU_LOG("\nERROR  --> F1AP : Memory allocation failed in fillFeatureSets");
6686       return RFAILED;
6687    }
6688
6689    elementCnt = 1;
6690    featureSets->featureSetsDownlinkPerCC->list.count = elementCnt;
6691    featureSets->featureSetsDownlinkPerCC->list.size = elementCnt * sizeof(struct FeatureSetDownlinkPerCC *);
6692    CU_ALLOC(featureSets->featureSetsDownlinkPerCC->list.array, featureSets->featureSetsDownlinkPerCC->list.size);
6693    if(!featureSets->featureSetsDownlinkPerCC->list.array)
6694    {
6695       DU_LOG("\nERROR  --> F1AP : Memory allocation failed in fillFeatureSets");
6696       return RFAILED;
6697    }
6698
6699    for(idx = 0; idx < elementCnt; idx++)
6700    {
6701       CU_ALLOC(featureSets->featureSetsDownlinkPerCC->list.array[idx], sizeof(struct FeatureSetDownlinkPerCC));
6702       if(!featureSets->featureSetsDownlinkPerCC->list.array[idx])
6703       {
6704          DU_LOG("\nERROR  --> F1AP : Memory allocation failed in fillFeatureSets");
6705          return RFAILED;
6706       }
6707    }
6708
6709    idx = 0;
6710    featureSets->featureSetsDownlinkPerCC->list.array[idx]->supportedSubcarrierSpacingDL = SubcarrierSpacing_kHz15;
6711    featureSets->featureSetsDownlinkPerCC->list.array[idx]->supportedBandwidthDL.present = SupportedBandwidth_PR_fr1;
6712    featureSets->featureSetsDownlinkPerCC->list.array[idx]->supportedBandwidthDL.choice.fr1 = SupportedBandwidth__fr1_mhz20;
6713    featureSets->featureSetsDownlinkPerCC->list.array[idx]->channelBW_90mhz = NULLP;
6714    featureSets->featureSetsDownlinkPerCC->list.array[idx]->maxNumberMIMO_LayersPDSCH = NULLP;
6715
6716    CU_ALLOC(featureSets->featureSetsDownlinkPerCC->list.array[idx]->supportedModulationOrderDL, sizeof(ModulationOrder_t));
6717    if(!featureSets->featureSetsDownlinkPerCC->list.array[idx]->supportedModulationOrderDL)
6718    {
6719       DU_LOG("\nERROR  --> F1AP : Memory allocation failed in fillFeatureSets");
6720       return RFAILED;
6721    }
6722    *(featureSets->featureSetsDownlinkPerCC->list.array[idx]->supportedModulationOrderDL) = ModulationOrder_qam64;
6723
6724    featureSets->featureSetsUplink = NULLP;
6725    CU_ALLOC(featureSets->featureSetsUplinkPerCC, sizeof(struct FeatureSets__featureSetsUplinkPerCC));
6726    if(!featureSets->featureSetsUplinkPerCC)
6727    {
6728       DU_LOG("\nERROR  --> F1AP : Memory allocation failed in fillFeatureSets");
6729       return RFAILED;
6730    }
6731
6732    elementCnt = 1;
6733    featureSets->featureSetsUplinkPerCC->list.count = elementCnt;
6734    featureSets->featureSetsUplinkPerCC->list.size = elementCnt * sizeof(struct FeatureSetUplinkPerCC *);
6735    CU_ALLOC(featureSets->featureSetsUplinkPerCC->list.array, featureSets->featureSetsUplinkPerCC->list.size);
6736    if(!featureSets->featureSetsUplinkPerCC->list.array)
6737    {
6738       DU_LOG("\nERROR  --> F1AP : Memory allocation failed in fillFeatureSets");
6739       return RFAILED;
6740    }
6741
6742    for(idx = 0; idx < elementCnt; idx++)
6743    {
6744       CU_ALLOC(featureSets->featureSetsUplinkPerCC->list.array[idx], sizeof(struct FeatureSetUplinkPerCC));
6745       if(!featureSets->featureSetsUplinkPerCC->list.array[idx])
6746       {
6747          DU_LOG("\nERROR  --> F1AP : Memory allocation failed in fillFeatureSets");
6748          return RFAILED;
6749       }
6750    }
6751
6752    idx = 0;
6753    featureSets->featureSetsUplinkPerCC->list.array[idx]->supportedSubcarrierSpacingUL = SubcarrierSpacing_kHz15;
6754    featureSets->featureSetsUplinkPerCC->list.array[idx]->supportedBandwidthUL.present = SupportedBandwidth_PR_fr1;
6755    featureSets->featureSetsUplinkPerCC->list.array[idx]->supportedBandwidthUL.choice.fr1 = SupportedBandwidth__fr1_mhz20;
6756    featureSets->featureSetsUplinkPerCC->list.array[idx]->channelBW_90mhz = NULLP;
6757    featureSets->featureSetsUplinkPerCC->list.array[idx]->mimo_CB_PUSCH = NULLP;
6758    featureSets->featureSetsUplinkPerCC->list.array[idx]->maxNumberMIMO_LayersNonCB_PUSCH = NULLP;
6759
6760    CU_ALLOC(featureSets->featureSetsUplinkPerCC->list.array[idx]->supportedModulationOrderUL, sizeof(ModulationOrder_t));
6761    if(!featureSets->featureSetsUplinkPerCC->list.array[idx]->supportedModulationOrderUL)
6762    {
6763       DU_LOG("\nERROR  --> F1AP : Memory allocation failed in fillFeatureSets");
6764       return RFAILED;
6765    }
6766    *(featureSets->featureSetsUplinkPerCC->list.array[idx]->supportedModulationOrderUL) = ModulationOrder_qam16;
6767
6768    return ROK;
6769 }
6770
6771 /*******************************************************************
6772  *
6773  * @brief Fill UE capability RAT container
6774  *
6775  * @details
6776  *
6777  *    Function : fillUeCapRatCont
6778  *
6779  *    Functionality: Fill UE capability RAT container
6780  *
6781  * @params[in] UE Capability RAT container buffer
6782  * @return ROK     - success
6783  *         RFAILED - failure
6784  *
6785  * ****************************************************************/
6786 uint8_t fillUeCapRatCont(OCTET_STRING_t *ueCapRatContBuf)
6787 {
6788    uint8_t             ret = ROK;
6789    uint8_t             idx, elementCnt;
6790    asn_enc_rval_t      encRetVal;
6791    UE_NR_Capability_t  ueNrCap;
6792
6793    while(true)
6794    {
6795       ueNrCap.accessStratumRelease = AccessStratumRelease_rel15;
6796
6797       /* Filling PDCP parameters */
6798       ueNrCap.pdcp_Parameters.supportedROHC_Profiles.profile0x0000 = false;
6799       ueNrCap.pdcp_Parameters.supportedROHC_Profiles.profile0x0001 = false;
6800       ueNrCap.pdcp_Parameters.supportedROHC_Profiles.profile0x0002 = false;
6801       ueNrCap.pdcp_Parameters.supportedROHC_Profiles.profile0x0003 = false;
6802       ueNrCap.pdcp_Parameters.supportedROHC_Profiles.profile0x0004 = false;
6803       ueNrCap.pdcp_Parameters.supportedROHC_Profiles.profile0x0006 = false;
6804       ueNrCap.pdcp_Parameters.supportedROHC_Profiles.profile0x0101 = false;
6805       ueNrCap.pdcp_Parameters.supportedROHC_Profiles.profile0x0102 = false;
6806       ueNrCap.pdcp_Parameters.supportedROHC_Profiles.profile0x0103 = false;
6807       ueNrCap.pdcp_Parameters.supportedROHC_Profiles.profile0x0104 = false;
6808       ueNrCap.pdcp_Parameters.maxNumberROHC_ContextSessions = PDCP_Parameters__maxNumberROHC_ContextSessions_cs2;
6809       ueNrCap.pdcp_Parameters.uplinkOnlyROHC_Profiles = NULLP;
6810       ueNrCap.pdcp_Parameters.continueROHC_Context = NULLP;
6811       ueNrCap.pdcp_Parameters.outOfOrderDelivery = NULLP;
6812       ueNrCap.pdcp_Parameters.shortSN = NULLP;
6813       ueNrCap.pdcp_Parameters.pdcp_DuplicationSRB = NULLP;
6814       ueNrCap.pdcp_Parameters.pdcp_DuplicationMCG_OrSCG_DRB = NULLP;
6815
6816       ueNrCap.rlc_Parameters = NULLP;
6817       ueNrCap.mac_Parameters = NULLP;
6818
6819       /* Filling PHY parameters */
6820       ueNrCap.phy_Parameters.phy_ParametersCommon = NULLP;
6821       ueNrCap.phy_Parameters.phy_ParametersXDD_Diff = NULLP;
6822       ueNrCap.phy_Parameters.phy_ParametersFRX_Diff = NULLP;
6823       ueNrCap.phy_Parameters.phy_ParametersFR1 = NULLP;
6824       ueNrCap.phy_Parameters.phy_ParametersFR2 = NULLP;
6825
6826       /* Filling RF parameters */
6827       elementCnt = 1;
6828       ueNrCap.rf_Parameters.supportedBandListNR.list.count = elementCnt;
6829       ueNrCap.rf_Parameters.supportedBandListNR.list.size = elementCnt * sizeof(struct BandNR *);
6830       CU_ALLOC(ueNrCap.rf_Parameters.supportedBandListNR.list.array, ueNrCap.rf_Parameters.supportedBandListNR.list.size);
6831       if(!ueNrCap.rf_Parameters.supportedBandListNR.list.array)
6832       {
6833          DU_LOG("\nERROR  --> F1AP : Memory allocation failed in fillUeCapRatCont");
6834          ret = RFAILED;
6835          break;
6836       }
6837
6838       for(idx = 0; idx < elementCnt; idx++)
6839       {
6840          CU_ALLOC(ueNrCap.rf_Parameters.supportedBandListNR.list.array[idx], sizeof(struct BandNR));
6841          if(!ueNrCap.rf_Parameters.supportedBandListNR.list.array[idx])
6842          {
6843             ret = RFAILED;
6844             break;
6845          }
6846       }
6847       if(ret == RFAILED)
6848          break;
6849
6850       idx = 0;
6851       ueNrCap.rf_Parameters.supportedBandListNR.list.array[idx]->bandNR = 1;
6852       ueNrCap.rf_Parameters.supportedBandCombinationList = NULLP;
6853       ueNrCap.rf_Parameters.appliedFreqBandListFilter = NULLP;
6854
6855       ueNrCap.measAndMobParameters = NULLP;
6856       ueNrCap.fdd_Add_UE_NR_Capabilities = NULLP;
6857       ueNrCap.tdd_Add_UE_NR_Capabilities = NULLP;
6858       ueNrCap.fr1_Add_UE_NR_Capabilities = NULLP;
6859       ueNrCap.fr2_Add_UE_NR_Capabilities = NULLP;
6860       ueNrCap.featureSets = NULLP;
6861
6862       CU_ALLOC(ueNrCap.featureSets, sizeof(struct FeatureSets));
6863       if(!ueNrCap.featureSets)
6864       {
6865          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in fillUeCapRatCont");
6866          ret = RFAILED;
6867          break;
6868       }
6869
6870       if(fillFeatureSets(ueNrCap.featureSets) != ROK)
6871       {
6872          DU_LOG("\nERROR  -->  fillDLFeatureSets() failed ");
6873          ret = RFAILED;
6874          break;
6875       }
6876
6877       ueNrCap.featureSetCombinations = NULLP;
6878       ueNrCap.lateNonCriticalExtension = NULLP;
6879       ueNrCap.nonCriticalExtension = NULLP;
6880
6881       /* encode UE Capability RAT Container List into duToCuRrcContainer */
6882       xer_fprint(stdout, &asn_DEF_UE_NR_Capability, &ueNrCap);
6883       cmMemset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
6884       encBufSize = 0;
6885       encRetVal = aper_encode(&asn_DEF_UE_NR_Capability, 0, &ueNrCap, PrepFinalEncBuf, encBuf);
6886
6887       /* Encode results */
6888       if(encRetVal.encoded == ENCODE_FAIL)
6889       {
6890          DU_LOG( "\nERROR  -->  F1AP : Could not encode UE Capability RAT Container (at %s)\n",\
6891             encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
6892          break;
6893       }
6894       else
6895       {
6896          DU_LOG("\nDEBUG  -->  F1AP : Created APER encodedbuffer for UE Capability RAT Container\n");
6897          for(int i=0; i< encBufSize; i++)
6898          {
6899             DU_LOG("%x",encBuf[i]);
6900          }
6901       }
6902
6903       ueCapRatContBuf->size = encBufSize;
6904       CU_ALLOC(ueCapRatContBuf->buf, ueCapRatContBuf->size);
6905       if(!ueCapRatContBuf->buf)
6906       {
6907          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in fillUeCapabilityContainer");
6908          break;
6909       }
6910       memcpy(ueCapRatContBuf->buf, encBuf, ueCapRatContBuf->size);
6911       ret = ROK;
6912       break;
6913    }
6914    freeUeCapRatCont(&ueNrCap);
6915    return ROK;
6916 }
6917
6918 /*******************************************************************
6919  *
6920  * @brief Fill UE Capability RAT container list
6921  *
6922  * @details
6923  *
6924  *    Function : fillUeCapRatContList
6925  *
6926  *    Functionality: Fill UE Capability RAT container list
6927
6928  *
6929  * @params[in] UE capability RAT container list
6930  * @return ROK     - success
6931  *         RFAILED - failure
6932  *
6933  * ****************************************************************/
6934 uint8_t fillUeCapRatContList(UE_CapabilityRAT_ContainerListRRC_t  *ueCapablityList)
6935 {
6936     uint8_t          ret = RFAILED;
6937     uint8_t          idx, elementCnt;
6938
6939     while(true)
6940     {
6941        elementCnt = 1;
6942        ueCapablityList->list.count = elementCnt;
6943        ueCapablityList->list.size = elementCnt * sizeof(UE_CapabilityRAT_Container_t *);
6944
6945        CU_ALLOC(ueCapablityList->list.array, ueCapablityList->list.size);
6946        if(!ueCapablityList->list.array)
6947        {
6948           DU_LOG("\nERROR  -->  Memory allocation failed in fillUeCapRatContList");
6949           ret = RFAILED;
6950           break;
6951        }
6952
6953        for(idx=0; idx<elementCnt; idx++)
6954        {
6955           CU_ALLOC(ueCapablityList->list.array[idx], sizeof(UE_CapabilityRAT_Container_t));
6956           if(ueCapablityList->list.array[idx] == NULLP)
6957           {
6958              DU_LOG("\nERROR  -->  Memory allocation failed in fillUeCapRatContList");
6959              ret = RFAILED;
6960              break;
6961           }
6962        }
6963        idx = 0;
6964        ueCapablityList->list.array[idx]->rat_Type = RAT_Type_nr;
6965        if(fillUeCapRatCont(&ueCapablityList->list.array[idx]->ue_CapabilityRAT_Container) != ROK)
6966        {
6967           DU_LOG("\nERROR  -->  F1AP : Failed to fill UE capability RAT Conatiner");
6968           ret = RFAILED;
6969           break;
6970        }
6971
6972        ret = ROK;
6973        break;
6974     }
6975     return ret;
6976 }
6977
6978 /*******************************************************************
6979  *
6980  * @brief Fill UE Capability RAT container list octet string
6981  *
6982  * @details
6983  *
6984  *    Function : fillUeCapRatContListBuf
6985  *
6986  *    Functionality: Fill UE Capability RAT container list octet string
6987
6988  *
6989  * @params[in] UE capability RAT container list buffer
6990  * @return ROK     - success
6991  *         RFAILED - failure
6992  *
6993  * ****************************************************************/
6994 uint8_t fillUeCapRatContListBuf(UE_CapabilityRAT_ContainerList_t *ueCapablityListBuf)
6995 {
6996    uint8_t          ret = RFAILED;
6997    asn_enc_rval_t   encRetVal;
6998    UE_CapabilityRAT_ContainerListRRC_t  ueCapablityList;
6999
7000    while(true)
7001    {
7002       ret = fillUeCapRatContList(&ueCapablityList);
7003       if(ret != ROK)
7004       {
7005          DU_LOG( "\nERROR  -->  F1AP : Failed to fill UE Capability RAT container list");
7006          break;
7007       }
7008
7009       /* encode UE Capability RAT Container List into duToCuRrcContainer */
7010       xer_fprint(stdout, &asn_DEF_UE_CapabilityRAT_ContainerListRRC, &ueCapablityList);
7011       cmMemset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
7012       encBufSize = 0;
7013       encRetVal = aper_encode(&asn_DEF_UE_CapabilityRAT_ContainerListRRC, 0, \
7014             &ueCapablityList, PrepFinalEncBuf, encBuf);
7015
7016       /* Encode results */
7017       if(encRetVal.encoded == ENCODE_FAIL)
7018       {
7019          DU_LOG( "\nERROR  -->  F1AP : Could not encode UE Capability RAT Container (at %s)\n",\
7020                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
7021          break;
7022       }
7023       else
7024       {
7025          DU_LOG("\nDEBUG  -->  F1AP : Created APER encodedbuffer for UE Capability RAT Container\n");
7026          for(int i=0; i< encBufSize; i++)
7027          {
7028             DU_LOG("%x",encBuf[i]);
7029          }
7030       }
7031
7032       ueCapablityListBuf->size = encBufSize;
7033       CU_ALLOC(ueCapablityListBuf->buf, ueCapablityListBuf->size);
7034       if(!ueCapablityListBuf->buf)
7035       {
7036          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in fillUeCapabilityContainer");
7037          break;
7038       }
7039       memcpy(ueCapablityListBuf->buf, encBuf, ueCapablityListBuf->size);
7040       ret = ROK;
7041       break;
7042    }
7043    freeUeCapRatContList(&ueCapablityList);
7044    return ret;
7045 }
7046
7047 /*******************************************************************
7048  *
7049  * @brief Free Measurement Timing Configuration
7050  *
7051  * @details
7052  *
7053  *    Function : freeMeasuementTimingConfig
7054  *
7055  *    Functionality: Free Measurement Timing Configuration
7056  *
7057  * @params[in] MeasurementTimingConfiguration_IEs_t measTimingCfg
7058  * @return void
7059  *
7060  * ****************************************************************/
7061 void freeMeasuementTimingConfig(MeasurementTimingConfigurationRrc_t measTimingConfig)
7062 {
7063    uint8_t measCfgIdx;
7064    MeasurementTimingConfigurationRrc_IEs_t *measTimingCfg = NULLP;
7065    MeasTiming_t *measTiming = NULLP;
7066
7067    if(measTimingConfig.criticalExtensions.choice.c1)
7068    {
7069       if(measTimingConfig.criticalExtensions.choice.c1->choice.measTimingConf)
7070       {
7071          measTimingCfg = measTimingConfig.criticalExtensions.choice.c1->choice.measTimingConf;
7072          if(measTimingCfg->measTiming)
7073          {
7074             if(measTimingCfg->measTiming->list.array)
7075             {
7076                for(measCfgIdx = 0; measCfgIdx < measTimingCfg->measTiming->list.count; measCfgIdx++)
7077                {
7078                   measTiming = measTimingCfg->measTiming->list.array[measCfgIdx];
7079                   CU_FREE(measTiming->frequencyAndTiming, sizeof(struct MeasTiming__frequencyAndTiming));
7080                   CU_FREE(measTimingCfg->measTiming->list.array[measCfgIdx], sizeof(MeasTiming_t));
7081                }
7082                CU_FREE(measTimingCfg->measTiming->list.array, measTimingCfg->measTiming->list.size);
7083             }
7084             CU_FREE(measTimingCfg->measTiming, sizeof(MeasTimingList_t));
7085          }
7086          CU_FREE(measTimingConfig.criticalExtensions.choice.c1->choice.measTimingConf, sizeof(struct MeasurementTimingConfigurationRrc_IEs));
7087       }
7088       CU_FREE(measTimingConfig.criticalExtensions.choice.c1, sizeof(struct MeasurementTimingConfigurationRrc__criticalExtensions__c1));
7089    }
7090 }
7091
7092 /*******************************************************************
7093  *
7094  * @brief Fill Measurement Timing Configuration
7095  *
7096  * @details
7097  *
7098  *    Function : fillMeasTimingCfg
7099  *
7100  *    Functionality: Fill Measurement Timing Configuration
7101  *
7102  * @params[in] MeasurementTimingConfiguration_IEs_t measTimingCfg
7103  * @return ROK     - success
7104  *         RFAILED - failure
7105  *
7106  * ****************************************************************/
7107 uint8_t fillMeasTimingCfg(MeasurementTimingConfigurationRrc_IEs_t *measTimingCfg)
7108 {
7109    uint8_t elementCnt = 0;
7110    uint8_t measCfgIdx = 0;
7111    MeasTiming_t *measTiming;
7112    SSB_MTC_t *smtc;
7113
7114    CU_ALLOC(measTimingCfg->measTiming, sizeof(MeasTimingList_t));
7115    if(!measTimingCfg->measTiming)
7116    {
7117       DU_LOG( "\nERROR  -->  F1AP : Failed to allocated memory  for measTiming in fillMeasTimingCfg");
7118       return RFAILED;
7119    }
7120
7121    elementCnt = 1;
7122    measTimingCfg->measTiming->list.count = elementCnt;
7123    measTimingCfg->measTiming->list.size = measTimingCfg->measTiming->list.count * sizeof(MeasTiming_t *);
7124    CU_ALLOC(measTimingCfg->measTiming->list.array, measTimingCfg->measTiming->list.size);
7125    if(!measTimingCfg->measTiming->list.array)
7126    {
7127       DU_LOG( "\nERROR  -->  F1AP : Failed to allocated memory for measTiming array in fillMeasTimingCfg");
7128       return RFAILED;
7129    }
7130
7131    for(measCfgIdx = 0; measCfgIdx < measTimingCfg->measTiming->list.count; measCfgIdx++)
7132    {
7133       CU_ALLOC(measTimingCfg->measTiming->list.array[measCfgIdx], sizeof(MeasTiming_t));
7134       if(!measTimingCfg->measTiming->list.array[measCfgIdx])
7135       {
7136          DU_LOG( "\nERROR  -->  F1AP : Failed to allocated memory for measTiming array element in fillMeasTimingCfg");
7137          return RFAILED;
7138       }
7139    }
7140
7141    measCfgIdx = 0;
7142    measTiming = measTimingCfg->measTiming->list.array[measCfgIdx];
7143    CU_ALLOC(measTiming->frequencyAndTiming, sizeof(struct MeasTiming__frequencyAndTiming));
7144    if(!measTiming->frequencyAndTiming)
7145    {
7146       DU_LOG( "\nERROR  -->  F1AP : Failed to allocated memory for frequency and timing IE in fillMeasTimingCfg");
7147       return RFAILED;
7148    }
7149
7150    measTiming->frequencyAndTiming->carrierFreq =  623800; /* This is a randomly chosen value since ARFCN configured in DU is 623400 */
7151    measTiming->frequencyAndTiming->ssbSubcarrierSpacing = SubcarrierSpacing_kHz15;
7152
7153    smtc = &measTiming->frequencyAndTiming->ssb_MeasurementTimingConfiguration;
7154    smtc->periodicityAndOffset.present = SSB_MTC__periodicityAndOffset_PR_sf20;
7155    smtc->periodicityAndOffset.choice.sf20 = 0;
7156    smtc->duration = SSB_MTC__duration_sf1;
7157    return ROK;
7158 }
7159
7160 /*******************************************************************
7161  *
7162  * @brief Fill Measurement Timing Configuration Octet string
7163  *
7164  * @details
7165  *
7166  *    Function : fillMeasConfigBuf
7167  *
7168  *    Functionality: Fill Measurement Timing Configuration Octet string
7169
7170  *
7171  * @params[in] MeasConfig_t *measConfgBuf
7172  * @return ROK     - success
7173  *         RFAILED - failure
7174  *
7175  * ****************************************************************/
7176 uint8_t fillMeasTimingConfigBuf(MeasConfig_t *measTimingConfigBuf)
7177 {
7178    uint8_t          ret = RFAILED;
7179    asn_enc_rval_t   encRetVal;
7180    MeasurementTimingConfigurationRrc_t measTimingConfig;
7181
7182    while(true)
7183    {
7184       measTimingConfig.criticalExtensions.present = MeasurementTimingConfigurationRrc__criticalExtensions_PR_c1;
7185       CU_ALLOC(measTimingConfig.criticalExtensions.choice.c1, sizeof(struct MeasurementTimingConfigurationRrc__criticalExtensions__c1));
7186       if(!measTimingConfig.criticalExtensions.choice.c1)
7187       {
7188          DU_LOG( "\nERROR  -->  F1AP : Failed to allocated memory for measurement configuration extension");
7189          return RFAILED;
7190       }
7191       measTimingConfig.criticalExtensions.choice.c1->present = MeasurementTimingConfigurationRrc__criticalExtensions__c1_PR_measTimingConf;
7192
7193       CU_ALLOC(measTimingConfig.criticalExtensions.choice.c1->choice.measTimingConf, sizeof(struct MeasurementTimingConfigurationRrc_IEs));
7194       if(!measTimingConfig.criticalExtensions.choice.c1->choice.measTimingConf)
7195       {
7196          DU_LOG( "\nERROR  -->  F1AP : Failed to allocated memory for measurement timing configuration IE");
7197          return RFAILED;
7198       }
7199
7200       ret = fillMeasTimingCfg(measTimingConfig.criticalExtensions.choice.c1->choice.measTimingConf);
7201       if(ret != ROK)
7202       {
7203          DU_LOG( "\nERROR  -->  F1AP : Failed to fill measurement timing configuration IE");
7204          break;
7205       }
7206
7207       /* Encode measurement timing configuration into octet string */
7208       xer_fprint(stdout, &asn_DEF_MeasurementTimingConfigurationRrc, &measTimingConfig);
7209       cmMemset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
7210       encBufSize = 0;
7211       encRetVal = aper_encode(&asn_DEF_MeasurementTimingConfigurationRrc, 0, &measTimingConfig, PrepFinalEncBuf, encBuf);
7212
7213       /* Encode results */
7214       if(encRetVal.encoded == ENCODE_FAIL)
7215       {
7216          DU_LOG( "\nERROR  -->  F1AP : Could not encode Measurement Timing Configuration (at %s)\n",\
7217                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
7218          break;
7219       }
7220       else
7221       {
7222          DU_LOG("\nDEBUG  -->  F1AP : Created APER encodedbuffer for Measurement timing configuration\n");
7223          for(int i=0; i< encBufSize; i++)
7224          {
7225             DU_LOG("%x",encBuf[i]);
7226          }
7227       }
7228
7229       measTimingConfigBuf->size = encBufSize;
7230       CU_ALLOC(measTimingConfigBuf->buf, measTimingConfigBuf->size);
7231       if(!measTimingConfigBuf->buf)
7232       {
7233          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed fillMeasTimingConfigBuf");
7234          break;
7235       }
7236       memcpy(measTimingConfigBuf->buf, encBuf, measTimingConfigBuf->size);
7237       ret = ROK;
7238       break;
7239    }
7240    freeMeasuementTimingConfig(measTimingConfig);
7241    return ret;
7242 }
7243
7244 /******************************************************************
7245  *
7246  * @brief Free RRC reconfiguration non-critical extension
7247  *
7248  * @details
7249  *
7250  *    Function : freeRrcReconfigNonCriticalExt
7251  *
7252  *    Functionality: Free RRC reconfiguration non-critical extension
7253  *
7254  * @params[in] RRC reconfiguration IE
7255  * @return void
7256  *
7257  * ****************************************************************/
7258 void freeRrcReconfigNonCriticalExt(RRCReconfiguration_v1530_IEs_t *rrcRecfg)
7259 {
7260    if(rrcRecfg->masterCellGroup)
7261    {
7262       CU_FREE(rrcRecfg->masterCellGroup, sizeof(OCTET_STRING_t));
7263    }
7264 }
7265
7266 /******************************************************************
7267  *
7268  * @brief Free measurement object addmod list
7269  *
7270  * @details
7271  *
7272  *    Function : freeMeasObjToAddModList
7273  *
7274  *    Functionality: Free measurement object add mod list
7275  *
7276  * @params[in] Measurement object add/mod list
7277  * @return void
7278  *
7279  * ****************************************************************/
7280 void freeMeasObjToAddModList(MeasObjectToAddModList_t *measObjList)
7281 {
7282    uint8_t objIdx;
7283    MeasObjectNR_t *measObject;
7284
7285    if(measObjList->list.array)
7286    {
7287       for(objIdx = 0; objIdx < measObjList->list.size; objIdx++)
7288       {
7289          if(measObjList->list.array[objIdx])
7290          {
7291             if(measObjList->list.array[objIdx]->measObject.choice.measObjectNR)
7292             {
7293                measObject = measObjList->list.array[objIdx]->measObject.choice.measObjectNR;
7294                CU_FREE(measObject->ssbFrequency, sizeof(ARFCN_ValueNR_t));
7295                CU_FREE(measObject->ssbSubcarrierSpacing, sizeof(SubcarrierSpacing_t));
7296                CU_FREE(measObject->smtc1 , sizeof(SSB_MTC_t));
7297                if(measObject->absThreshSS_BlocksConsolidation)
7298                {
7299                   CU_FREE(measObject->absThreshSS_BlocksConsolidation->thresholdRSRP, sizeof(RSRP_Range_t));
7300                   CU_FREE(measObject->absThreshSS_BlocksConsolidation->thresholdRSRQ, sizeof(RSRQ_Range_t));
7301                   CU_FREE(measObject->absThreshSS_BlocksConsolidation->thresholdSINR, sizeof(SINR_Range_t));
7302                   CU_FREE(measObject->absThreshSS_BlocksConsolidation, sizeof(ThresholdNR_t));
7303                }
7304                CU_FREE(measObject->nrofSS_BlocksToAverage, sizeof(long));
7305                CU_FREE(measObject->offsetMO.rsrpOffsetSSB, sizeof(Q_OffsetRange_t));
7306                CU_FREE(measObject->offsetMO.rsrqOffsetSSB, sizeof(Q_OffsetRange_t));
7307                CU_FREE(measObject->offsetMO.sinrOffsetSSB, sizeof(Q_OffsetRange_t));
7308                CU_FREE(measObjList->list.array[objIdx]->measObject.choice.measObjectNR, sizeof(MeasObjectNR_t));
7309             }
7310             CU_FREE(measObjList->list.array[objIdx], sizeof(MeasObjectToAddMod_t));
7311          }
7312       }
7313       CU_FREE(measObjList->list.array, measObjList->list.size);
7314    }
7315 }
7316
7317 /******************************************************************
7318  *
7319  * @brief Free report config add mod list
7320  *
7321  * @details
7322  *
7323  *    Function : freeReportCfgToAddModList
7324  *
7325  *    Functionality: Free report config add mod list
7326  *
7327  * @params[in] Report config list
7328  * @return void
7329  *
7330  * ****************************************************************/
7331 void freeReportCfgToAddModList(ReportConfigToAddModList_t *reportCfgList)
7332 {
7333    uint8_t reportCfgIdx;
7334    ReportConfigToAddMod_t *reportCfg;
7335    ReportConfigNR_t *reportCfgNr;
7336    EventTriggerConfig_t *eventTriggCfg;
7337
7338    if(reportCfgList->list.array)
7339    {
7340       for(reportCfgIdx=0; reportCfgIdx < reportCfgList->list.count; reportCfgIdx++)
7341       {
7342          if(reportCfgList->list.array[reportCfgIdx])
7343          {
7344             reportCfg = reportCfgList->list.array[reportCfgIdx];
7345             if(reportCfg->reportConfig.choice.reportConfigNR)
7346             {
7347                reportCfgNr = reportCfg->reportConfig.choice.reportConfigNR;
7348                if(reportCfgNr->reportType.choice.eventTriggered)
7349                {
7350                   eventTriggCfg = reportCfgNr->reportType.choice.eventTriggered;
7351                   CU_FREE(eventTriggCfg->eventId.choice.eventA3, sizeof(struct EventTriggerConfig__eventId__eventA3));
7352                   CU_FREE(eventTriggCfg->reportQuantityRS_Indexes, sizeof(MeasReportQuantity_t));
7353                   CU_FREE(eventTriggCfg->maxNrofRS_IndexesToReport, sizeof(long));
7354                   CU_FREE(reportCfgNr->reportType.choice.eventTriggered, sizeof(EventTriggerConfig_t));
7355                }
7356             }
7357          }
7358          CU_FREE(reportCfgList->list.array[reportCfgIdx], sizeof(ReportConfigToAddMod_t));
7359       }
7360       CU_FREE(reportCfgList->list.array, reportCfgList->list.size);
7361    }
7362 }
7363
7364 /******************************************************************
7365  *
7366  * @brief Free measurement id to add mod list
7367  *
7368  * @details
7369  *
7370  *    Function : freeMeasIdToAddModList
7371  *
7372  *    Functionality: Free measurement id to add mod list
7373  *
7374  * @params[in] Measurement id to add mod list
7375  * @return void
7376  *
7377  * ****************************************************************/
7378 void freeMeasIdToAddModList(MeasIdToAddModList_t *measIdList)
7379 {
7380    uint8_t measIdIdx;
7381    if(measIdList->list.array)
7382    {
7383       for(measIdIdx=0; measIdIdx < measIdList->list.count; measIdIdx++)
7384       {
7385          CU_FREE(measIdList->list.array[measIdIdx], sizeof(MeasIdToAddMod_t));
7386       }
7387       CU_FREE(measIdList->list.array, measIdList->list.size);
7388    }
7389 }
7390
7391 /*******************************************************************
7392  *
7393  * @brief Free quantity config
7394  *
7395  * @details
7396  *
7397  *    Function : freeQunatityConfig
7398  *
7399  *    Functionality: Free quantity config
7400  *
7401  * @params[in] Quantity Config
7402  * @return void
7403  *
7404  * ****************************************************************/
7405 uint8_t freeQuantityConfig(QuantityConfig_t *quantityCfg)
7406 {
7407    uint8_t quanCfgIdx;
7408    QuantityConfigNR_t *quantityCfgNr;
7409
7410    if(quantityCfg->quantityConfigNR_List)
7411    {
7412       if(quantityCfg->quantityConfigNR_List->list.array)
7413       {
7414          for(quanCfgIdx = 0; quanCfgIdx < quantityCfg->quantityConfigNR_List->list.count; quanCfgIdx++)
7415          {
7416             if(quantityCfg->quantityConfigNR_List->list.array[quanCfgIdx])
7417             {
7418                quantityCfgNr = quantityCfg->quantityConfigNR_List->list.array[quanCfgIdx];
7419                CU_FREE(quantityCfgNr->quantityConfigCell.ssb_FilterConfig.filterCoefficientRSRP, sizeof(FilterCoefficient_t));
7420                CU_FREE(quantityCfgNr->quantityConfigCell.ssb_FilterConfig.filterCoefficientRSRQ, sizeof(FilterCoefficient_t));
7421                CU_FREE(quantityCfgNr->quantityConfigCell.ssb_FilterConfig.filterCoefficientRS_SINR, sizeof(FilterCoefficient_t));
7422                if(quantityCfgNr->quantityConfigRS_Index)
7423                {
7424                   CU_FREE(quantityCfgNr->quantityConfigRS_Index->ssb_FilterConfig.filterCoefficientRSRP, sizeof(FilterCoefficient_t));
7425                   CU_FREE(quantityCfgNr->quantityConfigRS_Index->ssb_FilterConfig.filterCoefficientRSRQ, sizeof(FilterCoefficient_t));
7426                   CU_FREE(quantityCfgNr->quantityConfigRS_Index->ssb_FilterConfig.filterCoefficientRS_SINR, sizeof(FilterCoefficient_t));
7427                   CU_FREE(quantityCfgNr->quantityConfigRS_Index, sizeof(QuantityConfigRS_t));
7428                }
7429                CU_FREE(quantityCfg->quantityConfigNR_List->list.array[quanCfgIdx], sizeof(QuantityConfigNR_t));
7430             }
7431          }
7432          CU_FREE(quantityCfg->quantityConfigNR_List->list.array, quantityCfg->quantityConfigNR_List->list.size);
7433       }
7434       CU_FREE(quantityCfg->quantityConfigNR_List, sizeof(struct QuantityConfig__quantityConfigNR_List));
7435    }
7436 }
7437
7438 /******************************************************************
7439  *
7440  * @brief Free measurement Config
7441  *
7442  * @details
7443  *
7444  *    Function : freeMeasConfig
7445  *
7446  *    Functionality: Free measurement config
7447  *
7448  * @params[in] Measurement config
7449  * @return void
7450  *
7451  * ****************************************************************/
7452 void freeMeasConfig(MeasConfigRrc_t *measConfig)
7453 {
7454    if(measConfig->measObjectToAddModList)
7455    {
7456       freeMeasObjToAddModList(measConfig->measObjectToAddModList);
7457       CU_FREE(measConfig->measObjectToAddModList, sizeof(MeasObjectToAddModList_t));
7458    }
7459    if(measConfig->reportConfigToAddModList)
7460    {
7461       freeReportCfgToAddModList(measConfig->reportConfigToAddModList);
7462       CU_FREE(measConfig->reportConfigToAddModList, sizeof(ReportConfigToAddModList_t));
7463    }
7464    if(measConfig->measIdToAddModList)
7465    {
7466       freeMeasIdToAddModList(measConfig->measIdToAddModList);
7467       CU_FREE(measConfig->measIdToAddModList, sizeof(MeasIdToAddModList_t));
7468    }
7469    if(measConfig->s_MeasureConfig)
7470    {
7471       CU_FREE(measConfig->s_MeasureConfig, sizeof(struct MeasConfigRrc__s_MeasureConfig));
7472    }
7473    if(measConfig->quantityConfig)
7474    {
7475       freeQuantityConfig(measConfig->quantityConfig);
7476       CU_FREE(measConfig->quantityConfig, sizeof(QuantityConfig_t));
7477    }
7478 }
7479 /******************************************************************
7480  *
7481  * @brief Free DRB to AddMod List
7482  *
7483  * @details
7484  *
7485  *    Function : freeDrbToAddModList
7486  *
7487  *    Functionality: Free SRB to AddMod List
7488  *
7489  * @params[in] SBR to add/mod list
7490  * @return void
7491  *
7492  * ****************************************************************/
7493 void freeDrbToAddModList(DRB_ToAddModList_t *drbToAddList)
7494 {
7495    uint8_t drbIdx;
7496    if(drbToAddList->list.array)
7497    {
7498       for(drbIdx = 0; drbIdx < drbToAddList->list.count; drbIdx++)
7499       {
7500          if(drbToAddList->list.array[drbIdx]->pdcp_Config)
7501          {
7502             if(drbToAddList->list.array[drbIdx]->pdcp_Config->drb)
7503             {
7504                CU_FREE(drbToAddList->list.array[drbIdx]->pdcp_Config->drb->discardTimer, sizeof(long));
7505                CU_FREE(drbToAddList->list.array[drbIdx]->pdcp_Config->drb->pdcp_SN_SizeUL, sizeof(long));
7506                CU_FREE(drbToAddList->list.array[drbIdx]->pdcp_Config->drb->pdcp_SN_SizeDL, sizeof(long));
7507                CU_FREE(drbToAddList->list.array[drbIdx]->pdcp_Config->drb, sizeof(struct PDCP_Config__drb));
7508             }
7509             CU_FREE(drbToAddList->list.array[drbIdx]->pdcp_Config->t_Reordering, sizeof(long));
7510             CU_FREE(drbToAddList->list.array[drbIdx]->pdcp_Config, sizeof(PDCP_Config_t));
7511          }
7512          CU_FREE(drbToAddList->list.array[drbIdx], sizeof(DRB_ToAddMod_t));
7513       }
7514       CU_FREE(drbToAddList->list.array, drbToAddList->list.size);
7515    }
7516 }
7517
7518 /******************************************************************
7519  *
7520  * @brief Free SRB to AddMod List
7521  *
7522  * @details
7523  *
7524  *    Function : freeSrbToAddModList
7525  *
7526  *    Functionality: Free SRB to AddMod List
7527  *
7528  * @params[in] SBR to add/mod list
7529  * @return void
7530  *
7531  * ****************************************************************/
7532 void freeSrbToAddModList(SRB_ToAddModList_t *srbToAddList)
7533 {
7534    uint8_t srbIdx;
7535    if(srbToAddList->list.array)
7536    {
7537       for(srbIdx = 0; srbIdx < srbToAddList->list.count; srbIdx++)
7538       {
7539          CU_FREE(srbToAddList->list.array[srbIdx]->reestablishPDCP, sizeof(long));
7540          if(srbToAddList->list.array[srbIdx]->pdcp_Config)
7541          {
7542             CU_FREE(srbToAddList->list.array[srbIdx]->pdcp_Config->t_Reordering, sizeof(long));
7543             CU_FREE(srbToAddList->list.array[srbIdx]->pdcp_Config, sizeof(PDCP_Config_t));
7544          }
7545
7546          CU_FREE(srbToAddList->list.array[srbIdx], sizeof(SRB_ToAddMod_t));
7547       }
7548       CU_FREE(srbToAddList->list.array, srbToAddList->list.size);
7549    }
7550 }
7551
7552 /******************************************************************
7553  *
7554  * @brief Free Radio Bearer Config
7555  *
7556  * @details
7557  *
7558  *    Function : fillRadioBearerConfig
7559  *
7560  *    Functionality: Free Radio Bearer config
7561  *
7562  * @params[in] Radio bearer config
7563  * @return void
7564  *
7565  * ****************************************************************/
7566 void freeRadioBearerConfig(RadioBearerConfig_t *radioBearerConfig)
7567 {
7568    if(radioBearerConfig->srb_ToAddModList)
7569    {
7570       freeSrbToAddModList(radioBearerConfig->srb_ToAddModList);
7571       CU_FREE(radioBearerConfig->srb_ToAddModList, sizeof(SRB_ToAddModList_t));
7572    }
7573    if(radioBearerConfig->drb_ToAddModList)
7574    {
7575       freeDrbToAddModList(radioBearerConfig->drb_ToAddModList);
7576       CU_FREE(radioBearerConfig->drb_ToAddModList, sizeof(DRB_ToAddModList_t));
7577    }
7578 }
7579
7580 /******************************************************************
7581  *
7582  * @brief Free reconfiguration message
7583  *
7584  * @details
7585  *
7586  *    Function : freeRrcReconfig
7587  *
7588  *    Functionality: Free reconfiguration message
7589  *
7590  * @params[in] RRC Reconfiguration message
7591  * @return void
7592  *
7593  * ****************************************************************/
7594 void freeRrcReconfig(RRCReconfiguration_t *rrcReconfig)
7595 {
7596    if(rrcReconfig->criticalExtensions.choice.rrcReconfiguration)
7597    {
7598       if(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->radioBearerConfig)
7599       {
7600          freeRadioBearerConfig(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->radioBearerConfig);
7601          CU_FREE(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->radioBearerConfig, sizeof(RadioBearerConfig_t));
7602       }
7603       if(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->measConfig)
7604       {
7605          freeMeasConfig(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->measConfig);
7606          CU_FREE(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->measConfig, sizeof(MeasConfigRrc_t));
7607       }
7608       if(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->nonCriticalExtension)
7609       {
7610          freeRrcReconfigNonCriticalExt(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->nonCriticalExtension);
7611          CU_FREE(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->nonCriticalExtension, sizeof(struct RRCReconfiguration_v1530_IEs));
7612       }
7613       CU_FREE(rrcReconfig->criticalExtensions.choice.rrcReconfiguration, sizeof(RRCReconfiguration_IEs_t));
7614    }
7615 }
7616
7617 /******************************************************************
7618  *
7619  * @brief Fill SRB To Add Mod list
7620  *
7621  * @details
7622  *
7623  *    Function : fillSrbToAddModList
7624  *
7625  *    Functionality: fill SRB to Add Mod list
7626  *
7627  * @params[in] UE control block
7628  *             SRB to Add/Mod list
7629  * @return ROK     - success
7630  *         RFAILED - failure
7631  *
7632  * ****************************************************************/
7633 uint8_t fillSrbToAddModList(CuUeCb *ueCb, SRB_ToAddModList_t *srbToAddList, bool updateAllRbCfg)
7634 {
7635    uint8_t srbIdx, srbDbIdx, elementCnt = 0;
7636
7637    if(updateAllRbCfg)
7638       elementCnt = ueCb->numSrb;
7639    else
7640    {
7641       for(srbDbIdx=0; srbDbIdx < ueCb->numSrb; srbDbIdx++)
7642       {
7643          if(ueCb->srbList[srbDbIdx].cfgSentToUe == false)
7644             elementCnt++;
7645       }
7646    }
7647
7648    if(!elementCnt)
7649    {
7650       DU_LOG("INFO  --> F1AP : No SRB available to add or modify");
7651       return ROK;
7652    }
7653
7654    CU_ALLOC(srbToAddList, sizeof(SRB_ToAddModList_t));
7655    if(!srbToAddList)
7656    {
7657       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for SRB to AddMod List in fillRadioBearerConfig");
7658       return RFAILED;
7659    }
7660    srbToAddList->list.count = elementCnt;
7661    srbToAddList->list.size = srbToAddList->list.count * sizeof(SRB_ToAddMod_t *);
7662
7663    CU_ALLOC(srbToAddList->list.array, srbToAddList->list.size);
7664    if(!srbToAddList->list.array)
7665    {
7666       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for SRB to AddMod list array in fillSrbToAddModList");
7667       return RFAILED;
7668    }
7669
7670    srbIdx = 0;
7671    for(srbDbIdx = 0; srbDbIdx < ueCb->numSrb; srbDbIdx++)
7672    {
7673       if(!updateAllRbCfg && ueCb->srbList[srbDbIdx].cfgSentToUe)
7674          continue;
7675
7676       CU_ALLOC(srbToAddList->list.array[srbIdx], sizeof(SRB_ToAddMod_t));
7677       if(!srbToAddList->list.array[srbIdx])
7678       {
7679          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for SRB to AddMod list element in fillSrbToAddModList");
7680          return RFAILED;
7681       }
7682
7683       srbToAddList->list.array[srbIdx]->srb_Identity = ueCb->srbList[srbDbIdx].srbId;
7684
7685       /* Reestablish PDCP */
7686       CU_ALLOC(srbToAddList->list.array[srbIdx]->reestablishPDCP, sizeof(long));
7687       if(!srbToAddList->list.array[srbIdx]->reestablishPDCP)
7688       {
7689          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for reestablish PDCP IE in fillSrbToAddModList");
7690          return RFAILED;
7691       }
7692       *(srbToAddList->list.array[srbIdx]->reestablishPDCP) = SRB_ToAddMod__reestablishPDCP_true;
7693
7694       /* PDCP configuration */
7695       CU_ALLOC(srbToAddList->list.array[srbIdx]->pdcp_Config, sizeof(PDCP_Config_t));
7696       if(!srbToAddList->list.array[srbIdx]->pdcp_Config)
7697       {
7698          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for PDCP config IE in fillSrbToAddModList");
7699          return RFAILED;
7700       }
7701
7702       /* Reordering timer */
7703       CU_ALLOC(srbToAddList->list.array[srbIdx]->pdcp_Config->t_Reordering, sizeof(long));
7704       if(!srbToAddList->list.array[srbIdx]->pdcp_Config->t_Reordering)
7705       {
7706          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for reordering timer in fillSrbToAddModList");
7707          return RFAILED;
7708       }
7709       *(srbToAddList->list.array[srbIdx]->pdcp_Config->t_Reordering) = PDCP_Config__t_Reordering_ms40;
7710
7711       srbIdx++;
7712    }
7713    return ROK;
7714 }
7715
7716 /******************************************************************
7717  *
7718  * @biief Fill DRBeTo Add Mod list
7719  *
7720  * @details
7721  *
7722  *    Function : fillDrbToAddModList
7723  *
7724  *    Functionality: fill DRB to Add Mod list
7725  *
7726  * @params[in] UE control block
7727  *             DRB to Add/Mod list
7728  * @return ROK     - success
7729  *         RFAILED - failure
7730  *
7731  * ****************************************************************/
7732 uint8_t fillDrbToAddModList(CuUeCb *ueCb, DRB_ToAddModList_t *drbToAddList, bool updateAllRbCfg)
7733 {
7734    uint8_t drbIdx, drbDbIdx, elementCnt = 0;
7735
7736    if(updateAllRbCfg)
7737       elementCnt = ueCb->numDrb;
7738    else
7739    {
7740       for(drbDbIdx=0; drbDbIdx < ueCb->numDrb; drbDbIdx++)
7741       {
7742          if(ueCb->drbList[drbDbIdx].cfgSentToUe == false)
7743             elementCnt++;
7744       }
7745    }
7746
7747    if(!elementCnt)
7748    {
7749       DU_LOG("INFO  --> F1AP : No DRB available to add or modify");
7750       return ROK;
7751    }
7752
7753    /* DRB To Add/Mod List */
7754    CU_ALLOC(drbToAddList, sizeof(DRB_ToAddModList_t));
7755    if(!drbToAddList)
7756    {
7757       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for DRB to AddMod List in fillRadioBearerConfig");
7758       return RFAILED;
7759    }
7760
7761    drbToAddList->list.count = elementCnt;
7762    drbToAddList->list.size = drbToAddList->list.count * sizeof(DRB_ToAddMod_t *);
7763
7764    CU_ALLOC(drbToAddList->list.array, drbToAddList->list.size);
7765    if(!drbToAddList->list.array)
7766    {
7767       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for DRB to AddMod list array in fillDrbToAddModList");
7768       return RFAILED;
7769    }
7770
7771    drbIdx = 0;
7772    for(drbDbIdx=0; drbDbIdx < ueCb->numDrb; drbDbIdx++)
7773    {
7774       if(!updateAllRbCfg && ueCb->drbList[drbDbIdx].cfgSentToUe)
7775          continue;
7776
7777       CU_ALLOC(drbToAddList->list.array[drbIdx], sizeof(DRB_ToAddMod_t));
7778       if(!drbToAddList->list.array[drbIdx])
7779       {
7780          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for DRB to AddMod list elements in fillDrbToAddModList");
7781          return RFAILED;
7782       }
7783
7784       /* DRB Id */
7785       drbToAddList->list.array[drbIdx]->drb_Identity = ueCb->drbList[drbDbIdx].drbId;
7786
7787       /* PDCP Config */
7788       CU_ALLOC(drbToAddList->list.array[drbIdx]->pdcp_Config, sizeof(PDCP_Config_t));
7789       if(!drbToAddList->list.array[drbIdx]->pdcp_Config)
7790       {
7791          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for PDCP config IE in fillDrbToAddModList");
7792          return RFAILED;
7793       }
7794
7795       /* PDCP Config -> DRB */
7796       CU_ALLOC(drbToAddList->list.array[drbIdx]->pdcp_Config->drb, sizeof(struct PDCP_Config__drb));
7797       if(!drbToAddList->list.array[drbIdx]->pdcp_Config->drb)
7798       {
7799          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for PDCP config drb in fillDrbToAddModList");
7800          return RFAILED;
7801       }
7802
7803       /* DRB -> Discard Timer */
7804       CU_ALLOC(drbToAddList->list.array[drbIdx]->pdcp_Config->drb->discardTimer, sizeof(long));
7805       if(!drbToAddList->list.array[drbIdx]->pdcp_Config->drb->discardTimer)
7806       {
7807          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for DRB discard timer in fillDrbToAddModList");
7808          return RFAILED;
7809       }
7810       *(drbToAddList->list.array[drbIdx]->pdcp_Config->drb->discardTimer) = PDCP_Config__drb__discardTimer_infinity;
7811
7812       /* UL PDCP SN length */
7813       CU_ALLOC(drbToAddList->list.array[drbIdx]->pdcp_Config->drb->pdcp_SN_SizeUL, sizeof(long));
7814       if(!drbToAddList->list.array[drbIdx]->pdcp_Config->drb->pdcp_SN_SizeUL)
7815       {
7816          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for UL SN length in fillDrbToAddModList");
7817          return RFAILED;
7818       }
7819       *(drbToAddList->list.array[drbIdx]->pdcp_Config->drb->pdcp_SN_SizeUL) = PDCP_Config__drb__pdcp_SN_SizeUL_len12bits;
7820
7821       /* DL PDCP SN length */
7822       CU_ALLOC(drbToAddList->list.array[drbIdx]->pdcp_Config->drb->pdcp_SN_SizeDL, sizeof(long));
7823       if(!drbToAddList->list.array[drbIdx]->pdcp_Config->drb->pdcp_SN_SizeDL)
7824       {
7825          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for DL SN length in fillDrbToAddModList");
7826          return RFAILED;
7827       }
7828       *(drbToAddList->list.array[drbIdx]->pdcp_Config->drb->pdcp_SN_SizeDL) = PDCP_Config__drb__pdcp_SN_SizeDL_len12bits;
7829
7830       /* Header Compression */
7831       drbToAddList->list.array[drbIdx]->pdcp_Config->drb->headerCompression.present = PDCP_Config__drb__headerCompression_PR_notUsed;
7832        drbToAddList->list.array[drbIdx]->pdcp_Config->drb->headerCompression.choice.notUsed = NULLP;
7833
7834       /* Reordering timer */
7835       CU_ALLOC(drbToAddList->list.array[drbIdx]->pdcp_Config->t_Reordering, sizeof(long));
7836       if(!drbToAddList->list.array[drbIdx]->pdcp_Config->t_Reordering)
7837       {
7838          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for reordering timer in fillDrbToAddModList");
7839          return RFAILED;
7840       }
7841       *(drbToAddList->list.array[drbIdx]->pdcp_Config->t_Reordering) = PDCP_Config__t_Reordering_ms40;
7842
7843       drbIdx++;
7844    }
7845
7846    return ROK;
7847 }
7848
7849 /******************************************************************
7850  *
7851  * @brief Fill Radio bearer configuration
7852  *
7853  * @details
7854  *
7855  *    Function : fillRadioBearerConfig
7856  *
7857  *    Functionality: Fill Radio bearer configuration
7858  *
7859  * @params[in] UE control block
7860  *             Radio bearer config pointer
7861  * @return ROK     - success
7862  *         RFAILED - failure
7863  *
7864  * ****************************************************************/
7865 uint8_t fillRadioBearerConfig(CuUeCb *ueCb, RadioBearerConfig_t *radioBearerConfig, bool updateAllRbCfg)
7866 {
7867    /* SRB To Add/Mod List */
7868    if(fillSrbToAddModList(ueCb, radioBearerConfig->srb_ToAddModList, updateAllRbCfg) != ROK)
7869    {
7870       return RFAILED;
7871    }
7872
7873    if(fillDrbToAddModList(ueCb, radioBearerConfig->drb_ToAddModList, updateAllRbCfg) != ROK)
7874    {
7875       return RFAILED;
7876    }
7877
7878    return ROK;
7879 }
7880
7881 /*******************************************************************
7882  *
7883  * @brief Fill measurement object to add/mod list
7884  *
7885  * @details
7886  *
7887  *    Function : fillMeasObjToAddModList
7888  *
7889  *    Functionality: Fill measurement object to add/mod list
7890  *
7891  * @params[in] Measurement object to add/mod list
7892  * @return ROK     - success
7893  *         RFAILED - failure
7894  *
7895  * ****************************************************************/
7896 uint8_t fillMeasObjToAddModList(MeasObjectToAddModList_t *measObjList)
7897 {
7898    uint8_t elementCnt, objIdx;
7899    MeasObjectNR_t *measObject;
7900
7901    elementCnt = 1;
7902    measObjList->list.count = elementCnt;
7903    measObjList->list.size = measObjList->list.count * sizeof(MeasObjectToAddMod_t *);
7904
7905    CU_ALLOC(measObjList->list.array, measObjList->list.size);
7906    if(!measObjList->list.array)
7907    {
7908       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for measurement object list's array");
7909       return RFAILED;
7910    }
7911
7912    for(objIdx = 0; objIdx < measObjList->list.size; objIdx++)
7913    {
7914       CU_ALLOC(measObjList->list.array[objIdx], sizeof(MeasObjectToAddMod_t));
7915       if(!measObjList->list.array[objIdx])
7916       {
7917          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for measurement object list's array element");
7918          return RFAILED;
7919       }
7920    }
7921
7922    objIdx = 0;
7923    measObjList->list.array[objIdx]->measObjectId = 1;
7924    measObjList->list.array[objIdx]->measObject.present = MeasObjectToAddMod__measObject_PR_measObjectNR;
7925    CU_ALLOC(measObjList->list.array[objIdx]->measObject.choice.measObjectNR, sizeof(MeasObjectNR_t));
7926    if(!measObjList->list.array[objIdx]->measObject.choice.measObjectNR)
7927    {
7928       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for mesurement object NR");
7929       return RFAILED;
7930    }
7931
7932    measObject = measObjList->list.array[objIdx]->measObject.choice.measObjectNR;
7933
7934    /* SSB frequency */
7935    CU_ALLOC(measObject->ssbFrequency, sizeof(ARFCN_ValueNR_t));
7936    if(!measObject->ssbFrequency)
7937    {
7938       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for SSB frequency in fillMeasObjToAddModList");
7939       return RFAILED;
7940    }
7941    *(measObject->ssbFrequency) = 620736; /* Value picked from reference PCAP logs */
7942
7943    /* Subcarrier spacing */
7944    CU_ALLOC(measObject->ssbSubcarrierSpacing, sizeof(SubcarrierSpacing_t));
7945    if(!measObject->ssbSubcarrierSpacing)
7946    {
7947       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for SSB subcarrier spacing in fillMeasObjToAddModList");
7948       return RFAILED;
7949    }
7950    *(measObject->ssbSubcarrierSpacing) = SubcarrierSpacing_kHz15;
7951
7952    /* SMTC1 */
7953    CU_ALLOC(measObject->smtc1 , sizeof(SSB_MTC_t));
7954    if(!measObject->smtc1)
7955    {
7956       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for SMTC1 in fillMeasObjToAddModList");
7957       return RFAILED;
7958    }
7959    measObject->smtc1->duration = SSB_MTC__duration_sf1;
7960    measObject->smtc1->periodicityAndOffset.present = SSB_MTC__periodicityAndOffset_PR_sf20;
7961    measObject->smtc1->periodicityAndOffset.choice.sf20 = 0;
7962
7963    /* Absoulute threshold SSB consolidation */
7964    CU_ALLOC(measObject->absThreshSS_BlocksConsolidation, sizeof(ThresholdNR_t));
7965    if(!measObject->absThreshSS_BlocksConsolidation)
7966    {
7967       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for absolute threshold SSB consolidation in fillMeasObjToAddModList");
7968       return RFAILED;
7969    }
7970
7971    /* RSRP threshold */
7972    CU_ALLOC(measObject->absThreshSS_BlocksConsolidation->thresholdRSRP, sizeof(RSRP_Range_t));
7973    if(!measObject->absThreshSS_BlocksConsolidation->thresholdRSRP)
7974    {
7975       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for threshold RSRP in fillMeasObjToAddModList");
7976       return RFAILED;
7977    }
7978    *(measObject->absThreshSS_BlocksConsolidation->thresholdRSRP) = 1;
7979
7980    /* RSRQ threshold */
7981    CU_ALLOC(measObject->absThreshSS_BlocksConsolidation->thresholdRSRQ, sizeof(RSRQ_Range_t));
7982    if(!measObject->absThreshSS_BlocksConsolidation->thresholdRSRQ)
7983    {
7984       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for threshold RSRQ in fillMeasObjToAddModList");
7985       return RFAILED;
7986    }
7987    *(measObject->absThreshSS_BlocksConsolidation->thresholdRSRQ) = 1;
7988
7989    /* SINR threshold */
7990    CU_ALLOC(measObject->absThreshSS_BlocksConsolidation->thresholdSINR, sizeof(SINR_Range_t));
7991    if(!measObject->absThreshSS_BlocksConsolidation->thresholdSINR)
7992    {
7993       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for threshold SINR in fillMeasObjToAddModList");
7994       return RFAILED;
7995    }
7996    *(measObject->absThreshSS_BlocksConsolidation->thresholdSINR) = 1;
7997
7998    /* Number of SSBs to average */
7999    CU_ALLOC(measObject->nrofSS_BlocksToAverage, sizeof(long));
8000    if(!measObject->nrofSS_BlocksToAverage)
8001    {
8002       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for number of SSB to average in fillMeasObjToAddModList");
8003       return RFAILED;
8004    }
8005    *(measObject->nrofSS_BlocksToAverage) = 2;
8006
8007    /* Quantity Config index */
8008    measObject->quantityConfigIndex = 1;
8009
8010    /* Offset MO */
8011    /* RSRP offset for SSB */
8012    CU_ALLOC(measObject->offsetMO.rsrpOffsetSSB, sizeof(Q_OffsetRange_t));
8013    if(!measObject->offsetMO.rsrpOffsetSSB)
8014    {
8015       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for SSB RSRP offset in fillMeasObjToAddModList");
8016       return RFAILED;
8017    }
8018    *(measObject->offsetMO.rsrpOffsetSSB) = Q_OffsetRange_dB0;
8019
8020    /* RSRQ offset for SSB */
8021    CU_ALLOC(measObject->offsetMO.rsrqOffsetSSB, sizeof(Q_OffsetRange_t));
8022    if(!measObject->offsetMO.rsrpOffsetSSB)
8023    {
8024       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for SSB RSRQ offset in fillMeasObjToAddModList");
8025       return RFAILED;
8026    }
8027    *(measObject->offsetMO.rsrqOffsetSSB) = Q_OffsetRange_dB0;
8028
8029    /* SINR offset for SSB */
8030    CU_ALLOC(measObject->offsetMO.sinrOffsetSSB, sizeof(Q_OffsetRange_t));
8031    if(!measObject->offsetMO.sinrOffsetSSB)
8032    {
8033       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for SSB SINR offset in fillMeasObjToAddModList");
8034       return RFAILED;
8035    }
8036    *(measObject->offsetMO.sinrOffsetSSB) = Q_OffsetRange_dB0;
8037
8038    return ROK;
8039 }
8040
8041 /*******************************************************************
8042  *
8043  * @brief Fill Report configuration to Add/mod list
8044  *
8045  * @details
8046  *
8047  *    Function : fillReportCfgToAddModList
8048  *
8049  *    Functionality: Fill Report configuration to Add/mod list
8050  *
8051  * @params[in] Report Config To Add/Mod List
8052  * @return ROK     - success
8053  *         RFAILED - failure
8054  *
8055  * ****************************************************************/
8056 uint8_t fillReportCfgToAddModList(ReportConfigToAddModList_t *reportCfgList)
8057 {
8058    uint8_t elementCnt;
8059    uint8_t reportCfgIdx;
8060    ReportConfigToAddMod_t *reportCfg;
8061    ReportConfigNR_t *reportCfgNr;
8062    EventTriggerConfig_t *eventTriggCfg;
8063
8064    elementCnt = 1;
8065    reportCfgList->list.count = elementCnt;
8066    reportCfgList->list.size = reportCfgList->list.count * sizeof(ReportConfigToAddMod_t *);
8067
8068    CU_ALLOC(reportCfgList->list.array, reportCfgList->list.size);
8069    if(!reportCfgList->list.array)
8070    {
8071       DU_LOG("\nERROR  -->  F1AP: fillReportCfgToAddModList() :Memory allocation failed for report config list's array");
8072       return RFAILED;
8073    }
8074
8075    for(reportCfgIdx=0; reportCfgIdx < reportCfgList->list.count; reportCfgIdx++)
8076    {
8077       CU_ALLOC(reportCfgList->list.array[reportCfgIdx], sizeof(ReportConfigToAddMod_t));
8078       if(!reportCfgList->list.array[reportCfgIdx])
8079       {
8080          DU_LOG("\nERROR  -->  F1AP: fillReportCfgToAddModList(): Memory allocation failed for report config list's array element");
8081          return RFAILED;
8082       }
8083    }
8084
8085    reportCfgIdx = 0;
8086    reportCfg = reportCfgList->list.array[reportCfgIdx];
8087    reportCfg->reportConfigId = 1;
8088    reportCfg->reportConfig.present = ReportConfigToAddMod__reportConfig_PR_reportConfigNR;
8089
8090    /* Report Configuration for NR */
8091    CU_ALLOC(reportCfg->reportConfig.choice.reportConfigNR, sizeof(ReportConfigNR_t));
8092    if(!reportCfg->reportConfig.choice.reportConfigNR)
8093    {
8094       DU_LOG("\nERROR  -->  F1AP: fillReportCfgToAddModList(): Memory allocation failed for report config NR");
8095       return RFAILED;
8096    }
8097    reportCfgNr = reportCfg->reportConfig.choice.reportConfigNR;
8098
8099    /* Report Type */
8100    reportCfgNr->reportType.present = ReportConfigNR__reportType_PR_eventTriggered;
8101    CU_ALLOC(reportCfgNr->reportType.choice.eventTriggered, sizeof(EventTriggerConfig_t));
8102    if(!reportCfgNr->reportType.choice.eventTriggered)
8103    {
8104       DU_LOG("\nERROR  -->  F1AP: fillReportCfgToAddModList(): Memory allocation failed for event triggerred");
8105       return RFAILED;
8106    }
8107    eventTriggCfg = reportCfgNr->reportType.choice.eventTriggered;
8108
8109    /* Event 3 */
8110    eventTriggCfg->eventId.present = EventTriggerConfig__eventId_PR_eventA3;
8111    CU_ALLOC(eventTriggCfg->eventId.choice.eventA3, sizeof(struct EventTriggerConfig__eventId__eventA3));
8112    if(!eventTriggCfg->eventId.choice.eventA3)
8113    {
8114       DU_LOG("\nERROR  -->  F1AP: fillReportCfgToAddModList(): Memory allocation failed for event A3");
8115       return RFAILED;
8116    }
8117
8118    eventTriggCfg->eventId.choice.eventA3->a3_Offset.present = MeasTriggerQuantityOffset_PR_rsrp;
8119    eventTriggCfg->eventId.choice.eventA3->a3_Offset.choice.rsrp = 6; /* i.e. 3.0db . From Reference pcap log */
8120    eventTriggCfg->eventId.choice.eventA3->reportOnLeave = false;
8121    eventTriggCfg->eventId.choice.eventA3->hysteresis = 0;
8122    eventTriggCfg->eventId.choice.eventA3->timeToTrigger = TimeToTrigger_ms40;
8123    eventTriggCfg->eventId.choice.eventA3->useWhiteCellList = false;
8124
8125    /* Reference Signal Type */
8126    eventTriggCfg->rsType = NR_RS_Type_ssb;
8127
8128    /* Report Interval */
8129    eventTriggCfg->reportInterval = ReportInterval_ms1024;
8130
8131    /* Report Amount */
8132    eventTriggCfg->reportAmount = EventTriggerConfig__reportAmount_r8;
8133
8134    /* Report Quantity cell */
8135    eventTriggCfg->reportQuantityCell.rsrp = true;
8136    eventTriggCfg->reportQuantityCell.rsrq = false;
8137    eventTriggCfg->reportQuantityCell.sinr = false;
8138
8139    /* Maximum reported cells */
8140    eventTriggCfg->maxReportCells = 3;
8141
8142    /* Report qunatity RS Indexes */
8143    CU_ALLOC(eventTriggCfg->reportQuantityRS_Indexes, sizeof(MeasReportQuantity_t));
8144    if(!eventTriggCfg->reportQuantityRS_Indexes)
8145    {
8146       DU_LOG("\nERROR  -->  F1AP: fillReportCfgToAddModList(): Memory allocation failed for report qunatity RS indexes");
8147       return RFAILED;
8148    }
8149    eventTriggCfg->reportQuantityRS_Indexes->rsrp = true;
8150    eventTriggCfg->reportQuantityRS_Indexes->rsrq = false;
8151    eventTriggCfg->reportQuantityRS_Indexes->sinr = false;
8152
8153    /* Maximum number of RS indexes to report */
8154    CU_ALLOC(eventTriggCfg->maxNrofRS_IndexesToReport, sizeof(long));
8155    if(!eventTriggCfg->maxNrofRS_IndexesToReport)
8156    {
8157       DU_LOG("\nERROR  -->  F1AP: fillReportCfgToAddModList(): Memory allocation failed for max number of RS indexes to report");
8158       return RFAILED;
8159    }
8160    *(eventTriggCfg->maxNrofRS_IndexesToReport) = 1;
8161
8162    /* Include Beam measurement */
8163    eventTriggCfg->includeBeamMeasurements = false;
8164
8165    return ROK;
8166 }
8167
8168 /*******************************************************************
8169  *
8170  * @brief Fill measurement Id to add/mod list
8171
8172  * @details
8173  *
8174  *    Function : fillMeasIdToAddModList
8175  *
8176  *    Functionality: Fill measurement Id to add/mod list
8177  *
8178  * @params[in] Measurement Id to add/mod list
8179  * @return ROK     - success
8180  *         RFAILED - failure
8181  *
8182  * ****************************************************************/
8183 uint8_t fillMeasIdToAddModList(MeasIdToAddModList_t *measIdList)
8184 {
8185    uint8_t elementCnt;
8186    uint8_t measIdIdx;
8187
8188    elementCnt = 1;
8189    measIdList->list.count = elementCnt;
8190    measIdList->list.size = measIdList->list.count *sizeof(MeasIdToAddMod_t *);
8191
8192    CU_ALLOC(measIdList->list.array, measIdList->list.size);
8193    if(!measIdList->list.array)
8194    {
8195       return RFAILED;
8196    }
8197
8198    for(measIdIdx=0; measIdIdx < measIdList->list.count; measIdIdx++)
8199    {
8200       CU_ALLOC(measIdList->list.array[measIdIdx], sizeof(MeasIdToAddMod_t));
8201       if(!measIdList->list.array[measIdIdx])
8202       {
8203          return RFAILED;
8204       }
8205
8206       measIdIdx=0;
8207       measIdList->list.array[measIdIdx]->measId = 1;
8208       measIdList->list.array[measIdIdx]->measObjectId = 1;
8209       measIdList->list.array[measIdIdx]->reportConfigId = 1;
8210    }
8211    return ROK;
8212 }
8213
8214 /*******************************************************************
8215  *
8216  * @brief Fill s-measurement configuration
8217  *
8218  * @details
8219  *
8220  *    Function : fillSMeasConfig
8221  *
8222  *    Functionality: Fill s-measurement configuration
8223  *
8224  * @params[in] s-Measurement config
8225  * @return ROK     - success
8226  *         RFAILED - failure
8227  *
8228  * ****************************************************************/
8229 uint8_t fillSMeasConfig(struct MeasConfigRrc__s_MeasureConfig *sMeasCfg)
8230 {
8231    sMeasCfg->present = MeasConfigRrc__s_MeasureConfig_PR_ssb_RSRP;
8232    sMeasCfg->choice.ssb_RSRP = 100; /* Value taken from reference PCAP log */
8233
8234    return ROK;
8235 }
8236
8237 /*******************************************************************
8238  *
8239  * @brief Fill quantity config
8240  *
8241  * @details
8242  *
8243  *    Function : fillQunatityConfig
8244  *
8245  *    Functionality: Fill quantity config
8246  *
8247  * @params[in] Quantity Config
8248  * @return ROK     - success
8249  *         RFAILED - failure
8250  *
8251  * ****************************************************************/
8252 uint8_t fillQuantityConfig(QuantityConfig_t *quantityCfg)
8253 {
8254    uint8_t elementCnt = 0;
8255    uint8_t quanCfgIdx = 0;
8256    QuantityConfigNR_t *quantityCfgNr;
8257
8258    CU_ALLOC(quantityCfg->quantityConfigNR_List, sizeof(struct QuantityConfig__quantityConfigNR_List));
8259    if(!quantityCfg->quantityConfigNR_List)
8260    {
8261       return RFAILED;
8262    }
8263
8264    elementCnt = 1;
8265    quantityCfg->quantityConfigNR_List->list.count = elementCnt;
8266    quantityCfg->quantityConfigNR_List->list.size = elementCnt * sizeof(QuantityConfigNR_t *);
8267
8268    CU_ALLOC(quantityCfg->quantityConfigNR_List->list.array, quantityCfg->quantityConfigNR_List->list.size);
8269    if(!quantityCfg->quantityConfigNR_List->list.array)
8270    {
8271       return RFAILED;
8272    }
8273
8274    for(quanCfgIdx = 0; quanCfgIdx < quantityCfg->quantityConfigNR_List->list.count; quanCfgIdx++)
8275    {
8276       CU_ALLOC(quantityCfg->quantityConfigNR_List->list.array[quanCfgIdx], sizeof(QuantityConfigNR_t));
8277       if(!quantityCfg->quantityConfigNR_List->list.array[quanCfgIdx])
8278       {
8279          return RFAILED;
8280       }
8281    }
8282
8283    quanCfgIdx = 0;
8284    quantityCfgNr = quantityCfg->quantityConfigNR_List->list.array[quanCfgIdx];
8285
8286    /* Quantity Config of Reference signal */
8287    CU_ALLOC(quantityCfgNr->quantityConfigCell.ssb_FilterConfig.filterCoefficientRSRP, sizeof(FilterCoefficient_t));
8288    if(!quantityCfgNr->quantityConfigCell.ssb_FilterConfig.filterCoefficientRSRP)
8289    {
8290       return RFAILED;
8291    }
8292    *(quantityCfgNr->quantityConfigCell.ssb_FilterConfig.filterCoefficientRSRP) = FilterCoefficient_fc4;
8293
8294    CU_ALLOC(quantityCfgNr->quantityConfigCell.ssb_FilterConfig.filterCoefficientRSRQ, sizeof(FilterCoefficient_t));
8295    if(!quantityCfgNr->quantityConfigCell.ssb_FilterConfig.filterCoefficientRSRQ)
8296    {
8297       return RFAILED;
8298    }
8299    *(quantityCfgNr->quantityConfigCell.ssb_FilterConfig.filterCoefficientRSRQ) = FilterCoefficient_fc4;
8300
8301    CU_ALLOC(quantityCfgNr->quantityConfigCell.ssb_FilterConfig.filterCoefficientRS_SINR, sizeof(FilterCoefficient_t));
8302    if(!quantityCfgNr->quantityConfigCell.ssb_FilterConfig.filterCoefficientRS_SINR)
8303    {
8304       return RFAILED;
8305    }
8306    *(quantityCfgNr->quantityConfigCell.ssb_FilterConfig.filterCoefficientRS_SINR) = FilterCoefficient_fc4;
8307
8308    /* Quantity Config RS index */
8309    CU_ALLOC(quantityCfgNr->quantityConfigRS_Index, sizeof(QuantityConfigRS_t));
8310    if(!quantityCfgNr->quantityConfigRS_Index)
8311    {
8312       return RFAILED;
8313    }
8314
8315    CU_ALLOC(quantityCfgNr->quantityConfigRS_Index->ssb_FilterConfig.filterCoefficientRSRP, sizeof(FilterCoefficient_t));
8316    if(!quantityCfgNr->quantityConfigRS_Index->ssb_FilterConfig.filterCoefficientRSRP)
8317    {
8318       return RFAILED;
8319    }
8320    *(quantityCfgNr->quantityConfigRS_Index->ssb_FilterConfig.filterCoefficientRSRP) = FilterCoefficient_fc4;
8321
8322    CU_ALLOC(quantityCfgNr->quantityConfigRS_Index->ssb_FilterConfig.filterCoefficientRSRQ, sizeof(FilterCoefficient_t));
8323    if(!quantityCfgNr->quantityConfigRS_Index->ssb_FilterConfig.filterCoefficientRSRQ)
8324    {
8325       return RFAILED;
8326    }
8327    *(quantityCfgNr->quantityConfigRS_Index->ssb_FilterConfig.filterCoefficientRSRQ) = FilterCoefficient_fc4;
8328
8329    CU_ALLOC(quantityCfgNr->quantityConfigRS_Index->ssb_FilterConfig.filterCoefficientRS_SINR, sizeof(FilterCoefficient_t));
8330    if(!quantityCfgNr->quantityConfigRS_Index->ssb_FilterConfig.filterCoefficientRS_SINR)
8331    {
8332       return RFAILED;
8333    }
8334    *(quantityCfgNr->quantityConfigRS_Index->ssb_FilterConfig.filterCoefficientRS_SINR) = FilterCoefficient_fc4;
8335
8336    return ROK;
8337 }
8338
8339 /*******************************************************************
8340  *
8341  * @brief Fill measurement configuration
8342  *
8343  * @details
8344  *
8345  *    Function : fillMeasConfig
8346  *
8347  *    Functionality: Fill measurement configuration
8348  *
8349  * @params[in] Measurement config
8350  * @return ROK     - success
8351  *         RFAILED - failure
8352  *
8353  * ****************************************************************/
8354 uint8_t fillMeasConfig(MeasConfigRrc_t *measConfig)
8355 {
8356    /* Measurement object to add/mod list */
8357    CU_ALLOC(measConfig->measObjectToAddModList, sizeof(MeasObjectToAddModList_t));
8358    if(!measConfig->measObjectToAddModList)
8359    {
8360       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for measurement object list in fillMeasConfig");
8361       return RFAILED;
8362    }
8363    if(fillMeasObjToAddModList(measConfig->measObjectToAddModList) != ROK)
8364    {
8365       DU_LOG("\nERROR  -->  F1AP: Failure in fillMeasObjToAddModList");
8366       return RFAILED;
8367    }
8368
8369    /* Report Config To add/mod list */
8370    CU_ALLOC(measConfig->reportConfigToAddModList, sizeof(ReportConfigToAddModList_t));
8371    if(!measConfig->reportConfigToAddModList)
8372    {
8373       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for report config list in  fillMeasConfig");
8374       return RFAILED;
8375    }
8376    if(fillReportCfgToAddModList(measConfig->reportConfigToAddModList) != ROK)
8377    {
8378       DU_LOG("\nERROR  -->  F1AP: Failure in fillReportCfgToAddModList");
8379       return RFAILED;
8380    }
8381
8382    /* Measurement Id to add/mod list */
8383    CU_ALLOC(measConfig->measIdToAddModList, sizeof(MeasIdToAddModList_t));
8384    if(!measConfig->measIdToAddModList)
8385    {
8386       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for measuerment id list in  fillMeasConfig");
8387       return RFAILED;
8388    }
8389    if(fillMeasIdToAddModList(measConfig->measIdToAddModList) != ROK)
8390    {
8391       DU_LOG("\nERROR  -->  F1AP: Failure in fillMeasIdToAddModList");
8392       return RFAILED;
8393    }
8394
8395    /* S-Measurement config */
8396    CU_ALLOC(measConfig->s_MeasureConfig, sizeof(struct MeasConfigRrc__s_MeasureConfig));
8397    if(!measConfig->s_MeasureConfig)
8398    {
8399       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for s measuerment config in  fillMeasConfig");
8400       return RFAILED;
8401    }
8402    if(fillSMeasConfig(measConfig->s_MeasureConfig) != ROK)
8403    {
8404       DU_LOG("\nERROR  -->  F1AP: Failure in fillSMeasConfig");
8405       return RFAILED;
8406    }
8407
8408    /* Qunatity Config */
8409    CU_ALLOC(measConfig->quantityConfig, sizeof(QuantityConfig_t));
8410    if(!measConfig->quantityConfig)
8411    {
8412       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for quantity config in  fillMeasConfig");
8413       return RFAILED;
8414    }
8415    if(fillQuantityConfig(measConfig->quantityConfig) != ROK)
8416    {
8417       DU_LOG("\nERROR  -->  F1AP: Failure in fillQuantityConfig");
8418       return RFAILED;
8419    }
8420
8421 return ROK;
8422 }
8423
8424 /*******************************************************************
8425  *
8426  * @brief Fill RRC reconfiguration non-critical extension IE
8427  *
8428  * @details
8429  *
8430  *    Function : fillRrcReconfigNonCriticalExt
8431  *
8432  *    Functionality: Fill RRC reconfiguration non-critical extension
8433  *
8434  * @params[in] RRC Reconfig Non-critical extension
8435  * @return ROK     - success
8436  *         RFAILED - failure
8437  *
8438  * ****************************************************************/
8439 uint8_t fillRrcReconfigNonCriticalExt(CuUeCb *ueCb, RRCReconfiguration_v1530_IEs_t *rrcRecfg, bool updateAllRbCfg)
8440 {
8441    CU_ALLOC(rrcRecfg->masterCellGroup, sizeof(OCTET_STRING_t));
8442    if(!rrcRecfg->masterCellGroup)
8443    {
8444       return RFAILED;
8445    }
8446
8447    if(fillCellGrpCfg(ueCb, rrcRecfg->masterCellGroup, updateAllRbCfg) != ROK)
8448    {
8449       return RFAILED;
8450    }
8451
8452    return ROK;
8453 }
8454
8455 /*******************************************************************
8456  *
8457  * @brief Fill RRC reconfiguration structure
8458  *
8459  * @details
8460  *
8461  *    Function : fillRrcReconfig
8462  *
8463  *    Functionality: Fill RRC reconfiguration
8464
8465  *
8466  * @params[in] UE Cb
8467  *             RRC reconfiguration structure
8468  * @return ROK     - success
8469  *         RFAILED - failure
8470  *
8471  * ****************************************************************/
8472 uint8_t fillRrcReconfig(CuUeCb *ueCb, RRCReconfiguration_t *rrcReconfig, bool updateAllRbCfg)
8473 {
8474    memset(rrcReconfig, 0, sizeof(RRCReconfiguration_t));
8475
8476    rrcReconfig->rrc_TransactionIdentifier = 1;
8477    rrcReconfig->criticalExtensions.present = RRCReconfiguration__criticalExtensions_PR_rrcReconfiguration;
8478
8479    CU_ALLOC(rrcReconfig->criticalExtensions.choice.rrcReconfiguration, sizeof(RRCReconfiguration_IEs_t));
8480    if(!rrcReconfig->criticalExtensions.choice.rrcReconfiguration)
8481    {
8482       DU_LOG("\nERROR  -->  F1AP : Memormy allocation failed for RRC reconfiguration IE in fillRrcReconfig");
8483       return RFAILED;
8484    }
8485
8486    /* Radio Bearer Configuration */
8487    CU_ALLOC(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->radioBearerConfig, sizeof(RadioBearerConfig_t));
8488    if(!rrcReconfig->criticalExtensions.choice.rrcReconfiguration->radioBearerConfig)
8489    {
8490       DU_LOG("\nERROR  -->  F1AP : Memormy allocation failed for radio bearer config in fillRrcReconfig");
8491       return RFAILED;
8492    }
8493    if(fillRadioBearerConfig(ueCb, rrcReconfig->criticalExtensions.choice.rrcReconfiguration->radioBearerConfig, updateAllRbCfg) != ROK)
8494    {
8495       DU_LOG("\nERROR  -->  F1AP : Failed to fill radio bearer config in fillRrcReconfig");
8496       return RFAILED;
8497    }
8498
8499    /* Measurement Configuration */
8500    CU_ALLOC(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->measConfig, sizeof(MeasConfigRrc_t));
8501    if(!rrcReconfig->criticalExtensions.choice.rrcReconfiguration->measConfig)
8502    {
8503       DU_LOG("\nERROR  -->  F1AP : Memormy allocation failed for Measurement config IE in fillRrcReconfig");
8504       return RFAILED;
8505    }
8506    if(fillMeasConfig(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->measConfig) != ROK)
8507    {
8508       DU_LOG("\nERROR  -->  F1AP : Failed to fill measurement config in fillRrcReconfig");
8509       return RFAILED;
8510    }
8511
8512    /* Non Critical extension */
8513    CU_ALLOC(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->nonCriticalExtension, sizeof(struct RRCReconfiguration_v1530_IEs));
8514    if(!rrcReconfig->criticalExtensions.choice.rrcReconfiguration->nonCriticalExtension)
8515    {
8516       DU_LOG("\nERROR  -->  F1AP : Memormy allocation failed for non critical extension IE in fillRrcReconfig");
8517       return RFAILED;
8518    }
8519    if(fillRrcReconfigNonCriticalExt(ueCb, rrcReconfig->criticalExtensions.choice.rrcReconfiguration->nonCriticalExtension, updateAllRbCfg) != ROK)
8520    {
8521       DU_LOG("\nERROR  -->  F1AP : Failed to fill non critical extension in fillRrcReconfig");
8522       return RFAILED;
8523    }
8524    return ROK;
8525 }
8526
8527 /*******************************************************************
8528  *
8529  * @brief Fill RRC reconfiguration Octet string
8530  *
8531  * @details
8532  *
8533  *    Function : fillRrcReconfigBuf
8534  *
8535  *    Functionality: Fill RRC reconfiguration octet string
8536
8537  *
8538  * @params[in] OCTET_STRING_t buffer
8539  * @return ROK     - success
8540  *         RFAILED - failure
8541  *
8542  * ****************************************************************/
8543 uint8_t fillRrcReconfigBuf(CuUeCb *ueCb, OCTET_STRING_t  *rrcReconfigBuf, bool updateAllRbCfg)
8544 {
8545    uint8_t          ret = RFAILED;
8546    asn_enc_rval_t   encRetVal;
8547    RRCReconfiguration_t rrcRecfg, *rrcReconfig = NULLP;
8548    rrcReconfig = &rrcRecfg;
8549
8550    while(true)
8551    {
8552       if(fillRrcReconfig(ueCb, rrcReconfig, updateAllRbCfg) != ROK)
8553       {
8554          DU_LOG( "\nERROR  -->  F1AP : Failed to fill RRC Reconfiguration in fillRrcReconfigBuf");
8555          break;
8556       }
8557
8558       /* Encode RRC Reconfiguration */
8559       xer_fprint(stdout, &asn_DEF_RRCReconfiguration, rrcReconfig);
8560       cmMemset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
8561       encBufSize = 0;
8562       encRetVal = aper_encode(&asn_DEF_RRCReconfiguration, 0, rrcReconfig, PrepFinalEncBuf, encBuf);
8563
8564       /* Encode results */
8565       if(encRetVal.encoded == ENCODE_FAIL)
8566       {
8567          DU_LOG( "\nERROR  -->  F1AP : Could not encode RRC Reconfiguration (at %s)\n",\
8568                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
8569          break;
8570       }
8571       else
8572       {
8573          DU_LOG("\nDEBUG  -->  F1AP : Created APER encoded buffer for RRC Reconfiguration\n");
8574          for(int i=0; i< encBufSize; i++)
8575          {
8576             DU_LOG("%x",encBuf[i]);
8577          }
8578       }
8579
8580       rrcReconfigBuf->size = encBufSize;
8581       CU_ALLOC(rrcReconfigBuf->buf, rrcReconfigBuf->size);
8582       if(!rrcReconfigBuf->buf)
8583       {
8584          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in fillRrcReconfigBuf");
8585          break;
8586       }
8587       memcpy(rrcReconfigBuf->buf, encBuf, rrcReconfigBuf->size);
8588       ret = ROK;
8589       break;
8590    }
8591
8592    freeRrcReconfig(rrcReconfig);
8593    return ret;
8594 }
8595
8596 /*******************************************************************
8597  *
8598  * @brief Fill HO preparation information Octet string
8599  *
8600  * @details
8601  *
8602  *    Function : fillHOPreparationInfoBuf
8603  *
8604  *    Functionality: Fill HO preparation information Octet string
8605
8606  *
8607  * @params[in] HandoverPreparationInformation_t buffer
8608  * @return ROK     - success
8609  *         RFAILED - failure
8610  *
8611  * ****************************************************************/
8612 uint8_t fillHOPreparationInfoBuf(CuUeCb *ueCb, HandoverPreparationInformation_t *hoPrepInfoBuf)
8613 {
8614    uint8_t          ret = RFAILED;
8615    asn_enc_rval_t   encRetVal;
8616    HandoverPreparationInformationRrc_t hoPrepInfo;
8617    HandoverPreparationInformationRrc_IEs_t *hoPrepInfoIe;
8618
8619    while(true)
8620    {
8621
8622       hoPrepInfo.criticalExtensions.present = HandoverPreparationInformationRrc__criticalExtensions_PR_c1;
8623       CU_ALLOC(hoPrepInfo.criticalExtensions.choice.c1, sizeof(struct HandoverPreparationInformationRrc__criticalExtensions__c1));
8624       if(!hoPrepInfo.criticalExtensions.choice.c1)
8625       {
8626          DU_LOG( "\nERROR  -->  F1AP : Failed to allocate memory for c1 in fillHOPreparationInfo");
8627          break;
8628       }
8629       hoPrepInfo.criticalExtensions.choice.c1->present = \
8630          HandoverPreparationInformationRrc__criticalExtensions__c1_PR_handoverPreparationInformation;
8631
8632       CU_ALLOC(hoPrepInfo.criticalExtensions.choice.c1->choice.handoverPreparationInformation , \
8633          sizeof(HandoverPreparationInformationRrc_IEs_t));
8634       if(!hoPrepInfo.criticalExtensions.choice.c1->choice.handoverPreparationInformation)
8635       {
8636          DU_LOG( "\nERROR  -->  F1AP : Failed to allocate memory for handover preparation information IE in fillHOPreparationInfo");
8637          break;
8638       }
8639       hoPrepInfoIe = hoPrepInfo.criticalExtensions.choice.c1->choice.handoverPreparationInformation;
8640
8641       /* Fill UE Capability RAT container list */
8642       ret = fillUeCapRatContList(&hoPrepInfoIe->ue_CapabilityRAT_List);
8643       if(ret != ROK)
8644       {
8645          DU_LOG( "\nERROR  -->  F1AP : Failed to fill UE Capability RAT container list");
8646          break;
8647       }
8648
8649       /* Fill Source config */
8650       hoPrepInfoIe->sourceConfig = NULLP;
8651       CU_ALLOC(hoPrepInfoIe->sourceConfig, sizeof(AS_Config_t));
8652       if(!hoPrepInfoIe->sourceConfig)
8653       {
8654          DU_LOG( "\nERROR  -->  F1AP : Failed to allocate memory for source config in fillHOPreparationInfo");
8655          return RFAILED;
8656       }
8657       ret = fillRrcReconfigBuf(ueCb, &hoPrepInfoIe->sourceConfig->rrcReconfiguration, true);
8658
8659       if(ret != ROK)
8660       {
8661          DU_LOG( "\nERROR  -->  F1AP : Failed to fill Rrc reconfiguration buffer");
8662          return RFAILED;
8663       }
8664
8665       hoPrepInfoIe->rrm_Config = NULLP;
8666       hoPrepInfoIe->as_Context = NULLP;
8667       hoPrepInfoIe->nonCriticalExtension = NULLP;
8668
8669       /* encode UE Capability RAT Container List into duToCuRrcContainer */
8670       xer_fprint(stdout, &asn_DEF_HandoverPreparationInformationRrc, &hoPrepInfo);
8671       cmMemset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
8672       encBufSize = 0;
8673       encRetVal = aper_encode(&asn_DEF_HandoverPreparationInformationRrc, 0, \
8674             &hoPrepInfo, PrepFinalEncBuf, encBuf);
8675
8676       /* Encode results */
8677       if(encRetVal.encoded == ENCODE_FAIL)
8678       {
8679          DU_LOG( "\nERROR  -->  F1AP : Could not encode UE Capability RAT Container (at %s)\n",\
8680                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
8681          break;
8682       }
8683       else
8684       {
8685          DU_LOG("\nDEBUG  -->  F1AP : Created APER encodedbuffer for UE Capability RAT Container\n");
8686          for(int i=0; i< encBufSize; i++)
8687          {
8688             DU_LOG("%x",encBuf[i]);
8689          }
8690       }
8691
8692       hoPrepInfoBuf->size = encBufSize;
8693       CU_ALLOC(hoPrepInfoBuf->buf, hoPrepInfoBuf->size);
8694       if(!hoPrepInfoBuf->buf)
8695       {
8696          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in fillUeCapabilityContainer");
8697          break;
8698       }
8699       memcpy(hoPrepInfoBuf->buf, encBuf, hoPrepInfoBuf->size);
8700       ret = ROK;
8701       break;
8702    }
8703    freeHOPreparationInfo(&hoPrepInfo);
8704    return ret;
8705 }
8706
8707 /*******************************************************************
8708  *
8709  * @brief Fills CuToDuContainer
8710  *
8711  * @details
8712  *
8713  *    Function : fillCuToDuContainer
8714  *
8715  *    Functionality: Fills CuToDuContainer
8716  *
8717  * @params[in] pointer to CUtoDURRCInformation_t
8718  *
8719  * @return ROK     - success
8720  *         RFAILED - failure
8721  *
8722  ******************************************************************/
8723
8724 uint8_t fillCuToDuContainer(CuUeCb *ueCb, CUtoDURRCInformation_t *rrcMsg)
8725 {
8726    uint8_t elementCnt = 0;
8727    uint8_t ret = ROK;
8728    uint8_t idx, idx2, rrcBufLen;
8729
8730    /* UE Capabulity RAT Container List */
8731    CU_ALLOC(rrcMsg->uE_CapabilityRAT_ContainerList, sizeof(UE_CapabilityRAT_ContainerList_t));
8732    if(!rrcMsg->uE_CapabilityRAT_ContainerList)
8733    {
8734       DU_LOG("\nERROR  -->  F1AP : Memory allocation for UE capability RAT container list failed");
8735       return RFAILED;
8736    }
8737    ret = fillUeCapRatContListBuf(rrcMsg->uE_CapabilityRAT_ContainerList);
8738
8739    CU_ALLOC(rrcMsg->measConfig, sizeof(MeasConfig_t));
8740    if(!rrcMsg->measConfig)
8741    {
8742       DU_LOG("\nERROR  -->  F1AP : Memory allocation for measurement configuration failed");
8743       return RFAILED;
8744    }
8745    ret = fillMeasTimingConfigBuf(rrcMsg->measConfig);
8746
8747    if(ueCb->state == UE_HANDOVER_IN_PROGRESS)
8748    {
8749       /* IE extensions */
8750       CU_ALLOC(rrcMsg->iE_Extensions, sizeof(ProtocolExtensionContainer_4624P16_t));
8751       if(rrcMsg->iE_Extensions)
8752       {
8753          elementCnt = 1;
8754          rrcMsg->iE_Extensions->list.count = elementCnt;
8755          rrcMsg->iE_Extensions->list.size = elementCnt * sizeof(CUtoDURRCInformation_ExtIEs_t *);
8756
8757          /* Initialize the CUtoDURRCInformation_ExtIEs */
8758          CU_ALLOC(rrcMsg->iE_Extensions->list.array, rrcMsg->iE_Extensions->list.size);
8759
8760          if(rrcMsg->iE_Extensions->list.array == NULLP)
8761          {
8762             DU_LOG("\nERROR  -->  F1AP : Memory allocation for CUtoDURRCInformation_ExtIEs failed");
8763             ret = RFAILED;
8764          }
8765
8766          for(idx=0; idx<elementCnt; idx++)
8767          {
8768             CU_ALLOC(rrcMsg->iE_Extensions->list.array[idx], sizeof(CUtoDURRCInformation_ExtIEs_t));
8769             if(rrcMsg->iE_Extensions->list.array[idx] == NULLP)
8770             {
8771                DU_LOG("\nERROR  -->  F1AP : Memory allocation for array elements failed");
8772                ret = RFAILED;
8773             }
8774          }
8775
8776          idx = 0;
8777 #if 0
8778          /* Cell Group Configuration */
8779          rrcMsg->iE_Extensions->list.array[idx]->id = ProtocolIE_ID_id_CellGroupConfig;
8780          rrcMsg->iE_Extensions->list.array[idx]->criticality = Criticality_ignore;
8781          rrcMsg->iE_Extensions->list.array[idx]->extensionValue.present  =\
8782                                                                           CUtoDURRCInformation_ExtIEs__extensionValue_PR_CellGroupConfig;
8783          ret = fillCellGrpCfg(ueCb, &rrcMsg->iE_Extensions->list.array[idx]->extensionValue.choice.CellGroupConfig, true);
8784          idx++;
8785 #endif
8786          /* Handover Preparation Information */
8787          rrcMsg->iE_Extensions->list.array[idx]->id = ProtocolIE_ID_id_HandoverPreparationInformation;
8788          rrcMsg->iE_Extensions->list.array[idx]->criticality = Criticality_ignore;
8789          rrcMsg->iE_Extensions->list.array[idx]->extensionValue.present  = \
8790                                                                            CUtoDURRCInformation_ExtIEs__extensionValue_PR_HandoverPreparationInformation;
8791          ret = fillHOPreparationInfoBuf(ueCb, &rrcMsg->iE_Extensions->list.array[idx]->extensionValue.choice.HandoverPreparationInformation);
8792       }
8793    }
8794    return ret;
8795 }
8796
8797 /*******************************************************************
8798  *
8799  * @brief Free CuToDuContainer
8800  *
8801  * @details
8802  *
8803  *    Function : FreeCuToDuInfo
8804  *
8805  *    Functionality: Free CuToDuContainer
8806  *
8807  * @params[in] pointer to CUtoDURRCInformation_t
8808  *
8809  * @return ROK     - success
8810  *         RFAILED - failure
8811  *
8812  ******************************************************************/
8813
8814 void FreeCuToDuInfo(CUtoDURRCInformation_t *rrcMsg)
8815 {
8816    uint8_t idx, idx2;
8817
8818    if(rrcMsg->uE_CapabilityRAT_ContainerList)
8819    {
8820       if(rrcMsg->uE_CapabilityRAT_ContainerList->buf)
8821          CU_FREE(rrcMsg->uE_CapabilityRAT_ContainerList->buf, rrcMsg->uE_CapabilityRAT_ContainerList->size);
8822       CU_FREE(rrcMsg->uE_CapabilityRAT_ContainerList, sizeof(UE_CapabilityRAT_ContainerList_t));
8823    }
8824    if(rrcMsg->iE_Extensions)
8825    {
8826       if(rrcMsg->iE_Extensions->list.array)
8827       {
8828          for(idx= 0; idx < rrcMsg->iE_Extensions->list.count; idx++)
8829          {
8830             if(rrcMsg->iE_Extensions->list.array[idx])
8831             {
8832                switch(rrcMsg->iE_Extensions->list.array[idx]->id)
8833                {
8834                   case ProtocolIE_ID_id_CellGroupConfig:
8835                      if(rrcMsg->iE_Extensions->list.array[idx]->extensionValue.choice.CellGroupConfig.buf != NULLP)
8836                      {
8837                         CU_FREE(rrcMsg->iE_Extensions->list.array[idx]->extensionValue.choice.CellGroupConfig.buf,\
8838                               rrcMsg->iE_Extensions->list.array[idx]->extensionValue.choice.CellGroupConfig.size);
8839
8840                      }
8841                      break;
8842                   default:
8843                      DU_LOG("\nERROR  -->  F1AP : Invalid Event type %ld at FreeCuToDuInfo()", \
8844                            rrcMsg->iE_Extensions->list.array[idx]->id);
8845                      break;
8846                }
8847             }
8848             break;
8849          }
8850          for(idx2 = 0; idx2 < idx; idx2++)
8851          {
8852             CU_FREE(rrcMsg->iE_Extensions->list.array[idx2], sizeof(CUtoDURRCInformation_ExtIEs_t));
8853          }
8854          CU_FREE(rrcMsg->iE_Extensions->list.array, rrcMsg->iE_Extensions->list.size);
8855
8856       }
8857
8858       CU_FREE(rrcMsg->iE_Extensions, sizeof(ProtocolExtensionContainer_4624P16_t));
8859    }
8860 }
8861 /*******************************************************************
8862  *
8863  * @brief Builds and sends the UE Setup Request
8864  *
8865  * @details
8866  *
8867  *    Function : BuildAndSendUeContextSetupReq
8868  *
8869  *    Functionality: Constructs the UE Setup Request and sends
8870  *                   it to the CU through SCTP.
8871  *
8872  * @params[in]
8873  *
8874  * @return ROK     - success
8875  *         RFAILED - failure
8876  *
8877  * ****************************************************************/
8878 uint8_t BuildAndSendUeContextSetupReq(uint32_t duId, CuUeCb *ueCb, uint16_t rrcContLen, uint8_t *rrcContainer)
8879 {
8880    uint8_t   Nrcgiret, SplCellListret, SrbSetupret;
8881    uint8_t   ret= RFAILED, ret1;
8882    uint8_t   elementCnt;
8883    uint8_t   idx, idx1, bufLen, duIdx;
8884    uint32_t  spCellId;
8885    DuDb      *targetDuDb = NULLP;
8886    F1AP_PDU_t           *f1apMsg = NULLP;
8887    UEContextSetupRequest_t *ueSetReq = NULLP;
8888    asn_enc_rval_t encRetVal;        /* Encoder return value */
8889    memset(&encRetVal, 0, sizeof(asn_enc_rval_t));
8890
8891    while(true)
8892    {
8893       DU_LOG("\nINFO  -->  F1AP : Building UE Context Setup Request\n");
8894
8895       CU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
8896       if(f1apMsg == NULLP)
8897       {
8898          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
8899          break;
8900       }
8901
8902       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
8903       CU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
8904       if(f1apMsg->choice.initiatingMessage == NULLP)
8905       {
8906          DU_LOG("\nERROR  -->  F1AP : Memory allocation for     F1AP-PDU failed");
8907          break;
8908       }
8909
8910       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_UEContextSetup;
8911       f1apMsg->choice.initiatingMessage->criticality = Criticality_reject;
8912       f1apMsg->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_UEContextSetupRequest;
8913
8914       ueSetReq = &f1apMsg->choice.initiatingMessage->value.choice.UEContextSetupRequest;
8915
8916       if(ueCb->state == UE_HANDOVER_IN_PROGRESS)
8917          elementCnt = 7;
8918       else
8919          elementCnt = 12;
8920       ueSetReq->protocolIEs.list.count = elementCnt;
8921       ueSetReq->protocolIEs.list.size = elementCnt * sizeof(UEContextSetupRequestIEs_t *);
8922
8923       /* Initialize the UESetup members */
8924       CU_ALLOC(ueSetReq->protocolIEs.list.array,ueSetReq->protocolIEs.list.size);
8925
8926       if(ueSetReq->protocolIEs.list.array == NULLP)
8927       {
8928          DU_LOG("\nERROR  -->  F1AP : Memory allocation for UE Context SetupRequest failed");
8929          break;
8930       }
8931
8932       for(idx1=0; idx1<elementCnt; idx1++)
8933       {
8934          CU_ALLOC(ueSetReq->protocolIEs.list.array[idx1],sizeof(UEContextSetupRequestIEs_t));
8935          if(ueSetReq->protocolIEs.list.array[idx1] == NULLP)
8936          {
8937             break;
8938          }
8939       }
8940
8941       idx = 0;
8942
8943       /*GNB CU UE F1AP ID*/
8944       ueSetReq->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
8945       ueSetReq->protocolIEs.list.array[idx]->criticality        =       Criticality_reject;
8946       ueSetReq->protocolIEs.list.array[idx]->value.present = UEContextSetupRequestIEs__value_PR_GNB_CU_UE_F1AP_ID;
8947       ueSetReq->protocolIEs.list.array[idx]->value.choice.GNB_CU_UE_F1AP_ID = ueCb->gnbCuUeF1apId;
8948
8949       if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
8950       {
8951          /*GNB DU UE F1AP ID*/
8952          idx++;
8953          ueSetReq->protocolIEs.list.array[idx]->id      = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
8954          ueSetReq->protocolIEs.list.array[idx]->criticality     =       Criticality_ignore;
8955          ueSetReq->protocolIEs.list.array[idx]->value.present = UEContextSetupRequestIEs__value_PR_GNB_DU_UE_F1AP_ID;
8956          ueSetReq->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID = ueCb->gnbDuUeF1apId;
8957       }
8958
8959       /*Special Cell ID*/
8960       idx++;
8961       ueSetReq->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_SpCell_ID;
8962       ueSetReq->protocolIEs.list.array[idx]->criticality        =       Criticality_reject;
8963       ueSetReq->protocolIEs.list.array[idx]->value.present = UEContextSetupRequestIEs__value_PR_NRCGI;
8964       if(ueCb->state == UE_HANDOVER_IN_PROGRESS)
8965       {
8966          /* Spec 38.473 Sec 9.2.2.1 : For handover case, this IE shall be considered as target cell. */
8967          SEARCH_DU_DB(duIdx, ueCb->hoInfo.targetDuId, targetDuDb);
8968          /* Since we are supporting only one cell per DU, accessing 0th index to
8969           * get target cell info */
8970          spCellId = targetDuDb->cellCb[0].nrCellId;
8971       }
8972       else
8973          spCellId = ueCb->cellCb->nrCellId;
8974       Nrcgiret = BuildNrcgi(&ueSetReq->protocolIEs.list.array[idx]->value.choice.NRCGI, spCellId);
8975       if(Nrcgiret != ROK)
8976       {
8977          break;
8978       }
8979
8980       /*Served Cell Index*/
8981       idx++;
8982       ueSetReq->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_ServCellIndex;
8983       ueSetReq->protocolIEs.list.array[idx]->criticality        =       Criticality_reject;
8984       ueSetReq->protocolIEs.list.array[idx]->value.present = UEContextSetupRequestIEs__value_PR_ServCellIndex;
8985       ueSetReq->protocolIEs.list.array[idx]->value.choice.ServCellIndex = CELL_INDEX;
8986
8987       if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
8988       {
8989          /*CellULConfigured*/
8990          idx++;
8991          ueSetReq->protocolIEs.list.array[idx]->id      = ProtocolIE_ID_id_SpCellULConfigured;
8992          ueSetReq->protocolIEs.list.array[idx]->criticality     =       Criticality_ignore;
8993          ueSetReq->protocolIEs.list.array[idx]->value.present = UEContextSetupRequestIEs__value_PR_CellULConfigured;
8994          ueSetReq->protocolIEs.list.array[idx]->value.choice.CellULConfigured = CellULConfigured_none;
8995       }
8996
8997       /*CUtoDURRCContainer*/
8998       idx++;
8999       ueSetReq->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_CUtoDURRCInformation;
9000       ueSetReq->protocolIEs.list.array[idx]->criticality        =       Criticality_reject;
9001       ueSetReq->protocolIEs.list.array[idx]->value.present = UEContextSetupRequestIEs__value_PR_CUtoDURRCInformation;
9002       if(fillCuToDuContainer(ueCb, &ueSetReq->protocolIEs.list.array[idx]->value.choice.CUtoDURRCInformation))
9003       {
9004          break;
9005       }
9006
9007       if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
9008       {
9009          /*Special Cells to be SetupList*/
9010          idx++;
9011          ueSetReq->protocolIEs.list.array[idx]->id      = ProtocolIE_ID_id_SCell_ToBeSetup_List;
9012          ueSetReq->protocolIEs.list.array[idx]->criticality     =       Criticality_ignore;
9013          ueSetReq->protocolIEs.list.array[idx]->value.present = UEContextSetupRequestIEs__value_PR_SCell_ToBeSetup_List;
9014          SplCellListret = BuildSplCellList(ueCb, &ueSetReq->protocolIEs.list.array[idx]->value.choice.SCell_ToBeSetup_List);
9015          if(SplCellListret != ROK)
9016          {
9017             break;
9018          }
9019       }
9020
9021       /*SRBs To Be Setup List*/
9022       idx++;
9023       ueSetReq->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_SRBs_ToBeSetup_List;
9024       ueSetReq->protocolIEs.list.array[idx]->criticality        =       Criticality_reject;
9025       ueSetReq->protocolIEs.list.array[idx]->value.present = UEContextSetupRequestIEs__value_PR_SRBs_ToBeSetup_List;
9026       SrbSetupret = BuildSRBSetup(ueCb, &ueSetReq->protocolIEs.list.array[idx]->value.choice.SRBs_ToBeSetup_List);
9027       if(SrbSetupret != ROK)
9028       {
9029          break;
9030       }
9031
9032       /*DRBs to Be Setup List*/
9033       idx++;
9034       ueSetReq->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_DRBs_ToBeSetup_List;
9035       ueSetReq->protocolIEs.list.array[idx]->criticality        =       Criticality_reject;
9036       ueSetReq->protocolIEs.list.array[idx]->value.present = UEContextSetupRequestIEs__value_PR_DRBs_ToBeSetup_List;
9037       ret1 = BuildDRBSetup(ueCb, &ueSetReq->protocolIEs.list.array[idx]->value.choice.DRBs_ToBeSetup_List);
9038       if(ret1 != ROK)
9039       {
9040          break;
9041       }
9042
9043       if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
9044       {
9045          /* RRC Container for security mode */
9046          idx++;
9047          ueSetReq->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_RRCContainer;
9048          ueSetReq->protocolIEs.list.array[idx]->criticality = Criticality_reject;
9049          ueSetReq->protocolIEs.list.array[idx]->value.present = UEContextSetupRequestIEs__value_PR_RRCContainer;
9050
9051          char secModeBuf[9]={0x00, 0x02, 0x22, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00};
9052          bufLen =9;
9053          ueSetReq->protocolIEs.list.array[idx]->value.choice.RRCContainer.size = bufLen;
9054          CU_ALLOC(ueSetReq->protocolIEs.list.array[idx]->value.choice.RRCContainer.buf,
9055                ueSetReq->protocolIEs.list.array[idx]->value.choice.RRCContainer.size);
9056          if(!ueSetReq->protocolIEs.list.array[idx]->value.choice.RRCContainer.buf)
9057          {
9058             DU_LOG("\nERROR  -->  F1AP : Memory allocation for BuildAndSendUeContextSetupReq failed");
9059             break;
9060          }
9061          memset(ueSetReq->protocolIEs.list.array[idx]->value.choice.RRCContainer.buf, 0, bufLen);
9062          memcpy(ueSetReq->protocolIEs.list.array[idx]->value.choice.RRCContainer.buf, secModeBuf, bufLen);
9063
9064          /* RRC delivery status request */
9065          idx++;
9066          ueSetReq->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_RRCDeliveryStatusRequest;
9067          ueSetReq->protocolIEs.list.array[idx]->criticality = Criticality_ignore;
9068          ueSetReq->protocolIEs.list.array[idx]->value.present = UEContextSetupRequestIEs__value_PR_RRCDeliveryStatusRequest;
9069          ueSetReq->protocolIEs.list.array[idx]->value.choice.RRCDeliveryStatusRequest = RRCDeliveryStatusRequest_true;
9070       }
9071
9072       /* GNB-DU UE Aggregate Maximum Bit Rate hardcoded as in reference logs */
9073       idx++;
9074       ueSetReq->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_GNB_DU_UE_AMBR_UL;
9075       ueSetReq->protocolIEs.list.array[idx]->criticality = Criticality_ignore;
9076       ueSetReq->protocolIEs.list.array[idx]->value.present = UEContextSetupRequestIEs__value_PR_BitRate;
9077
9078       char bitRateBuf[4]= {0x3B, 0x37, 0xF4, 0xCD};
9079       bufLen = 4;
9080       ueSetReq->protocolIEs.list.array[idx]->value.choice.BitRate.size = bufLen;
9081       CU_ALLOC(ueSetReq->protocolIEs.list.array[idx]->value.choice.BitRate.buf,\
9082             ueSetReq->protocolIEs.list.array[idx]->value.choice.BitRate.size);
9083       if(!ueSetReq->protocolIEs.list.array[idx]->value.choice.BitRate.buf)
9084       {
9085          DU_LOG("\nERROR  -->  F1AP : Failed to allocate memory for Bit Rate in BuildAndSendUeContextSetupReq()");
9086          break;
9087       }
9088       memset(ueSetReq->protocolIEs.list.array[idx]->value.choice.BitRate.buf, 0, bufLen);
9089       memcpy(ueSetReq->protocolIEs.list.array[idx]->value.choice.BitRate.buf, bitRateBuf, bufLen);
9090
9091       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
9092
9093       /* Encode the F1SetupRequest type as APER */
9094       memset(encBuf, 0, ENC_BUF_MAX_LEN);
9095       encBufSize = 0;
9096       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
9097
9098       /* Encode results */
9099       if(encRetVal.encoded == ENCODE_FAIL)
9100       {
9101          DU_LOG( "\nERROR  -->  F1AP : Could not encode UE Context Setup Request structure (at %s)\n",\
9102                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
9103          break;
9104       }
9105       else
9106       {
9107          DU_LOG("\nDEBUG  -->  F1AP : Created APER encodedbuffer for UE Context Setup Request\n");
9108          for(int i=0; i< encBufSize; i++)
9109          {
9110             DU_LOG("%x",encBuf[i]);
9111          }
9112       }
9113
9114       /* Sending  msg  */
9115       if(SendF1APMsg(CU_APP_MEM_REG, CU_POOL, duId)     !=      ROK)
9116       {
9117          DU_LOG("\nERROR  -->  F1AP : Sending UE Context Setup Request Failed");
9118          break;
9119       }
9120       ret = ROK;
9121       break;
9122    }
9123    FreeUeContextSetupReq(f1apMsg);
9124
9125    return ret;
9126 }/* End of BuildAndSendUeContextSetupReq*/
9127
9128 /**********************************************************************
9129  * @brief Function to extractTeId received in UE context setup Response
9130  *
9131  * @details
9132  *
9133  *    Function : extractTeId
9134  *
9135  *    Functionality:
9136  *         - Function to extract TeId
9137  *
9138  * @params[in]
9139  * @return ROK     - success
9140  *         RFAILED - failure
9141  *
9142  **********************************************************************/
9143 uint8_t extractTeId(DLUPTNLInformation_ToBeSetup_List_t *dlTnlInfo)
9144 {
9145    uint8_t arrIdx = 0;
9146    uint32_t teId = 0;
9147    GTPTunnel_t *gtpDl = NULLP;
9148
9149    for(arrIdx =0; arrIdx < dlTnlInfo->list.count; arrIdx++)
9150    {
9151       if(dlTnlInfo->list.array[arrIdx]->dLUPTNLInformation.present == UPTransportLayerInformation_PR_gTPTunnel)
9152       {
9153          if(dlTnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel != NULLP)
9154          {
9155             gtpDl = dlTnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel;
9156             if(gtpDl->gTP_TEID.size > 0)
9157             {
9158                teIdStringToInt(gtpDl->gTP_TEID.buf, &teId);
9159             }
9160             else
9161                DU_LOG("\nERROR  -->  EGTP: No TeId received");
9162             return(teId);
9163          }
9164       }
9165    }
9166    return teId;
9167 }
9168
9169 /****************************************************************
9170  * @brief Function to add Drb tunnels
9171  *
9172  * @details
9173  *
9174  *    Function : addDrbTunnels
9175  *
9176  *    Functionality:
9177  *         - Function to add Drb tunnels
9178  *
9179  * @params[in]
9180  * @return ROK     - success
9181  *         RFAILED - failure
9182  *
9183  * ****************************************************************/
9184 uint8_t addDrbTunnels(uint8_t teId)
9185 {
9186    uint8_t ret = ROK;
9187    EgtpTnlEvt tnlEvt;
9188
9189    if(teId > MAX_TEID || teId < MIN_TEID)
9190    {
9191       DU_LOG("\nERROR  -->  EGTP : TEID(%x) OUT Of Range",teId);
9192    }
9193    memset(&tnlEvt, 0, sizeof(EgtpTnlEvt));
9194    tnlEvt.action = EGTP_TNL_MGMT_ADD;
9195    tnlEvt.lclTeid = teId;
9196    tnlEvt.remTeid = teId;
9197    ret = cuEgtpTnlMgmtReq(tnlEvt);
9198    if(ret != ROK)
9199    {
9200       DU_LOG("\nERROR  -->  EGTP : Tunnel management request failed for teId %x", teId);
9201    }
9202    return ROK;
9203 }
9204
9205 /****************************************************************
9206  * @brief Function to process Drb Setup List
9207  *
9208  * @details
9209  *
9210  *    Function : procDrbSetupList
9211  *
9212  *    Functionality:
9213  *         - Function to process DRB Setup List
9214  *
9215  * @params[in]
9216  * @return ROK     - success
9217  *         RFAILED - failure
9218  *
9219  * ****************************************************************/
9220 uint8_t procDrbSetupList(DRBs_Setup_List_t *drbSetupList)
9221 {
9222    uint8_t arrIdx = 0;
9223    uint32_t teId = 0;
9224    DRBs_Setup_ItemIEs_t *drbItemIe = NULLP;
9225
9226    if(drbSetupList != NULLP)
9227    {
9228       for(arrIdx = 0; arrIdx < drbSetupList->list.count; arrIdx++)
9229       {
9230          drbItemIe = ((DRBs_Setup_ItemIEs_t *)drbSetupList->list.array[arrIdx]);
9231          if(drbItemIe->value.present == DRBs_Setup_ItemIEs__value_PR_DRBs_Setup_Item)
9232          {
9233             /* extracting teId */
9234             teId  = extractTeId(&drbItemIe->value.choice.DRBs_Setup_Item.dLUPTNLInformation_ToBeSetup_List);
9235             if(teId > 0)
9236             {
9237               if(addDrbTunnels(teId)== ROK)
9238               {
9239                 DU_LOG("\nDEBUG  --> EGTP: Tunnel Added for TeId %d", teId);
9240               }
9241             }
9242             else
9243                return RFAILED;
9244          }
9245       }
9246    }
9247    return ROK;
9248 }
9249
9250 /****************************************************************
9251  * @brief Function to process Ue Context Setup Response
9252  *
9253  * @details
9254  *
9255  *    Function : procUeContextSetupResponse
9256  *
9257  *    Functionality:
9258  *         - Function to process Ue Context Setup Response
9259  *
9260  * @params[in]
9261  * @return ROK     - success
9262  *         RFAILED - failure
9263  *
9264  * ****************************************************************/
9265 uint8_t procUeContextSetupResponse(uint32_t duId, F1AP_PDU_t *f1apMsg)
9266 {
9267    uint8_t duIdx=0, idx, duUeF1apId;
9268    DuDb *duDb;
9269    CuUeCb *ueCb;
9270    UEContextSetupResponse_t *ueCtxtSetupRsp = NULLP;
9271
9272    SEARCH_DU_DB(duIdx, duId, duDb);
9273    ueCtxtSetupRsp = &f1apMsg->choice.successfulOutcome->value.choice.UEContextSetupResponse;
9274
9275    for(idx=0; idx < ueCtxtSetupRsp->protocolIEs.list.count; idx++)
9276    {
9277       switch(ueCtxtSetupRsp->protocolIEs.list.array[idx]->id)
9278       {
9279           case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
9280              {
9281                 duUeF1apId = ueCtxtSetupRsp->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID;
9282                 ueCb = &duDb->ueCb[duUeF1apId-1];
9283                 break;
9284              }
9285           case ProtocolIE_ID_id_DRBs_Setup_List:
9286              {
9287                 /* Adding Tunnels for successful DRB */
9288                 procDrbSetupList(&ueCtxtSetupRsp->protocolIEs.list.array[idx]->value.choice.DRBs_Setup_List);
9289                 break;
9290              }
9291          case ProtocolIE_ID_id_DUtoCURRCInformation:
9292              {
9293                 DU_LOG("\nINFO  -->  Received Du to Cu RRC Information ");
9294                 if((extractDuToCuRrcCont(ueCb, ueCtxtSetupRsp->protocolIEs.list.array[idx]->value.choice.\
9295                    DUtoCURRCInformation.cellGroupConfig)) != ROK)
9296                 {
9297                    DU_LOG("\nERROR  -->  F1AP: Failed to extract Du to Cu RRC Information ");
9298                    return RFAILED;
9299                 }
9300                 break;
9301              }
9302       }
9303    }
9304    ueCb->f1apMsgDb.dlRrcMsgCount++; /* keeping DL RRC Msg Count */
9305    return ROK;
9306 }
9307
9308 /****************************************************************
9309  * @brief Function to process Ul Rrc Msg received from DU
9310  *
9311  * @details
9312  *
9313  *    Function : procUlRrcMsg
9314  *
9315  *    Functionality:
9316  *         - Function to process Ul Rrc Msg received from DU
9317  *
9318  * @params[in]
9319  * @return ROK     - success
9320  *         RFAILED - failure
9321  *
9322  * ****************************************************************/
9323
9324 uint8_t procUlRrcMsg(uint32_t duId, F1AP_PDU_t *f1apMsg)
9325 {
9326    uint8_t idx, ret, srbId, rrcMsgType, duIdx=0;
9327    uint8_t cuUeF1apId, duUeF1apId;
9328    uint8_t *rrcContainer = NULLP;
9329    uint16_t rrcContLen;
9330    DuDb     *duDb;
9331    CuUeCb   *ueCb;
9332    ULRRCMessageTransfer_t *ulRrcMsg = NULLP;
9333
9334    ret = ROK;
9335    SEARCH_DU_DB(duIdx, duId, duDb);
9336    ulRrcMsg = &f1apMsg->choice.initiatingMessage->value.choice.ULRRCMessageTransfer;
9337
9338    for(idx=0; idx < ulRrcMsg->protocolIEs.list.count; idx++)
9339    {
9340       switch(ulRrcMsg->protocolIEs.list.array[idx]->id)
9341       {
9342          case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
9343             {
9344                cuUeF1apId = ulRrcMsg->protocolIEs.list.array[idx]->value.choice.GNB_CU_UE_F1AP_ID;
9345                break;
9346             }
9347          case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
9348             {
9349                duUeF1apId = ulRrcMsg->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID;
9350                break;
9351             }
9352          case ProtocolIE_ID_id_SRBID:
9353             srbId = ulRrcMsg->protocolIEs.list.array[idx]->value.choice.SRBID;
9354             break;
9355
9356          case ProtocolIE_ID_id_RRCContainer:
9357             {
9358                rrcContLen = ulRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.size;
9359                CU_ALLOC(rrcContainer, rrcContLen);
9360                if(!rrcContainer)
9361                {
9362                   DU_LOG("\nERROR  -->  F1AP : Failed to allocated memory in procUlRrcMsg");
9363                   return RFAILED;
9364                }
9365                memcpy(rrcContainer, ulRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.buf, rrcContLen);
9366                break;
9367             }
9368
9369          default:
9370             DU_LOG("\nERROR  -->  F1AP : Invalid Event %ld", ulRrcMsg->protocolIEs.list.array[idx]->id);
9371             break;
9372       }
9373    }
9374
9375    if(srbId == 1)
9376    {
9377       ueCb = &duDb->ueCb[duUeF1apId-1];
9378       ueCb->f1apMsgDb.dlRrcMsgCount++;
9379       rrcMsgType = setDlRRCMsgType(ueCb);
9380       if(rrcMsgType == REGISTRATION_ACCEPT)
9381       {
9382          DU_LOG("\nINFO  -->  F1AP: Sending DL RRC MSG for RRC Registration Accept");
9383          ret = BuildAndSendDLRRCMessageTransfer(duId, ueCb, srbId, rrcMsgType);
9384       }
9385       if(rrcMsgType == UE_CONTEXT_SETUP_REQ)
9386       {
9387          DU_LOG("\nINFO  -->  F1AP: Sending Ue Context Setup Req");
9388          ret = BuildAndSendUeContextSetupReq(duId, ueCb, rrcContLen, rrcContainer);
9389       }
9390       if(rrcMsgType == SECURITY_MODE_COMPLETE)
9391       {
9392          /* To trigger the DL RRC Msg for RRC Reconfig */
9393          ueCb->f1apMsgDb.dlRrcMsgCount++;
9394          rrcMsgType = setDlRRCMsgType(ueCb);
9395          if(rrcMsgType == RRC_RECONFIG)
9396          {
9397             DU_LOG("\nINFO  -->  F1AP: Sending DL RRC MSG for RRC Reconfig");
9398             BuildAndSendDLRRCMessageTransfer(duId, ueCb, srbId, rrcMsgType);
9399          }
9400       }
9401       if(rrcMsgType == RRC_RECONFIG_COMPLETE)
9402       {
9403          ueCb->state = UE_ACTIVE;
9404          ueCb->f1apMsgDb.dlRrcMsgCount++;
9405          rrcMsgType = setDlRRCMsgType(ueCb);
9406          if(rrcMsgType == UE_CONTEXT_MOD_REQ)
9407          {
9408             DU_LOG("\nINFO  -->  F1AP: Sending UE Context Modification Request");
9409             BuildAndSendUeContextModificationReq(duId, ueCb, RRC_RECONFIG_COMPLETE_IND);
9410          }
9411       }
9412    }
9413    return ret;
9414 }
9415
9416 /****************************************************************
9417  * @brief Build And Send F1ResetAck
9418  *
9419  * @details
9420  *
9421  *    Function : FreeF1ResetAck
9422  *
9423  *    Functionality:
9424  *         - Build And Send  F1ResetRSP
9425  *
9426  *  @params[in]
9427  * @return ROK     - success
9428  *         RFAILED - failure
9429  *
9430  * ****************************************************************/
9431 void FreeF1ResetAck(F1AP_PDU_t *f1apMsg)
9432 {
9433    uint8_t idx;
9434    ResetAcknowledge_t *f1ResetAck;
9435
9436    if(f1apMsg)
9437    {
9438       if(f1apMsg->choice.successfulOutcome)
9439       {
9440          f1ResetAck= &f1apMsg->choice.successfulOutcome->value.choice.ResetAcknowledge;
9441
9442          if(f1ResetAck->protocolIEs.list.array)
9443          {
9444             for(idx=0; idx<f1ResetAck->protocolIEs.list.count ; idx++)
9445             {
9446                if(f1ResetAck->protocolIEs.list.array[idx])
9447                {
9448                   CU_FREE(f1ResetAck->protocolIEs.list.array[idx], sizeof(ResetAcknowledgeIEs_t));
9449                }
9450             }
9451             CU_FREE(f1ResetAck->protocolIEs.list.array, f1ResetAck->protocolIEs.list.size );
9452          }
9453          CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
9454       }
9455       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
9456    }
9457 }
9458
9459 /****************************************************************
9460  * @brief Build And Send F1ResetAck
9461  *
9462  * @details
9463  *
9464  *    Function : BuildAndSendF1ResetAck
9465  *
9466  *    Functionality:
9467  *         - Build And Send  F1ResetRSP
9468  *
9469  *  @params[in]
9470  * @return ROK     - success
9471  *         RFAILED - failure
9472  *
9473  * ****************************************************************/
9474
9475 uint8_t BuildAndSendF1ResetAck()
9476 {
9477    uint8_t                idx = 0;
9478    uint8_t                elementCnt = 0;
9479    uint8_t                ret = RFAILED;
9480    F1AP_PDU_t             *f1apMsg = NULL;
9481    ResetAcknowledge_t     *f1ResetAck = NULLP;
9482    asn_enc_rval_t         encRetVal;
9483    DU_LOG("\nINFO  -->  F1AP : Building F1 Reset Acknowledgment \n");
9484
9485    do{
9486       /* Allocate the memory for F1ResetRequest_t */
9487       CU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
9488       if(f1apMsg == NULLP)
9489       {
9490          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
9491          break;
9492       }
9493
9494       f1apMsg->present =  F1AP_PDU_PR_successfulOutcome;
9495
9496       CU_ALLOC(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
9497       if(f1apMsg->choice.successfulOutcome == NULLP)
9498       {
9499          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
9500          break;
9501       }
9502
9503       f1apMsg->choice.successfulOutcome->procedureCode = ProcedureCode_id_Reset;
9504       f1apMsg->choice.successfulOutcome->criticality   = Criticality_reject;
9505       f1apMsg->choice.successfulOutcome->value.present = SuccessfulOutcome__value_PR_ResetAcknowledge;
9506       f1ResetAck = &f1apMsg->choice.successfulOutcome->value.choice.ResetAcknowledge;
9507
9508       elementCnt = 1;
9509
9510       f1ResetAck->protocolIEs.list.count = elementCnt;
9511       f1ResetAck->protocolIEs.list.size = elementCnt*sizeof(ResetAcknowledgeIEs_t *);
9512
9513       CU_ALLOC(f1ResetAck->protocolIEs.list.array, f1ResetAck->protocolIEs.list.size );
9514       if(f1ResetAck->protocolIEs.list.array == NULLP)
9515       {
9516          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1ResetAckIEs failed");
9517          break;
9518       }
9519
9520       for(idx=0; idx<elementCnt; idx++)
9521       {
9522          CU_ALLOC(f1ResetAck->protocolIEs.list.array[idx], sizeof(ResetAcknowledgeIEs_t));
9523          if(f1ResetAck->protocolIEs.list.array[idx] == NULLP)
9524          {
9525             break;
9526          }
9527       }
9528       /*TransactionID*/
9529       idx = 0;
9530       f1ResetAck->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_TransactionID;
9531       f1ResetAck->protocolIEs.list.array[idx]->criticality = Criticality_reject;
9532       f1ResetAck->protocolIEs.list.array[idx]->value.present = ResetAcknowledgeIEs__value_PR_TransactionID;
9533       f1ResetAck->protocolIEs.list.array[idx]->value.choice.TransactionID = TRANS_ID;
9534
9535       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
9536
9537       /* Encode the F1SetupRequest type as UPER */
9538       memset(encBuf, 0, ENC_BUF_MAX_LEN);
9539       encBufSize = 0;
9540       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
9541
9542       /* Check encode results */
9543       if(encRetVal.encoded == ENCODE_FAIL)
9544       {
9545          DU_LOG("\nERROR  -->  F1AP : Could not encode F1ResetAck structure (at %s)\n",\
9546                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
9547          break;
9548       }
9549       else
9550       {
9551          DU_LOG("\nDEBUG  -->  F1AP : Created APER encodedbuffer for F1ResetAck \n");
9552          for(int i=0; i< encBufSize; i++)
9553          {
9554             DU_LOG("%x",encBuf[i]);
9555          }
9556       }
9557
9558       /* Sending msg */
9559       /* TODO : Hardcoding DU ID to 1 for messages other than F1 Setup Response. This will be made generic in future gerrit */
9560       if(SendF1APMsg(CU_APP_MEM_REG, CU_POOL, DU_ID) != ROK)
9561       {
9562          DU_LOG("\nERROR  -->  F1AP : Sending F1 Reset Response failed");
9563          break;
9564       }
9565
9566       ret = ROK;
9567       break;
9568    }while(true);
9569
9570    FreeF1ResetAck(f1apMsg);
9571    return ret;
9572 }
9573
9574 void FreeUlTnlInfoforDrb2(ULUPTNLInformation_ToBeSetup_List_t *ulInfo)
9575 {
9576    uint8_t arrIdx =0;
9577
9578    if(ulInfo->list.array)
9579    {
9580       for(arrIdx=0; arrIdx<ulInfo->list.count ; arrIdx++)
9581       {
9582          if(ulInfo->list.array[arrIdx])
9583          {
9584             if(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel )
9585             {
9586                if(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf)
9587                {
9588                   if(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf)
9589                   {
9590                      CU_FREE(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
9591                      gTP_TEID.buf,ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.\
9592                      gTPTunnel->gTP_TEID.size);
9593                   }
9594                   CU_FREE(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
9595                   transportLayerAddress.buf,ulInfo->list.array[arrIdx]->\
9596                   uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.size);
9597                }
9598                CU_FREE(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel,\
9599                sizeof(GTPTunnel_t));
9600             }
9601             CU_FREE(ulInfo->list.array[arrIdx],sizeof(ULUPTNLInformation_ToBeSetup_Item_t));
9602          }
9603       }
9604       CU_FREE(ulInfo->list.array,ulInfo->list.size);
9605    }
9606 }
9607
9608 /*******************************************************************
9609 *
9610 * @brief Deletes the EGTP tunnel
9611 *
9612 * @details
9613 *
9614 *    Function : deleteEgtpTunnel
9615 *
9616 *    Functionality: Deletes the EGTP tunnel
9617 *
9618 * @params[in] uint8_t *buf
9619 *
9620 * @return ROK     - success
9621 *         RFAILED - failure
9622 *
9623 * ****************************************************************/
9624 uint8_t deleteEgtpTunnel(uint8_t *buf)
9625 {
9626    uint32_t teId = 0;
9627    EgtpTnlEvt tnlEvt;
9628
9629    teIdStringToInt(buf, &teId);
9630    if(teId > MAX_TEID || teId < MIN_TEID)
9631    {
9632       DU_LOG("\nERROR  -->  EGTP : TEID(%d) OUT Of Range", teId);
9633       return RFAILED;
9634    }
9635    memset(&tnlEvt, 0, sizeof(EgtpTnlEvt));
9636    tnlEvt.action = EGTP_TNL_MGMT_DEL;
9637    tnlEvt.lclTeid = teId;
9638    tnlEvt.remTeid = teId;
9639    if((cuEgtpTnlMgmtReq(tnlEvt)) != ROK)
9640    {
9641       DU_LOG("\nERROR  -->  EGTP : Failed to delete tunnel Id %d", teId);
9642    }
9643    return ROK;
9644 }
9645
9646 /*******************************************************************
9647 *
9648 * @brief Builds the Uplink Tunnel Info
9649 *
9650 * @details
9651 *
9652 *    Function : BuildUlTnlInfoforSetupMod
9653 *
9654 *    Functionality: Constructs the UL TnlInfo For DRB list
9655 *
9656 * @params[in] ULUPTNLInformation_ToBeSetup_List_t *ulInfo
9657 *
9658 * @return ROK     - success
9659 *         RFAILED - failure
9660 *
9661 * ****************************************************************/
9662 uint8_t BuildUlTnlInfoforSetupMod(uint8_t ueId, uint8_t drbId, TnlInfo *ulTnlInfo, ULUPTNLInformation_ToBeSetup_List_t *ulInfo, uint8_t actionType)
9663 {
9664    uint8_t arrIdx;
9665    uint8_t ulCnt;
9666
9667    ulCnt = 1;
9668    ulInfo->list.count = ulCnt;
9669    ulInfo->list.size = ulCnt * sizeof(ULUPTNLInformation_ToBeSetup_Item_t *);
9670    CU_ALLOC(ulInfo->list.array,ulInfo->list.size);
9671    if(ulInfo->list.array == NULLP)
9672    {
9673       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildUlTnlInfoforSetupMod");
9674       return RFAILED;
9675    }
9676    for(arrIdx=0; arrIdx<ulCnt; arrIdx++)
9677    {
9678       CU_ALLOC(ulInfo->list.array[arrIdx],sizeof(ULUPTNLInformation_ToBeSetup_Item_t));
9679       if(ulInfo->list.array[arrIdx] == NULLP)
9680       {
9681          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildUlTnlInfoforSetupMod");
9682          return RFAILED;
9683       }
9684    }
9685
9686    arrIdx = 0;
9687    ulInfo->list.array[arrIdx]->uLUPTNLInformation.present = \
9688    UPTransportLayerInformation_PR_gTPTunnel;
9689
9690    /*GTP TUNNEL*/
9691    CU_ALLOC(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel,\
9692          sizeof(GTPTunnel_t));
9693    if(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel == NULLP)
9694    {
9695       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildUlTnlInfoforSetupMod");
9696       return RFAILED;
9697    }
9698    ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
9699       transportLayerAddress.size        = 4*sizeof(uint8_t);
9700    CU_ALLOC(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
9701          transportLayerAddress.buf,ulInfo->list.array[arrIdx]->\
9702          uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.size);
9703    if(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
9704          transportLayerAddress.buf == NULLP)
9705    {
9706       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildUlTnlInfoforSetupMod");
9707       return RFAILED;
9708    }
9709
9710    ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
9711       transportLayerAddress.buf[0] = 192;
9712    ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
9713       transportLayerAddress.buf[1] = 168;
9714    ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
9715       transportLayerAddress.buf[2] = 130;
9716    ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
9717       transportLayerAddress.buf[3] = 82;
9718    ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
9719       transportLayerAddress.bits_unused = 0;
9720
9721    ulTnlInfo->address[0] = ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[0];
9722    ulTnlInfo->address[1] = ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[1];
9723    ulTnlInfo->address[2] = ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[2];
9724    ulTnlInfo->address[3] = ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[3];
9725
9726    /*GTP TEID*/
9727    ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.size\
9728       = 4 * sizeof(uint8_t);
9729    CU_ALLOC(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
9730          gTP_TEID.buf,ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.\
9731          gTPTunnel->gTP_TEID.size);
9732    if(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf\
9733          == NULLP)
9734    {
9735       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildUlTnlInfoforSetupMod");
9736       return RFAILED;
9737    }
9738    ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
9739       gTP_TEID.buf[0] = 0;
9740    ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
9741       gTP_TEID.buf[1] = 0;
9742    ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
9743       gTP_TEID.buf[2] = 0;
9744    if(actionType == ProtocolIE_ID_id_DRBs_ToBeModified_Item)
9745    {
9746      /*TODO: DRB context to be stored in CU STUB so that tunnel Id can be easily
9747       * fetched based on the Drb Id */
9748
9749      /*For For UE Id=1, DRB=2 is modified. For UE Id = 2, DRB=5 is modified and so on.*/
9750       ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[3]=\
9751                                                         (MAX_NUM_DRB_ADDED_PER_UE *(ueId  - 1)) + drbId;
9752    }
9753    else
9754    {
9755       ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
9756         gTP_TEID.buf[3] = cuCb.cuCfgParams.egtpParams.currTunnelId++;
9757    }
9758
9759    ulTnlInfo->teId[0] = ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[0];
9760    ulTnlInfo->teId[1] = ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[1];
9761    ulTnlInfo->teId[2] = ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[2];
9762    ulTnlInfo->teId[3] = ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[3];
9763    return ROK;
9764 }/*End of BuildULTnlInfo*/
9765
9766 /*******************************************************************
9767 *
9768 * @brief freeing the DRB item
9769 *
9770 * @details
9771 *
9772 *    Function : FreeDrbItem
9773 *
9774 *    Functionality: freeing the DRB item
9775 *
9776 * @params[in] DRBs_ToBeSetupMod_Item_t *drbItem
9777 *
9778 * @return ROK     - success
9779 *         RFAILED - failure
9780 *
9781 * ****************************************************************/
9782
9783 void FreeDrbItem(DRBs_ToBeSetupMod_Item_t *drbItem)
9784 {
9785    uint8_t arrIdx =0;
9786    SNSSAI_t *snssai =NULLP;
9787    Flows_Mapped_To_DRB_List_t *flowMap = NULLP;
9788
9789    drbItem->qoSInformation.present = QoSInformation_PR_choice_extension;
9790    switch(drbItem->qoSInformation.present)
9791    {
9792       case QoSInformation_PR_NOTHING:
9793          break;
9794       case QoSInformation_PR_eUTRANQoS:
9795          {
9796             if(drbItem->qoSInformation.choice.eUTRANQoS)
9797             {
9798                CU_FREE(drbItem->qoSInformation.choice.eUTRANQoS, sizeof(EUTRANQoS_t));
9799             }
9800             break;
9801          }
9802       case QoSInformation_PR_choice_extension:
9803          {
9804             if(drbItem->qoSInformation.choice.choice_extension)
9805             {
9806                FreeQOSInfo(&drbItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS);
9807
9808                snssai = &drbItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI;
9809                if(snssai->sST.buf)
9810                {
9811                   CU_FREE(snssai->sST.buf,snssai->sST.size);
9812                }
9813                if(snssai->sD)
9814                {
9815                   if(snssai->sD->buf)
9816                   {
9817                      CU_FREE(snssai->sD->buf,snssai->sD->size);
9818                   }
9819                   CU_FREE(snssai->sD,sizeof(OCTET_STRING_t));
9820                }
9821
9822                flowMap = &drbItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.flows_Mapped_To_DRB_List;
9823                if(flowMap->list.array)
9824                {
9825                   for(arrIdx=0; arrIdx<flowMap->list.count; arrIdx++)
9826                   {
9827                      if(flowMap->list.array[arrIdx] )
9828                      {
9829                         FreeQOSInfo(&flowMap->list.array[arrIdx]->qoSFlowLevelQoSParameters);
9830                         CU_FREE(flowMap->list.array[arrIdx],sizeof(Flows_Mapped_To_DRB_Item_t));
9831                      }
9832                   }
9833                   CU_FREE(flowMap->list.array,flowMap->list.size);
9834                }
9835
9836                CU_FREE(drbItem->qoSInformation.choice.choice_extension,sizeof(QoSInformation_ExtIEs_t));
9837             }
9838             break;
9839          }
9840
9841    }
9842    FreeUlTnlInfoforDrb2(&drbItem->uLUPTNLInformation_ToBeSetup_List);
9843    if(drbItem->uLConfiguration)
9844    {
9845       CU_FREE(drbItem->uLConfiguration,sizeof(ULConfiguration_t));
9846    }
9847 }
9848
9849 /*******************************************************************
9850 *
9851 * @brief filling the DRB setup Mod item
9852 *
9853 * @details
9854 *
9855 *    Function : FillDrbItemToSetupMod
9856 *
9857 *    Functionality: filling the DRB setup Mod item
9858 *
9859 *
9860 * @params[in] DRBs_ToBeSetupMod_Item_t *drbItem
9861 *
9862 * @return ROK     - success
9863 *         RFAILED - failure
9864 *
9865 * ****************************************************************/
9866
9867 uint8_t FillDrbItemToSetupMod(CuUeCb *ueCb, uint8_t arrIdx, DRBs_ToBeSetupMod_Item_t *drbItem)
9868 {
9869    uint8_t ret = ROK;
9870
9871    /*Drb Id */
9872    drbItem->dRBID = arrIdx + DRB_ID_TO_ADD_MOD;
9873    ueCb->drbList[ueCb->numDrb].drbId = drbItem->dRBID;
9874
9875    /*qoSInformation*/
9876    drbItem->qoSInformation.present = QoSInformation_PR_choice_extension;
9877
9878    switch(drbItem->qoSInformation.present)
9879    {
9880       case QoSInformation_PR_NOTHING:
9881       {
9882          break;
9883       }
9884       case QoSInformation_PR_eUTRANQoS:
9885       {
9886
9887          CU_ALLOC(drbItem->qoSInformation.choice.eUTRANQoS, sizeof(EUTRANQoS_t));
9888          if(drbItem->qoSInformation.choice.eUTRANQoS)
9889          {
9890             DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in FillDrbItemToSetupMod");
9891             return RFAILED;
9892          }
9893          drbItem->qoSInformation.choice.eUTRANQoS->qCI = QCI;
9894          drbItem->qoSInformation.choice.eUTRANQoS->allocationAndRetentionPriority.priorityLevel =
9895             PriorityLevel_no_priority;
9896
9897          drbItem->qoSInformation.choice.eUTRANQoS->allocationAndRetentionPriority.pre_emptionCapability =
9898             Pre_emptionCapability_may_trigger_pre_emption;
9899
9900          drbItem->qoSInformation.choice.eUTRANQoS->allocationAndRetentionPriority.pre_emptionVulnerability =
9901             Pre_emptionVulnerability_pre_emptable;
9902
9903          break;
9904       }
9905       case QoSInformation_PR_choice_extension:
9906       {
9907          CU_ALLOC(drbItem->qoSInformation.choice.choice_extension,sizeof(QoSInformation_ExtIEs_t));
9908          if(drbItem->qoSInformation.choice.choice_extension == NULLP)
9909          {
9910             DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in FillDrbItemToSetupMod");
9911             return RFAILED;
9912          }
9913
9914          drbItem->qoSInformation.choice.choice_extension->id = ProtocolIE_ID_id_DRB_Information;
9915          drbItem->qoSInformation.choice.choice_extension->criticality = Criticality_ignore;
9916          drbItem->qoSInformation.choice.choice_extension->value.present = QoSInformation_ExtIEs__value_PR_DRB_Information;
9917          ret =  BuildQOSInfo(&ueCb->drbList[ueCb->numDrb].qos, &drbItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS,\
9918            ProtocolIE_ID_id_DRBs_ToBeSetupMod_Item, PDU_SESSION_ID_2, FALSE);
9919          if(ret != ROK)
9920          {
9921             DU_LOG("\nERROR  -->  F1AP : BuildQOSInfo failed");
9922             return RFAILED;
9923          }
9924
9925          /*SNSSAI*/
9926          ret = BuildSNSSAI(&ueCb->drbList[ueCb->numDrb], &drbItem->qoSInformation.choice.\
9927                choice_extension->value.choice.DRB_Information.sNSSAI, cuCb.snssaiList[1], FALSE);
9928          if(ret != ROK)
9929          {
9930             DU_LOG("\nERROR  -->  F1AP : BuildSNSSAI failed");
9931             return RFAILED;
9932          }
9933
9934          /*Flows mapped to DRB List*/
9935          ret = BuildFlowsMap(&ueCb->drbList[ueCb->numDrb], &drbItem->qoSInformation.choice.\
9936                choice_extension->value.choice.DRB_Information.flows_Mapped_To_DRB_List,\
9937           ProtocolIE_ID_id_DRBs_ToBeSetupMod_Item, FALSE);
9938          if(ret != ROK)
9939          {
9940             DU_LOG("\nERROR  -->  F1AP : BuildFlowsMap failed");
9941             return RFAILED;
9942          }
9943       }
9944    }
9945
9946    /*ULUPTNLInformation To Be Setup List*/
9947    ret = BuildUlTnlInfoforSetupMod(ueCb->gnbCuUeF1apId, drbItem->dRBID, &ueCb->drbList[ueCb->numDrb].ulUpTnlInfo, \
9948       &drbItem->uLUPTNLInformation_ToBeSetup_List, ProtocolIE_ID_id_DRBs_ToBeSetupMod_Item);
9949    if(ret != ROK)
9950    {
9951       DU_LOG("\nERROR  -->  F1AP : BuildUlTnlInfoforSetupMod failed");
9952       return RFAILED;
9953    }
9954
9955    /*RLCMode*/
9956    drbItem->rLCMode = RLCMode_rlc_um_bidirectional;
9957    ueCb->drbList[ueCb->numDrb].rlcMode = drbItem->rLCMode;
9958
9959    ueCb->numDrb++;
9960    return ROK;
9961 }
9962
9963 /*******************************************************************
9964 *
9965 * @brief Builds the DRB to be Setup Mod ItemIes
9966 *
9967 * @details
9968 *
9969 *    Function : FillDrbItemList
9970 *
9971 *    Functionality: Constructs the DRB to be Setup Mod Item Ies
9972 *
9973 * @params[in] struct DRBs_ToBeSetupMod_ItemIEs *drbItemIe
9974 *
9975 * @return ROK     - success
9976 *         RFAILED - failure
9977 *
9978 * ****************************************************************/
9979
9980 uint8_t FillDrbItemList(CuUeCb *ueCb, uint8_t arrIdx, struct DRBs_ToBeSetupMod_ItemIEs *drbItemIe)
9981 {
9982    drbItemIe->id = ProtocolIE_ID_id_DRBs_ToBeSetupMod_Item;
9983    drbItemIe->criticality = Criticality_reject;
9984    drbItemIe->value.present = DRBs_ToBeSetupMod_ItemIEs__value_PR_DRBs_ToBeSetupMod_Item;
9985
9986    if(FillDrbItemToSetupMod(ueCb, arrIdx, (&(drbItemIe->value.choice.DRBs_ToBeSetupMod_Item))) != ROK)
9987    {
9988       DU_LOG("\nERROR  -->  F1AP : FillDrbItemToSetupMod failed");
9989       return RFAILED;
9990    }
9991    return ROK;
9992 }
9993 /*******************************************************************
9994 *
9995 * @brief free the DRB to be Setup Mod list
9996 *
9997 * @details
9998 *
9999 *    Function : FreeDrbToBeSetupModList
10000 *
10001 *    Functionality: free the DRB to be Setup Mod list
10002 *
10003 * @params[in] DRBs_ToBeSetupMod_List_t *drbSet
10004 *
10005 * @return ROK     - success
10006 *         RFAILED - failure
10007 *
10008 * ****************************************************************/
10009 void FreeDrbToBeSetupModList(DRBs_ToBeSetupMod_List_t *drbSet)
10010 {
10011    uint8_t arrIdx =0;
10012    struct DRBs_ToBeSetupMod_ItemIEs *drbItemIe;
10013
10014    if(drbSet->list.array)
10015    {
10016       for(arrIdx=0; arrIdx<drbSet->list.count ; arrIdx++)
10017       {
10018          if(drbSet->list.array[arrIdx] != NULLP)
10019          {
10020             if(arrIdx == 0)
10021             {
10022                drbItemIe = (DRBs_ToBeSetupMod_ItemIEs_t *)drbSet->list.array[arrIdx];
10023                FreeDrbItem(&(drbItemIe->value.choice.DRBs_ToBeSetupMod_Item));
10024             }
10025             CU_FREE(drbSet->list.array[arrIdx], sizeof(DRBs_ToBeSetupMod_ItemIEs_t));
10026          }
10027       }
10028       CU_FREE(drbSet->list.array, drbSet->list.size);
10029    }
10030
10031 }
10032
10033 /*******************************************************************
10034 *
10035 * @brief Builds the DRB to be Setup Mod list
10036 *
10037 * @details
10038 *
10039 *    Function : BuildDrbToBeSetupList
10040 *
10041 *    Functionality: Constructs the DRB to be Setup Mod list
10042 *
10043 * @params[in] DRBs_ToBeSetupMod_List_t *drbSet
10044 *
10045 * @return ROK     - success
10046 *         RFAILED - failure
10047 *
10048 * ****************************************************************/
10049
10050 uint8_t BuildDrbToBeSetupList(CuUeCb *ueCb, DRBs_ToBeSetupMod_List_t *drbSet)
10051 {
10052    uint8_t ret = ROK;
10053    uint8_t arrIdx =0;
10054    uint8_t drbCnt =0;
10055
10056    drbCnt = MAX_DRB_SET_UE_CONTEXT_MOD_REQ;
10057    drbSet->list.count = drbCnt;
10058    drbSet->list.size = drbCnt * sizeof(DRBs_ToBeSetupMod_ItemIEs_t *);
10059    CU_ALLOC(drbSet->list.array, drbSet->list.size);
10060    if(drbSet->list.array == NULLP)
10061    {
10062       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDrbToBeSetupList");
10063       return  RFAILED;
10064    }
10065
10066    for(arrIdx=0; arrIdx<drbCnt; arrIdx++)
10067    {
10068       CU_ALLOC(drbSet->list.array[arrIdx], sizeof(DRBs_ToBeSetupMod_ItemIEs_t));
10069       if(drbSet->list.array[arrIdx] == NULLP)
10070       {
10071          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDrbToBeSetupList for array idx [%d]", arrIdx);
10072          return  RFAILED;
10073       }
10074
10075       ret = FillDrbItemList(ueCb, arrIdx, (DRBs_ToBeSetupMod_ItemIEs_t *)drbSet->list.array[arrIdx]);
10076       if(ret != ROK)
10077       {
10078          DU_LOG("\nERROR  -->  F1AP : FillDrbItemList failed");
10079       }
10080    }
10081
10082    return ret;
10083 }
10084
10085 /*******************************************************************
10086 *
10087 * @brief Filling the DRB to be modified item
10088 *
10089 * @details
10090 *
10091 *    Function : FillDrbToBeModItem
10092 *
10093 *    Functionality: filling the DRB to be modified item
10094 *
10095 * @params[in] DRBs_ToBeModified_Item_t *drbItem
10096 *
10097 * @return ROK     - success
10098 *         RFAILED - failure
10099 *
10100 * ****************************************************************/
10101
10102 uint8_t FillDrbToBeModItem(CuUeCb *ueCb, uint8_t arrIdx, DRBs_ToBeModified_Item_t *drbItem)
10103 {
10104    uint8_t ret = ROK;
10105    uint drbIdx=0;
10106    DrbInfo *drbToBeMod;
10107
10108    /*Drb Id */
10109    drbItem->dRBID = DRB2 + arrIdx;
10110
10111    /* Search for DRB ID in CU databse */
10112    for(drbIdx = 0; drbIdx < ueCb->numDrb; drbIdx++)
10113    {
10114       if(ueCb->drbList[drbIdx].drbId == drbItem->dRBID)
10115       {
10116          drbToBeMod = &ueCb->drbList[drbIdx];
10117          break;
10118       }
10119    }
10120
10121    /*qoSInformation*/
10122    drbItem->qoSInformation = NULLP;
10123    CU_ALLOC(drbItem->qoSInformation, sizeof(QoSInformation_t));
10124    if(drbItem->qoSInformation != NULLP)
10125    {
10126       drbItem->qoSInformation->present = QoSInformation_PR_choice_extension;
10127
10128       switch(drbItem->qoSInformation->present)
10129       {
10130          case QoSInformation_PR_NOTHING:
10131             {
10132                break;
10133             }
10134          case QoSInformation_PR_eUTRANQoS:
10135             {
10136
10137                CU_ALLOC(drbItem->qoSInformation->choice.eUTRANQoS, sizeof(EUTRANQoS_t));
10138                if(drbItem->qoSInformation->choice.eUTRANQoS)
10139                {
10140                   DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in FillDrbToBeModItem");
10141                   return RFAILED;
10142                }
10143                drbItem->qoSInformation->choice.eUTRANQoS->qCI = QCI;
10144                drbItem->qoSInformation->choice.eUTRANQoS->allocationAndRetentionPriority.priorityLevel =
10145                   PriorityLevel_no_priority;
10146
10147                drbItem->qoSInformation->choice.eUTRANQoS->allocationAndRetentionPriority.pre_emptionCapability =
10148                   Pre_emptionCapability_may_trigger_pre_emption;
10149
10150                drbItem->qoSInformation->choice.eUTRANQoS->allocationAndRetentionPriority.pre_emptionVulnerability =
10151                   Pre_emptionVulnerability_pre_emptable;
10152
10153                break;
10154             }
10155          case QoSInformation_PR_choice_extension:
10156             {
10157                CU_ALLOC(drbItem->qoSInformation->choice.choice_extension,sizeof(QoSInformation_ExtIEs_t));
10158                if(drbItem->qoSInformation->choice.choice_extension == NULLP)
10159                {
10160                   DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in FillDrbItemToSetupMod");
10161                   return RFAILED;
10162                }
10163
10164                drbItem->qoSInformation->choice.choice_extension->id = ProtocolIE_ID_id_DRB_Information;
10165                drbItem->qoSInformation->choice.choice_extension->criticality = Criticality_ignore;
10166                drbItem->qoSInformation->choice.choice_extension->value.present = QoSInformation_ExtIEs__value_PR_DRB_Information;
10167                ret =  BuildQOSInfo(&drbToBeMod->qos, &drbItem->qoSInformation->choice.choice_extension->value.choice.DRB_Information.dRB_QoS,\
10168                      ProtocolIE_ID_id_DRBs_ToBeModified_Item, INVALID_PDU_SESSION_ID, FALSE);
10169                if(ret != ROK)
10170                {
10171                   DU_LOG("\nERROR  -->  F1AP : BuildQOSInfo failed");
10172                   return RFAILED;
10173                }
10174
10175                /*SNSSAI*/
10176                ret = BuildSNSSAI(drbToBeMod, &drbItem->qoSInformation->choice.\
10177                      choice_extension->value.choice.DRB_Information.sNSSAI, cuCb.snssaiList[0], FALSE);
10178                if(ret != ROK)
10179                {
10180                   DU_LOG("\nERROR  -->  F1AP : BuildSNSSAI failed");
10181                   return RFAILED;
10182                }
10183
10184                /*Flows mapped to DRB List*/
10185                ret = BuildFlowsMap(drbToBeMod, &drbItem->qoSInformation->choice.\
10186                      choice_extension->value.choice.DRB_Information.flows_Mapped_To_DRB_List,\
10187                      ProtocolIE_ID_id_DRBs_ToBeModified_Item, FALSE);
10188                if(ret != ROK)
10189                {
10190                   DU_LOG("\nERROR  -->  F1AP : BuildFlowsMap failed");
10191                   return RFAILED;
10192                }
10193             }
10194       }
10195    }/* End of QoS */
10196
10197    /*ULUPTNLInformation To Be Setup List*/
10198    ret = BuildUlTnlInfoforSetupMod(ueCb->gnbCuUeF1apId, drbItem->dRBID, &drbToBeMod->ulUpTnlInfo, &drbItem->uLUPTNLInformation_ToBeSetup_List,\
10199             ProtocolIE_ID_id_DRBs_ToBeModified_Item);
10200    if(ret != ROK)
10201    {
10202       DU_LOG("\nERROR  -->  F1AP : BuildUlTnlInfoforSetupMod failed");
10203       return RFAILED;
10204    }
10205    return ROK;
10206 }
10207
10208 /*******************************************************************
10209 *
10210 * @brief Builds the DRB to be modified Item IE
10211 *
10212 * @details
10213 *
10214 *    Function : FillDrbToBeModItemList
10215 *
10216 *    Functionality: Constructs the DRB to be modified Mod Item Ies
10217 *
10218 * @params[in] struct DRBs_ToBeModified_ItemIEs *drbItemIe
10219 *
10220 * @return ROK     - success
10221 *         RFAILED - failure
10222 *
10223 * ****************************************************************/
10224
10225 uint8_t FillDrbToBeModItemList(CuUeCb *ueCb, uint8_t arrIdx, struct DRBs_ToBeModified_ItemIEs *drbItemIe)
10226 {
10227    drbItemIe->id = ProtocolIE_ID_id_DRBs_ToBeModified_Item;
10228    drbItemIe->criticality = Criticality_reject;
10229    drbItemIe->value.present = DRBs_ToBeModified_ItemIEs__value_PR_DRBs_ToBeModified_Item;
10230    if(FillDrbToBeModItem(ueCb, arrIdx, &(drbItemIe->value.choice.DRBs_ToBeModified_Item)) != ROK)
10231    {
10232       DU_LOG("\nERROR  -->  F1AP : FillDrbToBeModItem failed");
10233       return RFAILED;
10234    }
10235
10236    return ROK;
10237 }
10238
10239 /*******************************************************************
10240 *
10241 * @brief Builds the DRB to be modified list
10242 *
10243 * @details
10244 *
10245 *    Function : BuildDrbToBeModList
10246 *
10247 *    Functionality: Constructs the DRB to be modified list
10248 *
10249 * @params[in] DRBs_ToBeModified_List_t *drbSet
10250 *
10251 * @return ROK     - success
10252 *         RFAILED - failure
10253 *
10254 * ****************************************************************/
10255
10256 uint8_t BuildDrbToBeModifiedList(CuUeCb *ueCb, DRBs_ToBeModified_List_t *drbSet)
10257 {
10258    uint8_t ret = ROK;
10259    uint8_t arrIdx =0;
10260    uint8_t drbCnt =0;
10261
10262    drbCnt = MAX_DRB_MODIFIED_UE_MOD_REQ;
10263    drbSet->list.count = drbCnt;
10264    drbSet->list.size = drbCnt * sizeof(DRBs_ToBeModified_ItemIEs_t *);
10265    CU_ALLOC(drbSet->list.array, drbSet->list.size);
10266    if(drbSet->list.array == NULLP)
10267    {
10268       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDrbToBeModifiedList");
10269       return  RFAILED;
10270    }
10271    for(arrIdx=0; arrIdx<drbCnt; arrIdx++)
10272    {
10273       CU_ALLOC(drbSet->list.array[arrIdx], sizeof(DRBs_ToBeModified_ItemIEs_t));
10274       if(drbSet->list.array[arrIdx] == NULLP)
10275       {
10276          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDrbToBeSetupList");
10277          return  RFAILED;
10278       }
10279
10280       ret = FillDrbToBeModItemList(ueCb, arrIdx, (DRBs_ToBeModified_ItemIEs_t *)drbSet->list.array[arrIdx]);
10281       if(ret != ROK)
10282       {
10283          DU_LOG("\nERROR  -->  F1AP : FillDrbToBeModItemList failed");
10284       }
10285    }
10286
10287    return ret;
10288 }
10289
10290 /*******************************************************************
10291 *
10292 * @brief freeing the DRB  item
10293 *
10294 * @details
10295 *
10296 *    Function : FreeModifiedDrbItem
10297 *
10298 *    Functionality: freeing the DRB 2 item
10299 *
10300 * @params[in] DRBs_ToBeSetupMod_Item_t *drbItem
10301 *
10302 * @return ROK     - success
10303 *         RFAILED - failure
10304 *
10305 * ****************************************************************/
10306
10307 void FreeModifiedDrbItem(DRBs_ToBeModified_Item_t *drbItem)
10308 {
10309    uint8_t arrIdx =0;
10310    SNSSAI_t *snssai =NULLP;
10311    Flows_Mapped_To_DRB_List_t *flowMap = NULLP;
10312
10313    if(drbItem->qoSInformation != NULLP)
10314    {
10315       switch(drbItem->qoSInformation->present)
10316       {
10317          case QoSInformation_PR_NOTHING:
10318             break;
10319          case QoSInformation_PR_eUTRANQoS:
10320             {
10321                if(drbItem->qoSInformation->choice.eUTRANQoS)
10322                {
10323                   CU_FREE(drbItem->qoSInformation->choice.eUTRANQoS, sizeof(EUTRANQoS_t));
10324                }
10325                break;
10326             }
10327          case QoSInformation_PR_choice_extension:
10328             {
10329                if(drbItem->qoSInformation->choice.choice_extension)
10330                {
10331                   FreeQOSInfo(&drbItem->qoSInformation->choice.choice_extension->value.choice.DRB_Information.dRB_QoS);
10332
10333                   snssai = &drbItem->qoSInformation->choice.choice_extension->value.choice.DRB_Information.sNSSAI;
10334                   if(snssai->sST.buf)
10335                   {
10336                      CU_FREE(snssai->sST.buf,snssai->sST.size);
10337                   }
10338                   if(snssai->sD)
10339                   {
10340                      if(snssai->sD->buf)
10341                      {
10342                         CU_FREE(snssai->sD->buf,snssai->sD->size);
10343                      }
10344                      CU_FREE(snssai->sD,sizeof(OCTET_STRING_t));
10345                   }
10346
10347                   flowMap = &drbItem->qoSInformation->choice.choice_extension->value.choice.DRB_Information.flows_Mapped_To_DRB_List;
10348                   if(flowMap->list.array)
10349                   {
10350                      for(arrIdx=0; arrIdx<flowMap->list.count; arrIdx++)
10351                      {
10352                         if(flowMap->list.array[arrIdx] )
10353                         {
10354                            FreeQOSInfo(&flowMap->list.array[arrIdx]->qoSFlowLevelQoSParameters);
10355                            CU_FREE(flowMap->list.array[arrIdx],sizeof(Flows_Mapped_To_DRB_Item_t));
10356                         }
10357                      }
10358                      CU_FREE(flowMap->list.array,flowMap->list.size);
10359                   }
10360
10361                   CU_FREE(drbItem->qoSInformation->choice.choice_extension,sizeof(QoSInformation_ExtIEs_t));
10362                }
10363                break;
10364             }
10365       }
10366    }
10367    FreeUlTnlInfoforDrb2(&drbItem->uLUPTNLInformation_ToBeSetup_List);
10368    if(drbItem->uLConfiguration)
10369    {
10370       CU_FREE(drbItem->uLConfiguration,sizeof(ULConfiguration_t));
10371    }
10372 }
10373
10374 /*******************************************************************
10375 *
10376 * @brief free the DRB to be modfified list
10377 *
10378 * @details
10379 *
10380 *    Function : FreeDrbToBeModifiedList
10381 *
10382 *    Functionality: free the DRB to be Setup Mod list
10383 *
10384 * @params[in] FreeDrbToBeModifiedList_t *drbSet
10385 *
10386 * @return ROK     - success
10387 *         RFAILED - failure
10388 *
10389 * ****************************************************************/
10390 void FreeDrbToBeModifiedList(DRBs_ToBeModified_List_t *drbSet)
10391 {
10392    uint8_t arrIdx =0;
10393    struct DRBs_ToBeModified_ItemIEs *drbItemIe;
10394
10395    if(drbSet->list.array)
10396    {
10397       for(arrIdx=0; arrIdx<drbSet->list.count ; arrIdx++)
10398       {
10399          if(drbSet->list.array[arrIdx] != NULLP)
10400          {
10401             drbItemIe = (struct DRBs_ToBeModified_ItemIEs *)drbSet->list.array[arrIdx];
10402             FreeModifiedDrbItem(&(drbItemIe->value.choice.DRBs_ToBeModified_Item));
10403             CU_FREE(drbSet->list.array[arrIdx], sizeof(DRBs_ToBeModified_ItemIEs_t));
10404          }
10405       }
10406       CU_FREE(drbSet->list.array, drbSet->list.size);
10407    }
10408
10409 }
10410
10411 /*******************************************************************
10412  *
10413  * @brief  free the UeContextModification Request
10414  *
10415  * @details
10416  *
10417  *    Function : FreeUeContextModicationRequest
10418  *
10419  *    Functionality : deallocation of memory allocated in UeContextModiification
10420  request
10421  *
10422  * @params[in] F1AP_PDU_t *f1apMsg
10423  *
10424  * @return void
10425 *
10426 * ****************************************************************/
10427 void FreeUeContextModicationRequest(F1AP_PDU_t *f1apMsg)
10428 {
10429    uint8_t arrIdx =0 , ieId=0;
10430    UEContextModificationRequest_t *ueContextModifyReq = NULLP;
10431
10432    if(f1apMsg)
10433    {
10434       if(f1apMsg->choice.initiatingMessage)
10435       {
10436          ueContextModifyReq =&f1apMsg->choice.initiatingMessage->value.choice.UEContextModificationRequest;
10437          if(ueContextModifyReq->protocolIEs.list.array)
10438          {
10439             for( arrIdx = 0 ; arrIdx<ueContextModifyReq->protocolIEs.list.count ; arrIdx++)
10440             {
10441                if(ueContextModifyReq->protocolIEs.list.array[arrIdx])
10442                {
10443                   ieId = ueContextModifyReq->protocolIEs.list.array[arrIdx]->id;
10444                   switch(ieId)
10445                   {
10446                      case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
10447                         break;
10448                      case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
10449                         break;
10450                      case ProtocolIE_ID_id_DRBs_ToBeSetupMod_List:
10451                         {
10452                            FreeDrbToBeSetupModList(&ueContextModifyReq->protocolIEs.list.array[arrIdx]->value.\
10453                                  choice.DRBs_ToBeSetupMod_List);
10454                            break;
10455                         }
10456                      case ProtocolIE_ID_id_DRBs_ToBeModified_List:
10457                         {
10458                            FreeDrbToBeModifiedList(&ueContextModifyReq->protocolIEs.list.array[arrIdx]->value.\
10459                                  choice.DRBs_ToBeModified_List);
10460                            break;
10461                         }
10462                     case ProtocolIE_ID_id_TransmissionActionIndicator:
10463                         break;
10464                     case ProtocolIE_ID_id_RRCContainer:
10465                     {
10466                         CU_FREE(ueContextModifyReq->protocolIEs.list.array[arrIdx]->value.choice.RRCContainer.buf,\
10467                         ueContextModifyReq->protocolIEs.list.array[arrIdx]->value.choice.RRCContainer.size);
10468                     }
10469
10470                   }
10471                   CU_FREE(ueContextModifyReq->protocolIEs.list.array[arrIdx], sizeof(UEContextModificationRequest_t));
10472                }
10473             }
10474             CU_FREE(ueContextModifyReq->protocolIEs.list.array, ueContextModifyReq->protocolIEs.list.size);
10475          }
10476          CU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
10477       }
10478       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
10479    }
10480 }
10481
10482 /*******************************************************************
10483  *
10484  * @brief Builds the Ue Context Modification Req
10485  *
10486  * @details
10487  *
10488  *    Function : BuildAndSendUeContextModificationReq
10489  *
10490  *    Functionality: Constructs the Ue Context Modification Req
10491  *
10492  * @params[in]
10493  *
10494  * @return ROK     - success
10495  *         RFAILED - failure
10496  *
10497  * ****************************************************************/
10498 uint8_t BuildAndSendUeContextModificationReq(uint32_t duId, void *cuUeCb, UeCtxtModAction action)
10499 {
10500    uint8_t    ieIdx = 0;
10501    uint8_t    elementCnt = 0;
10502    uint8_t    ret = RFAILED;
10503    CuUeCb     *ueCb = (CuUeCb *)cuUeCb;
10504    F1AP_PDU_t *f1apMsg = NULLP;
10505    UEContextModificationRequest_t *ueContextModifyReq = NULLP;
10506    action =RESTART_DATA_TX;
10507    asn_enc_rval_t         encRetVal;
10508    DU_LOG("\nINFO  -->  F1AP : Building Ue context modification request\n");
10509    while(1)
10510    {
10511       CU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
10512       if(f1apMsg == NULLP)
10513       {
10514          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed Ue context modification");
10515          break;
10516       }
10517
10518       f1apMsg->present =  F1AP_PDU_PR_initiatingMessage;
10519
10520       CU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
10521       if(f1apMsg->choice.initiatingMessage == NULLP)
10522       {
10523          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed Ue context modification");
10524          break;
10525       }
10526       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_UEContextModification;
10527       f1apMsg->choice.initiatingMessage->criticality = Criticality_reject;
10528       f1apMsg->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_UEContextModificationRequest;
10529
10530       ueContextModifyReq =&f1apMsg->choice.initiatingMessage->value.choice.UEContextModificationRequest;
10531
10532       if(action == MODIFY_UE)
10533          elementCnt = 4;
10534       else if(action == QUERY_CONFIG)
10535          elementCnt = 3;
10536       else if(action == RRC_RECONFIG_COMPLETE_IND)
10537          elementCnt = 3;
10538       else if((action == STOP_DATA_TX) || (action == RESTART_DATA_TX))
10539          elementCnt = 5;
10540
10541       ueContextModifyReq->protocolIEs.list.count = elementCnt;
10542       ueContextModifyReq->protocolIEs.list.size = elementCnt*sizeof(UEContextModificationRequest_t *);
10543
10544       /* Initialize the UE context modification members */
10545       CU_ALLOC(ueContextModifyReq->protocolIEs.list.array, ueContextModifyReq->protocolIEs.list.size);
10546       if(ueContextModifyReq->protocolIEs.list.array == NULLP)
10547       {
10548          DU_LOG("\nERROR  -->  F1AP : Memory allocation for UE context modifcation Request failed");
10549          break;
10550       }
10551
10552       for(ieIdx=0 ; ieIdx<elementCnt; ieIdx++)
10553       {
10554          CU_ALLOC(ueContextModifyReq->protocolIEs.list.array[ieIdx], sizeof(UEContextModificationRequest_t));
10555          if(ueContextModifyReq->protocolIEs.list.array[ieIdx] == NULLP)
10556          {
10557             DU_LOG("\nERROR  -->  F1AP : Memory allocation for UE context modifcation Request failed");
10558             break;
10559          }
10560       }
10561
10562       ieIdx=0;
10563       ueContextModifyReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
10564       ueContextModifyReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
10565       ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present = \
10566                                                                          UEContextModificationRequestIEs__value_PR_GNB_CU_UE_F1AP_ID;
10567       ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID = ueCb->gnbCuUeF1apId;
10568
10569       ieIdx++;
10570       ueContextModifyReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
10571       ueContextModifyReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
10572       ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present=\
10573                                                                        UEContextModificationRequestIEs__value_PR_GNB_DU_UE_F1AP_ID;
10574       ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID = ueCb->gnbDuUeF1apId;
10575
10576       if(action == MODIFY_UE)
10577       {
10578          /* DRB to be setup list */
10579          ieIdx++;
10580          ueContextModifyReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_DRBs_ToBeSetupMod_List;
10581          ueContextModifyReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
10582          ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present =\
10583                                                                            UEContextModificationRequestIEs__value_PR_DRBs_ToBeSetupMod_List;
10584          ret = BuildDrbToBeSetupList(ueCb, &(ueContextModifyReq->protocolIEs.list.array[ieIdx]->\
10585                   value.choice.DRBs_ToBeSetupMod_List));
10586
10587          /* DRB to be modified list */
10588          ieIdx++;
10589          ueContextModifyReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_DRBs_ToBeModified_List;
10590          ueContextModifyReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
10591          ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present =\
10592                                                                            UEContextModificationRequestIEs__value_PR_DRBs_ToBeModified_List;
10593          ret = BuildDrbToBeModifiedList(ueCb, &(ueContextModifyReq->protocolIEs.list.array[ieIdx]->\
10594                   value.choice.DRBs_ToBeModified_List));
10595
10596          /* TODO: DRB to be release list */
10597
10598          if(ret != ROK)
10599          {
10600             DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextModificationReq(): Failed to build drb to be modified list");
10601             break;
10602          }
10603
10604          /* TODO: fill the RRC reconfiguration information in RRC Contaiiner ie in case of MODIFY_UE  */
10605       }
10606       else if(action == QUERY_CONFIG)
10607       {
10608          ieIdx++;
10609          ueContextModifyReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_GNB_DUConfigurationQuery;
10610          ueContextModifyReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
10611          ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present = \
10612             UEContextModificationRequestIEs__value_PR_GNB_DUConfigurationQuery;
10613          ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DUConfigurationQuery = GNB_DUConfigurationQuery_true;
10614       }
10615       else if(action == RRC_RECONFIG_COMPLETE_IND)
10616       {
10617          ieIdx++;
10618          ueContextModifyReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_RRCReconfigurationCompleteIndicator;
10619          ueContextModifyReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
10620          ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present = \
10621             UEContextModificationRequestIEs__value_PR_RRCReconfigurationCompleteIndicator;
10622          ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.RRCReconfigurationCompleteIndicator = \
10623             RRCReconfigurationCompleteIndicator_true;
10624       }
10625       else if((action == STOP_DATA_TX) || (action == RESTART_DATA_TX))
10626       {
10627          ieIdx++;
10628          if(action == STOP_DATA_TX)
10629          {
10630             ueContextModifyReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_TransmissionActionIndicator;
10631             ueContextModifyReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
10632             ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present = \
10633             UEContextModificationRequestIEs__value_PR_TransmissionActionIndicator;
10634             ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.TransmissionActionIndicator = \
10635             TransmissionActionIndicator_stop;
10636          }
10637          else if (action == RESTART_DATA_TX)
10638          {
10639             ueContextModifyReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_TransmissionActionIndicator;
10640             ueContextModifyReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
10641             ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present = \
10642             UEContextModificationRequestIEs__value_PR_TransmissionActionIndicator;
10643             ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.TransmissionActionIndicator = \
10644             TransmissionActionIndicator_restart;
10645          }
10646          ieIdx++;
10647          ueContextModifyReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_RRCContainer;
10648          ueContextModifyReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
10649          ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present = \
10650          UEContextModificationRequestIEs__value_PR_RRCContainer;
10651          if(fillRrcReconfigBuf(ueCb, &ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer, true) != ROK)
10652          {
10653             DU_LOG( "\nERROR  -->  F1AP : Failed to fill Rrc reconfiguration buffer");
10654             return RFAILED;
10655          }
10656
10657          /* RRC delivery status request */
10658          ieIdx++;
10659          ueContextModifyReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_RRCDeliveryStatusRequest;
10660          ueContextModifyReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_ignore;
10661          ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present = UEContextModificationRequestIEs__value_PR_RRCDeliveryStatusRequest;
10662          ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.RRCDeliveryStatusRequest = RRCDeliveryStatusRequest_true;
10663       }
10664
10665       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
10666
10667       /* Encode the F1SetupRequest type as APER */
10668       memset(encBuf, 0, ENC_BUF_MAX_LEN);
10669       encBufSize = 0;
10670       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
10671
10672       /* Encode results */
10673       if(encRetVal.encoded == ENCODE_FAIL)
10674       {
10675          DU_LOG("\nERROR  -->  F1AP : Could not encode ueContextModifyReq structure (at %s)\n",\
10676                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
10677          break;
10678       }
10679       else
10680       {
10681          DU_LOG("\nDEBUG  -->  F1AP : Created APER encodedbuffer for ueContextModifyReq\n");
10682          for(ieIdx=0; ieIdx< encBufSize; ieIdx++)
10683          {
10684             DU_LOG("%x",encBuf[ieIdx]);
10685          }
10686       }
10687
10688       /* TODO : Hardcoding DU ID to 1 for messages other than F1 Setup Response. This will be made generic in future gerrit */
10689       if(SendF1APMsg(CU_APP_MEM_REG, CU_POOL, duId) != ROK)
10690       {
10691          DU_LOG("\nERROR  -->  F1AP : Sending Ue context modification request  failed");
10692          break;
10693       }
10694
10695       ret = ROK;
10696       break;
10697
10698    }
10699    FreeUeContextModicationRequest(f1apMsg);
10700    return ret;
10701 }
10702
10703 /*****************************************************************i
10704  *
10705 * @brief Free memory allocated for UE Context Release Command
10706 *
10707 * @details
10708 *
10709 *    Function : FreeUeContextReleaseCommand
10710 *
10711 *    Functionality:
10712 *         - Free memory allocated for UE Context Release Command
10713 *
10714 * @params[in] F1AP_PDU_t *f1apMsg
10715 * @return void
10716 *
10717 * *************************************************************/
10718 void FreeUeContextReleaseCommand(F1AP_PDU_t *f1apMsg)
10719 {
10720    uint8_t ieIdx;
10721    UEContextReleaseCommand_t *ueReleaseCommand = NULLP;
10722
10723    if(f1apMsg)
10724    {
10725       if(f1apMsg->choice.initiatingMessage)
10726       {
10727          ueReleaseCommand =&f1apMsg->choice.initiatingMessage->value.choice.UEContextReleaseCommand;
10728          if(ueReleaseCommand->protocolIEs.list.array)
10729          {
10730             for(ieIdx=0 ; ieIdx<ueReleaseCommand->protocolIEs.list.count; ieIdx++)
10731             {
10732                CU_FREE(ueReleaseCommand->protocolIEs.list.array[ieIdx], sizeof(UEContextReleaseCommand_t));
10733             }
10734             CU_FREE(ueReleaseCommand->protocolIEs.list.array, ueReleaseCommand->protocolIEs.list.size);
10735          }
10736          CU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
10737       }
10738       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
10739    }
10740 }
10741 /*******************************************************************
10742  *
10743  * @brief Builds the Ue Context Release Command
10744  *
10745  * @details
10746 *
10747 *    Function : BuildAndSendUeContextReleaseCommand
10748 *
10749 *    Functionality: Constructs the Ue Context Release Command
10750 *
10751 * @params[in]
10752 *
10753 * @return ROK     - success
10754 *         RFAILED - failure
10755 *
10756 * ****************************************************************/
10757 uint8_t BuildAndSendUeContextReleaseCommand(uint32_t duId, uint8_t cuUeF1apId, uint8_t duUeF1apId)
10758 {
10759    bool       memAllocFailed = false;
10760    uint8_t  duIdx = 0, ieIdx = 0,elementCnt = 0, ret = RFAILED, bufLen=0;
10761    DuDb *duDb;
10762    CuUeCb *ueCb;
10763    F1AP_PDU_t *f1apMsg = NULLP;
10764    UEContextReleaseCommand_t *ueContextReleaseCommand = NULLP;
10765
10766    asn_enc_rval_t         encRetVal;
10767    DU_LOG("\nINFO  -->  F1AP : Building Ue context release command\n");
10768
10769    while(true)
10770    {
10771       CU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
10772       if(f1apMsg == NULLP)
10773       {
10774          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseCommand(): Memory allocation for F1AP-PDU");
10775          break;
10776       }
10777
10778       f1apMsg->present =  F1AP_PDU_PR_initiatingMessage;
10779
10780       CU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
10781       if(f1apMsg->choice.initiatingMessage == NULLP)
10782       {
10783          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseCommand(): Memory allocation for F1AP-PDU failed ");
10784          break;
10785       }
10786       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_UEContextRelease;
10787       f1apMsg->choice.initiatingMessage->criticality = Criticality_reject;
10788       f1apMsg->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_UEContextReleaseCommand;
10789
10790       ueContextReleaseCommand =&f1apMsg->choice.initiatingMessage->value.choice.UEContextReleaseCommand;
10791
10792       SEARCH_DU_DB(duIdx, duId, duDb);
10793       ueCb = &duDb->ueCb[duUeF1apId-1];
10794       if(ueCb->state == UE_HANDOVER_IN_PROGRESS)
10795          elementCnt = 3;
10796       else
10797          elementCnt = 4;
10798
10799       ueContextReleaseCommand->protocolIEs.list.count = elementCnt;
10800       ueContextReleaseCommand->protocolIEs.list.size = elementCnt*sizeof(UEContextReleaseCommand_t*);
10801
10802       /* Initialize the UE context modification members */
10803       CU_ALLOC(ueContextReleaseCommand->protocolIEs.list.array, ueContextReleaseCommand->protocolIEs.list.size);
10804       if(ueContextReleaseCommand->protocolIEs.list.array == NULLP)
10805       {
10806          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseCommand():Memory allocation failed");
10807          break;
10808       }
10809
10810       for(ieIdx=0 ; ieIdx<elementCnt; ieIdx++)
10811       {
10812          CU_ALLOC(ueContextReleaseCommand->protocolIEs.list.array[ieIdx], sizeof(UEContextReleaseCommand_t));
10813          if(ueContextReleaseCommand->protocolIEs.list.array[ieIdx] == NULLP)
10814          {
10815             DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseCommand(): Memory allocation failed ");
10816             memAllocFailed = true;
10817             break;
10818          }
10819       }
10820
10821       if(memAllocFailed == true)
10822       {
10823          break;
10824       }
10825
10826       ieIdx=0;
10827       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
10828       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
10829       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.present = \
10830       UEContextReleaseCommandIEs__value_PR_GNB_CU_UE_F1AP_ID;
10831       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID =cuUeF1apId;
10832
10833       ieIdx++;
10834       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
10835       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
10836       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.present=\
10837       UEContextReleaseCommandIEs__value_PR_GNB_DU_UE_F1AP_ID;
10838       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID =duUeF1apId;
10839
10840       /* Cause of UE context release */
10841       ieIdx++;
10842       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_Cause;
10843       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->criticality = Criticality_ignore;
10844       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.present=\
10845                                                                             UEContextReleaseCommandIEs__value_PR_Cause;
10846       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.Cause.present = Cause_PR_radioNetwork;
10847       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.Cause.choice.radioNetwork=\
10848                                                                                                      CauseRadioNetwork_normal_release;
10849       if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
10850       {
10851          /* RRC Container for RRC release */
10852          ieIdx++;
10853          ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_RRCContainer;
10854          ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->criticality = Criticality_ignore;
10855          ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.present = \
10856                                                                                  UEContextReleaseCommandIEs__value_PR_RRCContainer;
10857          char secModeBuf[7]={ 0x00, 0x05, 0x13, 0x00, 0x00, 0x00, 0x00};
10858          bufLen =7;
10859          ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.size = bufLen;
10860          CU_ALLOC(ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf,
10861                ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.size);
10862          if(!ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf)
10863          {
10864             DU_LOG("\nERROR  -->  F1AP : Memory allocation for BuildAndSendUeContextReleaseCommand failed");
10865             break;
10866          }
10867          memset(ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf, 0, bufLen);
10868          memcpy(ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf, secModeBuf, bufLen);
10869       }
10870       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
10871
10872       /* Encode the UE Context Release Command type as APER */
10873       memset(encBuf, 0, ENC_BUF_MAX_LEN);
10874       encBufSize = 0;
10875       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
10876             encBuf);
10877
10878       /* Encode results */
10879       if(encRetVal.encoded == ENCODE_FAIL)
10880       {
10881          DU_LOG("\nERROR  -->  F1AP : Could not encode Release Command structure (at %s)\n",\
10882                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
10883          break;
10884       }
10885       else
10886       {
10887          DU_LOG("\nDEBUG  -->  F1AP : Created APER encoded buffer for Ue Context Release Command\n");
10888          for(ieIdx=0; ieIdx< encBufSize; ieIdx++)
10889          {
10890             DU_LOG("%x",encBuf[ieIdx]);
10891          }
10892       }
10893
10894       /* TODO : Hardcoding DU ID to 1 for messages other than F1 Setup Response. This will be made generic in future gerrit */
10895       if(SendF1APMsg(CU_APP_MEM_REG, CU_POOL, duId) != ROK)
10896       {
10897          DU_LOG("\nERROR  -->  F1AP : Sending Ue context Release Command failed");
10898          break;
10899       }
10900
10901       ret = ROK;
10902       break;
10903
10904    }
10905    FreeUeContextReleaseCommand(f1apMsg);
10906    return ret;
10907 }
10908 /*******************************************************************
10909 *
10910 * @brief process Ue context release request
10911 *
10912 * @details
10913 *
10914 *    Function : procUeContextReleaseReq
10915 *
10916 *    Functionality:
10917 *         - process Ue context release request
10918 *
10919 * @params[in] F1AP_PDU_t *f1apMsg
10920 * @return ROK     - success
10921 *         RFAILED - failure
10922 *
10923 * ****************************************************************/
10924 uint8_t procUeContextReleaseReq(uint32_t duId, F1AP_PDU_t *f1apMsg)
10925 {
10926    uint8_t ieIdx=0, duUeF1apId=0,cuUeF1apId=0;
10927
10928    UEContextReleaseRequest_t *ueReleaseReq = NULLP;
10929    ueReleaseReq = &f1apMsg->choice.initiatingMessage->value.choice.UEContextReleaseRequest;
10930
10931    for(ieIdx=0; ieIdx < ueReleaseReq->protocolIEs.list.count; ieIdx++)
10932    {
10933       switch(ueReleaseReq->protocolIEs.list.array[ieIdx]->id)
10934       {
10935          case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
10936             {
10937                cuUeF1apId = ueReleaseReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID;
10938                break;
10939             }
10940          case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
10941             {
10942                duUeF1apId = ueReleaseReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID;
10943                break;
10944             }
10945          default:
10946               break;
10947       }
10948    }
10949
10950    if(BuildAndSendUeContextReleaseCommand(duId, cuUeF1apId, duUeF1apId) != ROK)
10951    {
10952       DU_LOG("\nERROR  -->  F1AP : procUeContextReleaseReq(): Failed to build Ue Context Release Command ");
10953       return RFAILED;
10954    }
10955    return ROK;
10956 }
10957 /*******************************************************************
10958 *
10959 * @brief processing of Gnb-DU config update
10960 *
10961 * @details
10962 *
10963 *    Function : procGnbDuUpdate
10964 *
10965 *    Functionality:
10966 *         - processing of Gnb-DU config update
10967 *
10968 * @params[in] F1AP_PDU_t *f1apMsg
10969 * @return ROK     - success
10970 *         RFAILED - failure
10971 *
10972 * ****************************************************************/
10973 uint8_t procGnbDuUpdate(uint32_t duId, F1AP_PDU_t *f1apMsg)
10974 {
10975    bool cellToBeDelete = false;
10976    uint8_t ieIdx = 0, ueIdx = 0, duIdx = 0, cellIdx=0;
10977    uint16_t nrCellId;
10978    DuDb *duDb;
10979    CuCellCb *cellCb;
10980    GNBDUConfigurationUpdate_t *duCfgUpdate = NULLP;
10981
10982    duCfgUpdate = &f1apMsg->choice.initiatingMessage->value.choice.GNBDUConfigurationUpdate;
10983    for(ieIdx=0; ieIdx < duCfgUpdate->protocolIEs.list.count; ieIdx++)
10984    {
10985       switch(duCfgUpdate->protocolIEs.list.array[ieIdx]->id)
10986       {
10987          case ProtocolIE_ID_id_TransactionID:
10988             break;
10989          case ProtocolIE_ID_id_Served_Cells_To_Modify_List:
10990             break;
10991          case ProtocolIE_ID_id_Served_Cells_To_Delete_List:
10992             {
10993                struct Served_Cells_To_Delete_ItemIEs *deleteItemIe = \
10994                   (struct Served_Cells_To_Delete_ItemIEs *)duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.\
10995                   Served_Cells_To_Delete_List.list.array[0];
10996                nrCellId = deleteItemIe->value.choice.Served_Cells_To_Delete_Item.oldNRCGI.nRCellIdentity.buf[4] >>\
10997                   deleteItemIe->value.choice.Served_Cells_To_Delete_Item.oldNRCGI.nRCellIdentity.bits_unused;
10998                cellToBeDelete = true;
10999                break;
11000             }
11001          case ProtocolIE_ID_id_gNB_DU_ID:
11002             break;
11003       }
11004    }
11005    if(BuildAndSendDUUpdateAck(duId) != ROK)
11006    {
11007       DU_LOG("ERROR  -->  F1AP : Failed to build and send DUUpdateAck");
11008       return RFAILED;
11009    }
11010 #if 0
11011    /* We don't require F1 Reset message in Cell Up and Broadcast Procedure flow, So that's why
11012     * commented this trigger for now */
11013
11014    if(cellToBeDelete == false)
11015    {
11016       DU_LOG("\nINFO  -->  F1AP : Sending F1 reset request");
11017       if(BuildAndSendF1ResetReq() != ROK)
11018       {
11019          DU_LOG("ERROR  -->  F1AP : Failed to build and send F1 reset request");
11020          return RFAILED;
11021       }
11022    }
11023 #endif
11024    if(cellToBeDelete == true)
11025    {
11026       SEARCH_DU_DB(duIdx, duId, duDb);
11027       SEARCH_CELL_DB(cellIdx, duDb, nrCellId, cellCb);
11028       for(ueIdx = 0; ueIdx < cellCb->numUe; ueIdx++)
11029       {
11030          CU_FREE(cellCb->ueCb[ueIdx]->f1apMsgDb.duToCuContainer.buf, cellCb->ueCb[ueIdx]->f1apMsgDb.duToCuContainer.size);
11031          memset(cellCb->ueCb[ueIdx], 0, sizeof(CuUeCb));
11032       }
11033    }
11034
11035    return ROK;
11036 }
11037
11038 /*******************************************************************
11039 *
11040 * @brief storing slice list in CU database
11041 *
11042 * @details
11043 *
11044 *    Function : buildSliceList
11045 *
11046 *    Functionality:
11047 *         - storing slice list in CU database
11048 *
11049 * @params[in] SliceSupportList_t *sliceSupportList
11050 * @return ROK     - success
11051 *         RFAILED - failure
11052 *
11053 * ****************************************************************/
11054 uint8_t buildSliceList(SliceSupportList_t *sliceSupportList)
11055 {
11056    uint8_t sliceListIdx = 0;
11057
11058    if(sliceSupportList)
11059    {
11060       if(sliceSupportList->list.array)
11061       {
11062          cuCb.numSnssaiSupported = sliceSupportList->list.count;
11063          for(sliceListIdx=0; sliceListIdx<sliceSupportList->list.count; sliceListIdx++)
11064          {
11065             if(sliceSupportList->list.array[sliceListIdx])
11066             {
11067                CU_ALLOC(cuCb.snssaiList[sliceListIdx], sizeof(Snssai));
11068                if(cuCb.snssaiList[sliceListIdx] == NULLP)
11069                {
11070                    DU_LOG("\nERROR  --> CU_STUB: buildSliceList(): Memory allocation failed");
11071                    return RFAILED;
11072                }
11073                if(sliceSupportList->list.array[sliceListIdx]->sNSSAI.sST.buf)
11074                {
11075                   memcpy(&cuCb.snssaiList[sliceListIdx]->sst, sliceSupportList->list.array[sliceListIdx]->\
11076                   sNSSAI.sST.buf, sliceSupportList->list.array[sliceListIdx]->sNSSAI.sST.size);
11077                }
11078                if(sliceSupportList->list.array[sliceListIdx]->sNSSAI.sD->size)
11079                {
11080                   memcpy(&cuCb.snssaiList[sliceListIdx]->sd,\
11081                   sliceSupportList->list.array[sliceListIdx]->sNSSAI.sD->buf,\
11082                   sliceSupportList->list.array[sliceListIdx]->sNSSAI.sD->size);
11083                }
11084             }
11085          }
11086       }
11087    }
11088    return ROK;
11089 }
11090
11091 /****************************************************************
11092  * @brief Function to process Srb Setup Mod List
11093  *
11094  * @details
11095  *
11096  *    Function : procSrbSetupModList
11097  *
11098  *    Functionality:
11099  *         - Function to process SRB Setup Mod List
11100  *
11101  * @params[in]
11102  * @return ROK     - success
11103  *         RFAILED - failure
11104  *
11105  * ****************************************************************/
11106 uint8_t procSrbSetupModList(CuUeCb *ueCb, SRBs_SetupMod_List_t *srbSetupList)
11107 {
11108    uint8_t arrIdx = 0, srbIdx;
11109    struct SRBs_SetupMod_ItemIEs *srbItemIe = NULLP;
11110
11111    if(srbSetupList != NULLP)
11112    {
11113       for(arrIdx = 0; arrIdx < srbSetupList->list.count; arrIdx++)
11114       {
11115          srbItemIe = ((struct SRBs_SetupMod_ItemIEs *)srbSetupList->list.array[arrIdx]);
11116          if(srbItemIe->value.present == SRBs_SetupMod_ItemIEs__value_PR_SRBs_SetupMod_Item)
11117          {
11118             for(srbIdx = 0; srbIdx < ueCb->numSrb; srbIdx++)
11119             {
11120                if(ueCb->srbList[srbIdx].srbId == srbItemIe->value.choice.SRBs_SetupMod_Item.sRBID)
11121                {
11122                   ueCb->srbList[srbIdx].lcId = srbItemIe->value.choice.SRBs_SetupMod_Item.lCID;
11123                   break;
11124                }
11125             }
11126          }
11127
11128       }
11129    }
11130    return ROK;
11131 }
11132
11133
11134 /****************************************************************
11135  * @brief Function to process Drb Setup Mod List
11136  *
11137  * @details
11138  *
11139  *    Function : procDrbSetupModList
11140  *
11141  *    Functionality:
11142  *         - Function to process DRB Setup Mod List
11143  *
11144  * @params[in]
11145  * @return ROK     - success
11146  *         RFAILED - failure
11147  *
11148  * ****************************************************************/
11149 uint8_t procDrbSetupModList(CuUeCb *ueCb, DRBs_SetupMod_List_t *drbSetupList)
11150 {
11151    uint8_t arrIdx = 0, drbIdx;
11152    uint32_t teId = 0;
11153    struct DRBs_SetupMod_ItemIEs *drbItemIe = NULLP;
11154
11155    if(drbSetupList != NULLP)
11156    {
11157       for(arrIdx = 0; arrIdx < drbSetupList->list.count; arrIdx++)
11158       {
11159          drbItemIe = ((struct DRBs_SetupMod_ItemIEs *)drbSetupList->list.array[arrIdx]);
11160          if(drbItemIe->value.present == DRBs_SetupMod_ItemIEs__value_PR_DRBs_SetupMod_Item)
11161          {
11162             for(drbIdx = 0; drbIdx < ueCb->numDrb; drbIdx++)
11163             {
11164                if(ueCb->drbList[drbIdx].drbId == drbItemIe->value.choice.DRBs_SetupMod_Item.dRBID)
11165                {
11166                   if(drbItemIe->value.choice.DRBs_SetupMod_Item.lCID)
11167                      ueCb->drbList[drbIdx].lcId = *(drbItemIe->value.choice.DRBs_SetupMod_Item.lCID);
11168                   break;
11169                }
11170             }
11171
11172             if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
11173             {
11174             /* extracting teId */
11175             teId  = extractTeId(&drbItemIe->value.choice.DRBs_SetupMod_Item.dLUPTNLInformation_ToBeSetup_List);
11176             if(teId > 0)
11177             {
11178               if(addDrbTunnels(teId)== ROK)
11179               {
11180                 DU_LOG("\nDEBUG  --> EGTP: Tunnel Added for TeId %d", teId);
11181               }
11182             }
11183             else
11184                return RFAILED;
11185             }
11186          }
11187       }
11188    }
11189    return ROK;
11190 }
11191
11192 /*******************************************************************
11193 *
11194 * @brief processing of GNB_DU_Served_Cells Plmn list  information
11195 *
11196 * @details
11197 *
11198 *    Function : procServedCellPlmnList
11199 *
11200 *    Functionality:
11201 *         - processing of GNB_DU_Served_Cells Plmn list information for storing
11202 *         SNSSAI list
11203 *
11204 * @params[in] F1AP_PDU_t *f1apMsg
11205 * @return ROK     - success
11206 *         RFAILED - failure
11207 *
11208 * ****************************************************************/
11209 uint8_t procServedCellPlmnList(ServedPLMNs_List_t *srvPlmn)
11210 {
11211    uint8_t srvPlmnIdx=0, ieExtensionsLstIdx=0;
11212    ProtocolExtensionContainer_4624P3_t **ieExtend;
11213
11214    if(srvPlmn->list.array)
11215    {
11216       for(srvPlmnIdx=0; srvPlmnIdx<srvPlmn->list.count; srvPlmnIdx++)
11217       {
11218          if(srvPlmn->list.array[srvPlmnIdx])
11219          {
11220             ieExtend =  &srvPlmn->list.array[srvPlmnIdx]->iE_Extensions;
11221             if(*ieExtend)
11222             {
11223                if((*ieExtend)->list.array)
11224                {
11225                   for(ieExtensionsLstIdx = 0; ieExtensionsLstIdx<(*ieExtend)->list.count; ieExtensionsLstIdx++)
11226                   {
11227                      if((*ieExtend)->list.array[ieExtensionsLstIdx])
11228                      {
11229                         switch((*ieExtend)->list.array[ieExtensionsLstIdx]->id )
11230                         {
11231                            case ProtocolIE_ID_id_TAISliceSupportList:
11232                               {
11233                                  if(buildSliceList(&(*ieExtend)->list.array[ieExtensionsLstIdx]->\
11234                                           extensionValue.choice.SliceSupportList) != ROK)
11235                                  {
11236                                     DU_LOG("\nERROR  --> CU_STUB: procServedCellPlmnList(): Failed to build slice List");
11237                                     return RFAILED;
11238                                  }
11239                               }
11240                         }
11241                      }
11242                   }
11243                }
11244             }
11245          }
11246       }
11247    }
11248    return ROK;
11249 }
11250
11251 /****************************************************************
11252  * @brief Function to process Ue Context Modification Response
11253  *
11254  * @details
11255  *
11256  *    Function : procUeContextModificationResponse
11257  *
11258  *    Functionality:
11259  *         - Function to process Ue Context Modification Response
11260  *
11261  * @params[in]
11262  * @return ROK     - success
11263  *         RFAILED - failure
11264  *
11265  * ****************************************************************/
11266 uint8_t procUeContextModificationResponse(uint32_t duId, F1AP_PDU_t *f1apMsg)
11267 {
11268    uint8_t idx=0, duIdx=0, duUeF1apId;
11269    DuDb *duDb;
11270    CuUeCb *ueCb;
11271    UEContextModificationResponse_t *ueCtxtModRsp = NULLP;
11272
11273    SEARCH_DU_DB(duIdx, duId, duDb);
11274    ueCtxtModRsp = &f1apMsg->choice.successfulOutcome->value.choice.UEContextModificationResponse;
11275
11276    for(idx=0; idx < ueCtxtModRsp->protocolIEs.list.count; idx++)
11277    {
11278       switch(ueCtxtModRsp->protocolIEs.list.array[idx]->id)
11279       {
11280           case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
11281              {
11282                 duUeF1apId = ueCtxtModRsp->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID;
11283                 ueCb = &duDb->ueCb[duUeF1apId-1];
11284                 break;
11285              }
11286           case ProtocolIE_ID_id_DRBs_SetupMod_List:
11287              {
11288                 /* Adding Tunnels for successful DRB */
11289                 procDrbSetupModList(ueCb, &ueCtxtModRsp->protocolIEs.list.array[idx]->value.choice.DRBs_SetupMod_List);
11290                 break;
11291
11292              }
11293           case ProtocolIE_ID_id_SRBs_SetupMod_List:
11294              {
11295                 procSrbSetupModList(ueCb, &ueCtxtModRsp->protocolIEs.list.array[idx]->value.choice.SRBs_SetupMod_List);
11296                 break;
11297              }
11298          case ProtocolIE_ID_id_DUtoCURRCInformation:
11299              {
11300                 DU_LOG("\nINFO  -->  Received Du to Cu RRC Information ");
11301                 if((extractDuToCuRrcCont(ueCb, ueCtxtModRsp->protocolIEs.list.array[idx]->value.choice.\
11302                    DUtoCURRCInformation.cellGroupConfig)) != ROK)
11303                 {
11304                    DU_LOG("\nERROR  -->  F1AP : Failed to extract Du to Cu RRC Information");
11305                    return RFAILED;
11306                 }
11307                 break;
11308              }
11309
11310       }
11311    }
11312    if(ueCb->state == UE_HANDOVER_IN_PROGRESS)
11313    {
11314       BuildAndSendUeContextSetupReq(ueCb->hoInfo.targetDuId, ueCb, 0, NULLP);
11315       return ROK;
11316    }
11317
11318    return ROK;
11319 }
11320
11321 /*******************************************************************
11322 *
11323 * @brief processing of F1 setup request
11324 *
11325 * @details
11326 *
11327 *    Function : procF1SetupReq
11328 *
11329 *    Functionality:
11330 *         - processing of  F1 setup request
11331 *
11332 * @params[in] F1AP_PDU_t *f1apMsg
11333 * @return ROK     - success
11334 *         RFAILED - failure
11335 *
11336 * ****************************************************************/
11337 void procF1SetupReq(uint32_t *destDuId, F1AP_PDU_t *f1apMsg)
11338 {
11339    uint8_t ieIdx = 0, plmnidx=0, duIdx = 0, ret=ROK, cellIdx = 0;
11340    uint32_t duId = 0, nrCellId = 0;
11341    DuDb     *duDb = NULLP;
11342    CuCellCb *cellCb = NULLP;
11343    BIT_STRING_t nrcellIdentity;
11344    F1SetupRequest_t *f1SetupReq = NULLP;
11345    GNB_DU_Served_Cells_Item_t *srvCellItem = NULLP;
11346    GNB_DU_Served_Cells_List_t *duServedCell = NULLP;
11347
11348    f1SetupReq = &f1apMsg->choice.initiatingMessage->value.choice.F1SetupRequest;
11349    for(ieIdx=0; ieIdx < f1SetupReq->protocolIEs.list.count; ieIdx++)
11350    {
11351       switch(f1SetupReq->protocolIEs.list.array[ieIdx]->id)
11352       {
11353          case ProtocolIE_ID_id_gNB_DU_ID:
11354            {
11355               duId = f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf[0];
11356               SEARCH_DU_DB(duIdx, duId, duDb);
11357               if(duDb == NULLP)
11358               {
11359                  duDb = &cuCb.duInfo[cuCb.numDu];
11360                  memset(duDb, 0, sizeof(DuDb));
11361                  duDb->duId = duId;
11362                  cuCb.numDu++;
11363                  *destDuId = duId;
11364               }
11365               else
11366                  return;
11367               break;
11368            }
11369          case ProtocolIE_ID_id_gNB_DU_Name:
11370            {
11371               strcpy((char *)duDb->duName, (char*)f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_Name.buf);
11372               break;
11373            }
11374          case ProtocolIE_ID_id_gNB_DU_Served_Cells_List:
11375            {
11376                duServedCell = &f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_Served_Cells_List;
11377                if(duServedCell->list.array)
11378                {
11379                   for(plmnidx=0; plmnidx<duServedCell->list.count; plmnidx++)
11380                   {
11381                      if(duServedCell->list.array[plmnidx])
11382                      {
11383                         switch(duServedCell->list.array[plmnidx]->id)
11384                         {
11385                            case ProtocolIE_ID_id_GNB_DU_Served_Cells_Item:
11386                            {
11387                               srvCellItem =  &duServedCell->list.array[plmnidx]->value.choice.GNB_DU_Served_Cells_Item;
11388                               ret = procServedCellPlmnList(&srvCellItem->served_Cell_Information.servedPLMNs);
11389                               memcpy(&nrcellIdentity, &srvCellItem->served_Cell_Information.nRCGI.nRCellIdentity, sizeof(BIT_STRING_t));
11390
11391                               nrCellId = nrcellIdentity.buf[4] >> nrcellIdentity.bits_unused;
11392                               SEARCH_CELL_DB(cellIdx, duDb, nrCellId, cellCb);
11393                               if(cellCb == NULLP)
11394                               {
11395                                  cellCb = &duDb->cellCb[duDb->numCells];
11396                                  memset(cellCb, 0, sizeof(CuCellCb));
11397                                  cellCb->nrCellId = nrCellId;
11398                                  duDb->numCells++;
11399                               }
11400                            }
11401                         }
11402                      }
11403                   }
11404                }
11405            }
11406       }
11407    }
11408    if(ret == ROK)
11409    {
11410       BuildAndSendF1SetupRsp(duId, &nrcellIdentity);
11411    }
11412    else
11413    {
11414        DU_LOG("\nERROR  --> CU_STUB: procF1SetupReq(): Failed to process F1 setup request");
11415    }
11416 }
11417
11418 /****************************************************************
11419 *
11420 * @brief processing of UE Context Release Complete
11421 *
11422 * @details
11423 *
11424 *    Function : procUeContextReleaseComplete
11425 *
11426 *    Functionality:
11427 *         - processing of UE Context Release Complete
11428 *
11429 * @params[in] F1AP_PDU_t *f1apMsg
11430 * @return ROK     - success
11431 *         RFAILED - failure
11432 *
11433 * ****************************************************************/
11434 void procUeContextReleaseComplete(uint32_t duId, F1AP_PDU_t *f1apMsg)
11435 {
11436    uint8_t duIdx = 0, ieIdx = 0, ueIdx = 0;
11437    uint8_t gnbDuUeF1apId = 0, gnbCuUeF1apId = 0;
11438    DuDb *duDb = NULLP;
11439    CuUeCb *ueCb = NULLP;
11440    UEContextReleaseComplete_t *ueReleaseComplete = NULLP;
11441
11442    SEARCH_DU_DB(duIdx, duId, duDb);
11443    if(!duDb)
11444    {
11445       DU_LOG("\nERROR  -->  F1AP : No entry found for DU ID [%d]", duId);
11446       return;
11447    }
11448
11449    ueReleaseComplete = &f1apMsg->choice.successfulOutcome->value.choice.UEContextReleaseComplete;
11450    for(ieIdx=0; ieIdx < ueReleaseComplete->protocolIEs.list.count; ieIdx++)
11451    {
11452       switch(ueReleaseComplete->protocolIEs.list.array[ieIdx]->id)
11453       {
11454          case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
11455             {
11456                gnbCuUeF1apId = ueReleaseComplete->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID;
11457                break;
11458             }
11459          case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
11460             {
11461                gnbDuUeF1apId = ueReleaseComplete->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID;
11462                ueCb = &duDb->ueCb[gnbDuUeF1apId-1];
11463
11464                for(ueIdx = 0; ueIdx < ueCb->cellCb->numUe; ueIdx++)
11465                {
11466                   if((ueCb->cellCb->ueCb[ueIdx]->gnbCuUeF1apId == gnbCuUeF1apId) &&
11467                         (ueCb->cellCb->ueCb[ueIdx]->gnbDuUeF1apId == gnbDuUeF1apId))
11468                   {
11469                      ueCb->cellCb->ueCb[ueIdx] = NULLP;
11470                      ueCb->cellCb->numUe--;
11471                      break;
11472
11473                   }
11474                }
11475                memset(ueCb, 0, sizeof(CuUeCb));
11476                duDb->numUe--;
11477                break;
11478             }
11479       }
11480    }
11481 }
11482
11483 /*******************************************************************
11484  *
11485  * @brief Handles received F1AP message and sends back response
11486  *
11487  * @details
11488  *
11489  *    Function : F1APMsgHdlr
11490  *
11491  *    Functionality:
11492  *         - Decodes received F1AP control message
11493  *         - Prepares response message, encodes and sends to SCTP
11494  *
11495  * @params[in]
11496  * @return ROK     - success
11497  *         RFAILED - failure
11498  *
11499  * ****************************************************************/
11500 void F1APMsgHdlr(uint32_t *duId, Buffer *mBuf)
11501 {
11502    int i;
11503    char *recvBuf;
11504    MsgLen copyCnt;
11505    MsgLen recvBufLen;
11506    F1AP_PDU_t *f1apMsg = NULLP;
11507    asn_dec_rval_t rval; /* Decoder return value */
11508    F1AP_PDU_t f1apasnmsg ;
11509
11510    DU_LOG("\nINFO  -->  F1AP : Received F1AP message buffer");
11511    ODU_PRINT_MSG(mBuf, 0,0);
11512
11513    /* Copy mBuf into char array to decode it */
11514    ODU_GET_MSG_LEN(mBuf, &recvBufLen);
11515    CU_ALLOC(recvBuf, (Size)recvBufLen);
11516
11517    if(recvBuf == NULLP)
11518    {
11519       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed");
11520       return;
11521    }
11522    if(ODU_COPY_MSG_TO_FIX_BUF(mBuf, 0, recvBufLen, (Data *)recvBuf, &copyCnt) != ROK)
11523    {
11524       DU_LOG("\nERROR  -->  F1AP : Failed while copying %d", copyCnt);
11525       return;
11526    }
11527
11528    DU_LOG("\nDEBUG  -->  F1AP : Received flat buffer to be decoded : ");
11529    for(i=0; i< recvBufLen; i++)
11530    {
11531       DU_LOG("%x",recvBuf[i]);
11532    }
11533
11534    /* Decoding flat buffer into F1AP messsage */
11535    f1apMsg = &f1apasnmsg;
11536    memset(f1apMsg, 0, sizeof(F1AP_PDU_t));
11537
11538    rval = aper_decode(0, &asn_DEF_F1AP_PDU, (void **)&f1apMsg, recvBuf, recvBufLen, 0, 0);
11539    CU_FREE(recvBuf, (Size)recvBufLen);
11540
11541    if(rval.code == RC_FAIL || rval.code == RC_WMORE)
11542    {
11543       DU_LOG("\nERROR  -->  F1AP : ASN decode failed");
11544       return;
11545    }
11546    DU_LOG("\n");
11547    xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
11548
11549    switch(f1apMsg->present)
11550    {
11551       case F1AP_PDU_PR_initiatingMessage:
11552          {
11553             switch(f1apMsg->choice.initiatingMessage->value.present)
11554             {
11555                case InitiatingMessage__value_PR_Reset:
11556                   {
11557                      DU_LOG("\nINFO  -->  F1AP : F1 reset request received ");
11558                      BuildAndSendF1ResetAck();
11559                      break;
11560                   }
11561
11562                case InitiatingMessage__value_PR_F1SetupRequest:
11563                   {
11564                      DU_LOG("\nINFO  -->  F1AP : F1 setup request received");
11565                      procF1SetupReq(duId, f1apMsg);
11566                      break;
11567                   }
11568
11569                case InitiatingMessage__value_PR_GNBDUConfigurationUpdate:
11570                   {
11571                      DU_LOG("\nINFO  -->  F1AP : GNB-DU config update received");
11572                      procGnbDuUpdate(*duId, f1apMsg);
11573                      break;
11574                   }
11575                case InitiatingMessage__value_PR_InitialULRRCMessageTransfer:
11576                   {
11577                      DU_LOG("\nINFO  -->  F1AP : Received InitialULRRCMessageTransfer");
11578                      procInitULRRCMsg(*duId, f1apMsg);
11579                      break;
11580                   }
11581                case InitiatingMessage__value_PR_ULRRCMessageTransfer:
11582                   {
11583                      DU_LOG("\nINFO  -->  F1AP : Received ULRRCMessageTransfer");
11584                      procUlRrcMsg(*duId, f1apMsg);
11585                      break;
11586                   }
11587
11588                case InitiatingMessage__value_PR_RRCDeliveryReport:
11589                   {
11590                      DU_LOG("\nINFO  -->  F1AP : Received RRC delivery report");
11591                      break;
11592                   }
11593                case InitiatingMessage__value_PR_UEContextReleaseRequest:
11594                   {
11595                      DU_LOG("\nINFO  -->  F1AP : Received UE Context Release Request");
11596                      procUeContextReleaseReq(*duId, f1apMsg);
11597                      break;
11598                   }
11599                default:
11600                   {
11601                      DU_LOG("\nERROR  -->  F1AP : Invalid type of intiating message [%d]",\
11602                            f1apMsg->choice.initiatingMessage->value.present);
11603                      return;
11604                   }
11605             }/* End of switch(initiatingMessage) */
11606             break;
11607          }
11608
11609       case F1AP_PDU_PR_successfulOutcome:
11610          {
11611             switch(f1apMsg->choice.successfulOutcome->value.present)
11612             {
11613                case SuccessfulOutcome__value_PR_ResetAcknowledge:
11614                   {
11615                      DU_LOG("\nINFO  -->  F1Reset Acknowledgement is received successfully ");
11616                      break;
11617                   }
11618                case SuccessfulOutcome__value_PR_UEContextSetupResponse:
11619                   {
11620                      DU_LOG("\nINFO  -->  F1AP : UE ContextSetupResponse received");
11621                      procUeContextSetupResponse(*duId, f1apMsg);
11622                      break;
11623                   }
11624                case SuccessfulOutcome__value_PR_UEContextModificationResponse:
11625                   {
11626                      DU_LOG("\nINFO  -->  F1AP : UE Context Modification Response received");
11627                      procUeContextModificationResponse(*duId, f1apMsg);
11628                      break;
11629                   }
11630                case SuccessfulOutcome__value_PR_UEContextReleaseComplete:
11631                   {
11632                       DU_LOG("\nINFO  -->  F1AP : UE Context release complete received");
11633                       procUeContextReleaseComplete(*duId, f1apMsg);
11634                       break;
11635                   }
11636                default:
11637                   {
11638                      DU_LOG("\nERROR  -->  F1AP : Invalid type of successful outcome message [%d]",\
11639                            f1apMsg->choice.successfulOutcome->value.present);
11640                      return;
11641                   }
11642             }/* End of switch(successfulOutcome) */
11643             break;
11644          }
11645       default:
11646          {
11647             DU_LOG("\nERROR  -->  F1AP : Invalid type of f1apMsg->present [%d]",f1apMsg->present);
11648             return;
11649          }
11650    }/* End of switch(f1apMsg->present) */
11651
11652 } /* End of F1APMsgHdlr */
11653
11654 /**********************************************************************
11655   End of file
11656  **********************************************************************/