src/cu_stub/cu_f1ap_msg_hdl.c

   1 /*******************************************************************************
   2 ################################################################################
   3 #   Copyright (c) [2017-2019] [Radisys]                                        #
   4 #                                                                              #
   5 #   Licensed under the Apache License, Version 2.0 (the "License");            #
   6 #   you may not use this file except in compliance with the License.           #
   7 #   You may obtain a copy of the License at                                    #
   8 #                                                                              #
   9 #       http://www.apache.org/licenses/LICENSE-2.0                             #
  10 #                                                                              #
  11 #   Unless required by applicable law or agreed to in writing, software        #
  12 #   distributed under the License is distributed on an "AS IS" BASIS,          #
  13 #   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.   #
  14 #   See the License for the specific language governing permissions and        #
  15 #   limitations under the License.                                             #
  16 ################################################################################
  17 *******************************************************************************/
  18
  19 /* This file contains F1AP message handler functions */
  20 #include "common_def.h"
  21 #include "OCTET_STRING.h"
  22 #include "BIT_STRING.h"
  23 #include "odu_common_codec.h"
  24 #include "ProtocolIE-Field.h"
  25 #include "ProtocolExtensionField.h"
  26 #include "ProtocolIE-SingleContainer.h"
  27 #include "F1AP-PDU.h"
  28 #include "ModulationOrder.h"
  29 #include "BandNR.h"
  30 #include "UE-CapabilityRAT-Container.h"
  31 #include "UE-CapabilityRAT-ContainerList.h"
  32 #include "UE-CapabilityRAT-ContainerListRRC.h"
  33 #include "HandoverPreparationInformationRrc-IEs.h"
  34 #include "HandoverPreparationInformationRrc.h"
  35 #include "SupportedBandwidth.h"
  36 #include "FeatureSetUplinkPerCC.h"
  37 #include "FeatureSetDownlinkPerCC.h"
  38 #include "FeatureSets.h"
  39 #include "RF-Parameters.h"
  40 #include "UE-NR-Capability.h"
  41 #include "ProtocolExtensionContainer.h"
  42 #include "CellGroupConfigRrc.h"
  43 #include "MAC-CellGroupConfig.h"
  44 #include "SchedulingRequestConfig.h"
  45 #include "SchedulingRequestToAddMod.h"
  46 #include "BSR-Config.h"
  47 #include "TAG-Config.h"
  48 #include "TAG.h"
  49 #include "PHR-Config.h"
  50 #include "RLC-Config.h"
  51 #include "UL-AM-RLC.h"
  52 #include "DL-AM-RLC.h"
  53 #include "LogicalChannelConfig.h"
  54 #include "RLC-BearerConfig.h"
  55 #include "PhysicalCellGroupConfig.h"
  56 #include "SpCellConfig.h"
  57 #include "ServingCellConfig.h"
  58 #include "ControlResourceSet.h"
  59 #include "SearchSpace.h"
  60 #include "PDCCH-Config.h"
  61 #include "PDSCH-TimeDomainResourceAllocation.h"
  62 #include "PDSCH-TimeDomainResourceAllocationList.h"
  63 #include "DMRS-DownlinkConfig.h"
  64 #include "PDSCH-Config.h"
  65 #include "BWP-DownlinkDedicated.h"
  66 #include "PUSCH-TimeDomainResourceAllocation.h"
  67 #include "PUSCH-TimeDomainResourceAllocationList.h"
  68 #include "DMRS-UplinkConfig.h"
  69 #include "PUSCH-Config.h"
  70 #include "SRS-ResourceId.h"
  71 #include "SRS-Resource.h"
  72 #include "SRS-ResourceSet.h"
  73 #include "SRS-Config.h"
  74 #include "PUCCH-Config.h"
  75 #include "PUCCH-ResourceSet.h"
  76 #include "PUCCH-Resource.h"
  77 #include "PUCCH-format1.h"
  78 #include "PUCCH-FormatConfig.h"
  79 #include "BWP-UplinkDedicated.h"
  80 #include "PUSCH-ServingCellConfig.h"
  81 #include "UplinkConfig.h"
  82 #include "PDSCH-ServingCellConfig.h"
  83 #include "EUTRANQoS.h"
  84 #include "GBR-QosInformation.h"
  85 #include "DRBs-ToBeSetupMod-List.h"
  86 #include "DRBs-ToBeSetupMod-Item.h"
  87 #include "DRBs-Setup-Item.h"
  88 #include "DLUPTNLInformation-ToBeSetup-List.h"
  89 #include "DLUPTNLInformation-ToBeSetup-Item.h"
  90 #include "UPTransportLayerInformation.h"
  91 #include "GTPTunnel.h"
  92 #include "QoSInformation.h"
  93 #include "Cells-to-be-Activated-List.h"
  94 #include "DL-CCCH-Message.h"
  95 #include "SRB-ToAddModList.h"
  96 #include "SRB-ToAddMod.h"
  97 #include "RRCSetup-IEs.h"
  98 #include "RRCSetup.h"
  99 #include "DL-DCCH-Message.h"
 100 #include "RRCReconfiguration-IEs.h"
 101 #include "RRCReconfiguration.h"
 102 #include "DRB-ToAddModList.h"
 103 #include "DRB-ToAddMod.h"
 104 #include "SDAP-Config.h"
 105 #include "SSB-MTC.h"
 106 #include "MeasTiming.h"
 107 #include "MeasTimingList.h"
 108 #include "MeasurementTimingConfigurationRrc-IEs.h"
 109 #include "MeasurementTimingConfigurationRrc.h"
 110 #include "PDCP-Config.h"
 111 #include "RSRP-Range.h"
 112 #include "RSRQ-Range.h"
 113 #include "SINR-Range.h"
 114 #include "ThresholdNR.h"
 115 #include "MeasObjectToAddMod.h"
 116 #include "MeasObjectNR.h"
 117 #include "MeasObjectToAddModList.h"
 118 #include "EventTriggerConfig.h"
 119 #include "ReportConfigNR.h"
 120 #include "ReportConfigToAddMod.h"
 121 #include "ReportConfigToAddModList.h"
 122 #include "MeasIdToAddMod.h"
 123 #include "MeasIdToAddModList.h"
 124 #include "FilterCoefficient.h"
 125 #include "QuantityConfigNR.h"
 126 #include "QuantityConfig.h"
 127 #include "MeasConfigRrc.h"
 128 #include "AS-Config.h"
 129 #include "RRCReconfiguration-v1530-IEs.h"
 130 #include "CNUEPagingIdentity.h"
 131 #include "PagingCell-Item.h"
 132 #include "UL-DCCH-Message.h"
 133
 134 #include "cu_stub_sctp.h"
 135 #include "cu_stub_egtp.h"
 136 #include "cu_f1ap_msg_hdl.h"
 137 #include "cu_stub.h"
 138
 139 uint8_t fillCellGrpCfg(CuUeCb *ueCb, OCTET_STRING_t *cellGrp, bool updateAllRbCfg);
 140 uint8_t fillRrcReconfig(CuUeCb *ueCb, RRCReconfiguration_t *rrcReconfig, bool updateAllRbCfg);
 141
 142 /*******************************************************************
 143  *
 144  * @brief Sends F1 msg over SCTP
 145  *
 146  * @details
 147  *
 148  *    Function : SendF1APMsg
 149  *
 150  *    Functionality: Sends F1 msg over SCTP
 151  *
 152  * @params[in] Region region
 153  *             Pool pool
 154  * @return ROK     - success
 155  *         RFAILED - failure
 156  *
 157  * ****************************************************************/
 158 S16 SendF1APMsg(Region region, Pool pool, uint32_t duId)
 159 {
 160    Buffer *mBuf = NULLP;
 161
 162    if(ODU_GET_MSG_BUF(region, pool, &mBuf) == ROK)
 163    {
 164       if(ODU_ADD_POST_MSG_MULT((Data *)encBuf, encBufSize, mBuf) == ROK)
 165       {
 166          ODU_PRINT_MSG(mBuf, 0,0);
 167
 168          if(sctpSend(duId, mBuf) != ROK)
 169          {
 170             DU_LOG("\nERROR  -->  F1AP : SCTP Send failed");
 171             ODU_PUT_MSG_BUF(mBuf);
 172             return RFAILED;
 173          }
 174       }
 175       else
 176       {
 177          DU_LOG("\nERROR  -->  F1AP : ODU_ADD_POST_MSG_MULT failed");
 178          ODU_PUT_MSG_BUF(mBuf);
 179          return RFAILED;
 180       }
 181       ODU_PUT_MSG_BUF(mBuf);
 182    }
 183    else
 184    {
 185       DU_LOG("\nERROR  -->  F1AP : Failed to allocate memory");
 186       return RFAILED;
 187    }
 188
 189    return ROK;
 190 } /* SendF1APMsg */
 191
 192 /*******************************************************************
 193  *
 194  * @brief Builds NRCell ID
 195  *
 196  * @details
 197  *
 198  *    Function : BuildNrCellId
 199  *
 200  *    Functionality: Building the NR Cell ID
 201  *
 202  * @params[in] BIT_STRING_t *nrcell
 203  * @return ROK     - success
 204  *         RFAILED - failure
 205  *
 206  * ****************************************************************/
 207
 208 S16 BuildNrCellId(BIT_STRING_t *nrcell)
 209 {
 210    memset(nrcell->buf, 0, nrcell->size);
 211    nrcell->buf[4]   = 16;
 212    nrcell->bits_unused = 4;
 213    nrcell->size = 5 * sizeof(uint8_t);
 214    return ROK;
 215 }
 216
 217 /********************************************************************
 218  *
 219  * @brief Builds and sends the F1SetupResponse
 220  *
 221  * @details
 222  *
 223  *    Function : BuildAndSendF1SetupRsp
 224  *
 225  *    Functionality: Constructs the F1SetupResponse message and sends
 226  *                   it back to the DU through SCTP.
 227  *
 228  * @params[in] void **buf,Buffer to which encoded pattern is written into
 229  * @params[in] int *size,size of buffer
 230  *
 231  * @return ROK     - success
 232  *         RFAILED - failure
 233  *
 234  * ****************************************************************/
 235 uint8_t BuildAndSendF1SetupRsp(uint32_t duId, BIT_STRING_t *nrcellId)
 236 {
 237    uint8_t    idx,ieIdx;
 238    uint8_t    elementCnt,cellCnt;
 239    F1AP_PDU_t         *f1apMsg = NULL;
 240    F1SetupResponse_t  *f1SetupRsp;
 241    GNB_CU_Name_t      *cuName;
 242    Cells_to_be_Activated_List_t *cellToActivate;
 243    RRC_Version_t      *rrcVer;
 244    asn_enc_rval_t     encRetVal;
 245    DU_LOG("\nINFO  -->  F1AP : Building F1 Setup Response\n");
 246
 247    /* Allocate the memory for F1SetupRequest_t */
 248    CU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
 249    if(f1apMsg == NULLP)
 250    {
 251       DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
 252       return RFAILED;
 253    }
 254    f1apMsg->present =  F1AP_PDU_PR_successfulOutcome;
 255
 256    CU_ALLOC(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 257    if(f1apMsg->choice.successfulOutcome == NULLP)
 258    {
 259       DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
 260       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 261       return RFAILED;
 262    }
 263
 264    f1apMsg->choice.successfulOutcome->procedureCode = ProcedureCode_id_F1Setup;
 265    f1apMsg->choice.successfulOutcome->criticality = Criticality_reject;
 266    f1apMsg->choice.successfulOutcome->value.present = \
 267                                                       SuccessfulOutcome__value_PR_F1SetupResponse;
 268    f1SetupRsp = &f1apMsg->choice.successfulOutcome->value.choice.F1SetupResponse;
 269
 270    elementCnt = 4;
 271    f1SetupRsp->protocolIEs.list.count = elementCnt;
 272    f1SetupRsp->protocolIEs.list.size = elementCnt*sizeof(F1SetupResponseIEs_t *);
 273
 274    CU_ALLOC(f1SetupRsp->protocolIEs.list.array, \
 275          elementCnt * sizeof(F1SetupResponseIEs_t *));
 276    if(f1SetupRsp->protocolIEs.list.array == NULLP)
 277    {
 278       DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1ResponseIEs failed");
 279       CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 280       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 281       return RFAILED;
 282    }
 283
 284    for(idx=0; idx<elementCnt; idx++)
 285    {
 286       CU_ALLOC(f1SetupRsp->protocolIEs.list.array[idx], \
 287             sizeof(F1SetupResponseIEs_t));
 288       if(f1SetupRsp->protocolIEs.list.array[idx] == NULLP)
 289       {
 290          CU_FREE(f1SetupRsp->protocolIEs.list.array,\
 291                elementCnt * sizeof(F1SetupResponseIEs_t *));
 292          CU_FREE(f1apMsg->choice.successfulOutcome, \
 293                sizeof(SuccessfulOutcome_t));
 294          CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 295          return RFAILED;
 296       }
 297    }
 298
 299    /*TransactionID*/
 300    idx = 0;
 301    f1SetupRsp->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_TransactionID;
 302    f1SetupRsp->protocolIEs.list.array[idx]->criticality = Criticality_reject;
 303    f1SetupRsp->protocolIEs.list.array[idx]->value.present = \
 304                                                             F1SetupResponseIEs__value_PR_TransactionID;
 305    f1SetupRsp->protocolIEs.list.array[idx]->value.choice.TransactionID =\
 306                                                                         TRANS_ID;
 307
 308    /*CU Name*/
 309    idx++;
 310    f1SetupRsp->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_gNB_CU_Name;
 311    f1SetupRsp->protocolIEs.list.array[idx]->criticality = Criticality_ignore;
 312    f1SetupRsp->protocolIEs.list.array[idx]->value.present = \
 313                                                             F1SetupResponseIEs__value_PR_GNB_CU_Name;
 314    cuName = &f1SetupRsp->protocolIEs.list.array[idx]->value.choice.GNB_CU_Name;
 315    cuName->size = sizeof(cuCb.cuCfgParams.cuName);
 316
 317    CU_ALLOC(cuName->buf, sizeof(cuName->size));
 318    if(cuName->buf == NULLP)
 319    {
 320       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
 321       {
 322          CU_FREE(f1SetupRsp->protocolIEs.list.array[ieIdx],\
 323                sizeof(F1SetupResponseIEs_t));
 324       }
 325       CU_FREE(f1SetupRsp->protocolIEs.list.array,\
 326             elementCnt * sizeof(F1SetupResponseIEs_t *));
 327       CU_FREE(f1apMsg->choice.successfulOutcome,\
 328             sizeof(SuccessfulOutcome_t));
 329       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 330       return RFAILED;
 331    }
 332    strcpy((char*)cuName->buf, (char*)cuCb.cuCfgParams.cuName);
 333
 334    /*Cells to be activated list*/
 335    idx++;
 336    f1SetupRsp->protocolIEs.list.array[idx]->id = \
 337                                                  ProtocolIE_ID_id_Cells_to_be_Activated_List ;
 338    f1SetupRsp->protocolIEs.list.array[idx]->criticality = Criticality_reject;
 339    f1SetupRsp->protocolIEs.list.array[idx]->value.present = \
 340                                                             F1SetupResponseIEs__value_PR_Cells_to_be_Activated_List;
 341    cellToActivate = &f1SetupRsp->protocolIEs.list.array[idx]->value.choice.\
 342                     Cells_to_be_Activated_List;
 343    cellCnt=1;
 344    cellToActivate->list.count = cellCnt;
 345    cellToActivate->list.size = \
 346                                cellCnt*sizeof(struct Cells_to_be_Activated_List_ItemIEs  *);
 347    CU_ALLOC(cellToActivate->list.array,\
 348          sizeof(struct Cells_to_be_Activated_List_ItemIEs  *));
 349    if(cellToActivate->list.array == NULLP)
 350    {
 351       CU_FREE(cuName->buf, sizeof(cuName->size));
 352       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
 353       {
 354          CU_FREE(f1SetupRsp->protocolIEs.list.array[ieIdx],\
 355                sizeof(F1SetupResponseIEs_t));
 356       }
 357       CU_FREE(f1SetupRsp->protocolIEs.list.array,\
 358             elementCnt * sizeof(F1SetupResponseIEs_t *));
 359       CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 360       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 361       return RFAILED;
 362    }
 363    for(ieIdx=0; ieIdx<cellCnt; ieIdx++)
 364    {
 365       CU_ALLOC(cellToActivate->list.array[ieIdx],sizeof(struct Cells_to_be_Activated_List_ItemIEs ));
 366       if(cellToActivate->list.array[ieIdx] == NULLP)
 367       {
 368          CU_FREE(cellToActivate->list.array,\
 369                sizeof(struct Cells_to_be_Activated_List_ItemIEs  *));
 370          CU_FREE(cuName->buf, sizeof(cuName->size));
 371          for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
 372          {
 373             CU_FREE(f1SetupRsp->protocolIEs.list.array[ieIdx], \
 374                   sizeof(F1SetupResponseIEs_t));
 375          }
 376          CU_FREE(f1SetupRsp->protocolIEs.list.array, \
 377                elementCnt * sizeof(F1SetupResponseIEs_t *));
 378          CU_FREE(f1apMsg->choice.successfulOutcome, \
 379                sizeof(SuccessfulOutcome_t));
 380          CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 381          return RFAILED;
 382       }
 383    }
 384    cellToActivate->list.array[0]->id = \
 385                                        ProtocolIE_ID_id_Cells_to_be_Activated_List_Item;
 386    cellToActivate->list.array[0]->criticality = Criticality_ignore;
 387    cellToActivate->list.array[0]->value.present = \
 388                                                   Cells_to_be_Activated_List_ItemIEs__value_PR_Cells_to_be_Activated_List_Item;
 389    cellToActivate->list.array[0]->value.choice.Cells_to_be_Activated_List_Item.\
 390       nRCGI.pLMN_Identity.size = 3*sizeof(uint8_t);
 391    CU_ALLOC(cellToActivate->list.array[0]->\
 392          value.choice.Cells_to_be_Activated_List_Item.nRCGI.pLMN_Identity.buf,\
 393          3*sizeof(uint8_t));
 394    if(cellToActivate->list.array[0]->value.choice.\
 395          Cells_to_be_Activated_List_Item.nRCGI.pLMN_Identity.buf == NULLP)
 396    {
 397
 398       for(ieIdx=0; ieIdx<cellCnt; ieIdx++)
 399       {
 400          CU_FREE(cellToActivate->list.array[ieIdx],\
 401                sizeof(struct Cells_to_be_Activated_List_ItemIEs ));
 402       }
 403
 404       CU_FREE(cellToActivate->list.array,\
 405             sizeof(struct Cells_to_be_Activated_List_ItemIEs  *));
 406       CU_FREE(cuName->buf, sizeof(cuName->size));
 407       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
 408       {
 409          CU_FREE(f1SetupRsp->protocolIEs.list.array[ieIdx], \
 410                sizeof(F1SetupResponseIEs_t));
 411       }
 412       CU_FREE(f1SetupRsp->protocolIEs.list.array, \
 413             elementCnt * sizeof(F1SetupResponseIEs_t *));
 414       CU_FREE(f1apMsg->choice.successfulOutcome, \
 415             sizeof(SuccessfulOutcome_t));
 416       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 417       return RFAILED;
 418    }
 419    buildPlmnId(cuCb.cuCfgParams.plmn , cellToActivate->list.array[0]->value.choice.\
 420          Cells_to_be_Activated_List_Item.nRCGI.pLMN_Identity.buf);
 421    cellToActivate->list.array[0]->value.choice.Cells_to_be_Activated_List_Item.\
 422       nRCGI.nRCellIdentity.size = 5;
 423    CU_ALLOC(cellToActivate->list.array[0]->value.choice.\
 424          Cells_to_be_Activated_List_Item.nRCGI.nRCellIdentity.buf,\
 425          5*sizeof(uint8_t));
 426    if(cellToActivate->list.array[0]->value.choice.\
 427          Cells_to_be_Activated_List_Item.nRCGI.nRCellIdentity.buf == NULLP)
 428    {
 429       CU_FREE(cellToActivate->list.array[0]->\
 430             value.choice.Cells_to_be_Activated_List_Item.nRCGI.pLMN_Identity.buf,\
 431             3*sizeof(uint8_t));
 432       for(ieIdx=0; ieIdx<cellCnt; ieIdx++)
 433       {
 434          CU_FREE(cellToActivate->list.array[ieIdx],\
 435                sizeof(struct Cells_to_be_Activated_List_ItemIEs ));
 436       }
 437
 438       CU_FREE(cellToActivate->list.array,\
 439             sizeof(struct Cells_to_be_Activated_List_ItemIEs  *));
 440       CU_FREE(cuName->buf, sizeof(cuName->size));
 441       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
 442       {
 443          CU_FREE(f1SetupRsp->protocolIEs.list.array[ieIdx], \
 444                sizeof(F1SetupResponseIEs_t));
 445       }
 446       CU_FREE(f1SetupRsp->protocolIEs.list.array, \
 447             elementCnt * sizeof(F1SetupResponseIEs_t *));
 448       CU_FREE(f1apMsg->choice.successfulOutcome, \
 449             sizeof(SuccessfulOutcome_t));
 450       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 451       return RFAILED;
 452    }
 453    memcpy(&cellToActivate->list.array[0]->value.choice.Cells_to_be_Activated_List_Item.nRCGI.nRCellIdentity, nrcellId, sizeof(BIT_STRING_t));
 454    /* RRC Version */
 455    idx++;
 456    f1SetupRsp->protocolIEs.list.array[idx]->id = \
 457                                                  ProtocolIE_ID_id_GNB_CU_RRC_Version;
 458    f1SetupRsp->protocolIEs.list.array[idx]->criticality = Criticality_reject;
 459    f1SetupRsp->protocolIEs.list.array[idx]->value.present = \
 460                                                             F1SetupResponseIEs__value_PR_RRC_Version;
 461    rrcVer = &f1SetupRsp->protocolIEs.list.array[idx]->value.choice.RRC_Version;
 462    rrcVer->latest_RRC_Version.size = RRC_SIZE;
 463
 464    CU_ALLOC(rrcVer->latest_RRC_Version.buf, sizeof(uint8_t));
 465    if(rrcVer->latest_RRC_Version.buf == NULLP)
 466    {
 467       CU_FREE(cuName->buf, sizeof(cuName->size));
 468       for(ieIdx=0; ieIdx<elementCnt; idx++)
 469       {
 470          CU_FREE(f1SetupRsp->protocolIEs.list.array[ieIdx], \
 471                sizeof(F1SetupResponseIEs_t));
 472       }
 473       CU_FREE(f1SetupRsp->protocolIEs.list.array,\
 474             elementCnt * sizeof(F1SetupResponseIEs_t *));
 475       CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 476       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 477       return RFAILED;
 478    }
 479
 480    /* Need to check RRC Version */
 481    rrcVer->latest_RRC_Version.buf[0] = cuCb.cuCfgParams.rrcVersion.rrcVer;
 482    rrcVer->latest_RRC_Version.bits_unused = 5; //TODO: pick from cuCfgParam. If not present, add it
 483    CU_ALLOC(rrcVer->iE_Extensions,sizeof(ProtocolExtensionContainer_4624P81_t));
 484    if(rrcVer->iE_Extensions == NULLP)
 485    {
 486       CU_FREE(rrcVer->latest_RRC_Version.buf, sizeof(uint8_t));
 487       CU_FREE(cuName->buf, sizeof(cuName->size));
 488       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
 489       {
 490          CU_FREE(f1SetupRsp->protocolIEs.list.array[ieIdx], \
 491                sizeof(F1SetupResponseIEs_t));
 492       }
 493       CU_FREE(f1SetupRsp->protocolIEs.list.array,\
 494             elementCnt * sizeof(F1SetupResponseIEs_t *));
 495       CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 496       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 497       return RFAILED;
 498    }
 499    rrcVer->iE_Extensions->list.count = 1;
 500    rrcVer->iE_Extensions->list.size = sizeof(struct RRC_Version_ExtIEs *);
 501    CU_ALLOC(rrcVer->iE_Extensions->list.array,\
 502          sizeof(struct RRC_Version_ExtIEs *));
 503    if(rrcVer->iE_Extensions->list.array == NULLP)
 504    {
 505       CU_FREE(rrcVer->iE_Extensions,\
 506             sizeof(ProtocolExtensionContainer_4624P81_t));
 507       CU_FREE(rrcVer->latest_RRC_Version.buf, sizeof(uint8_t));
 508       CU_FREE(cuName->buf, sizeof(cuName->size));
 509       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
 510       {
 511          CU_FREE(f1SetupRsp->protocolIEs.list.array[ieIdx], \
 512                sizeof(F1SetupResponseIEs_t));
 513       }
 514       CU_FREE(f1SetupRsp->protocolIEs.list.array,\
 515             elementCnt * sizeof(F1SetupResponseIEs_t *));
 516       CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 517       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 518       return RFAILED;
 519    }
 520    CU_ALLOC(rrcVer->iE_Extensions->list.array[0],\
 521          sizeof(struct RRC_Version_ExtIEs));
 522    if(rrcVer->iE_Extensions->list.array[0] == NULLP)
 523    {
 524       CU_FREE(rrcVer->iE_Extensions->list.array,\
 525             sizeof(struct RRC_Version_ExtIEs *));
 526       CU_FREE(rrcVer->iE_Extensions,\
 527             sizeof(ProtocolExtensionContainer_4624P81_t));
 528       CU_FREE(rrcVer->latest_RRC_Version.buf, sizeof(uint8_t));
 529       CU_FREE(cuName->buf, sizeof(cuName->size));
 530       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
 531       {
 532          CU_FREE(f1SetupRsp->protocolIEs.list.array[ieIdx], \
 533                sizeof(F1SetupResponseIEs_t));
 534       }
 535       CU_FREE(f1SetupRsp->protocolIEs.list.array,\
 536             elementCnt * sizeof(F1SetupResponseIEs_t *));
 537       CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 538       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 539       return RFAILED;
 540    }
 541    rrcVer->iE_Extensions->list.array[0]->id = \
 542                                               ProtocolIE_ID_id_latest_RRC_Version_Enhanced;
 543    rrcVer->iE_Extensions->list.array[0]->criticality = Criticality_reject;
 544    rrcVer->iE_Extensions->list.array[0]->extensionValue.present = \
 545                                                                   RRC_Version_ExtIEs__extensionValue_PR_Latest_RRC_Version_Enhanced;
 546    rrcVer->iE_Extensions->list.array[0]->extensionValue.choice.\
 547       Latest_RRC_Version_Enhanced.size = 3*sizeof(uint8_t);
 548    CU_ALLOC(rrcVer->iE_Extensions->list.\
 549          array[0]->extensionValue.choice.Latest_RRC_Version_Enhanced.buf,\
 550          3*sizeof(uint8_t));
 551    if(rrcVer->iE_Extensions->list.\
 552          array[0]->extensionValue.choice.Latest_RRC_Version_Enhanced.buf == NULLP)
 553    {
 554       CU_FREE(rrcVer->iE_Extensions->list.array[0],\
 555             sizeof(struct RRC_Version_ExtIEs));
 556       CU_FREE(rrcVer->iE_Extensions->list.array,\
 557             sizeof(struct RRC_Version_ExtIEs *));
 558       CU_FREE(rrcVer->iE_Extensions,\
 559             sizeof(ProtocolExtensionContainer_4624P81_t));
 560       CU_FREE(rrcVer->latest_RRC_Version.buf, sizeof(uint8_t));
 561       CU_FREE(cuName->buf, sizeof(cuName->size));
 562       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
 563       {
 564          CU_FREE(f1SetupRsp->protocolIEs.list.array[ieIdx], \
 565                sizeof(F1SetupResponseIEs_t));
 566       }
 567       CU_FREE(f1SetupRsp->protocolIEs.list.array,\
 568             elementCnt * sizeof(F1SetupResponseIEs_t *));
 569       CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 570       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 571       return RFAILED;
 572    }
 573    rrcVer->iE_Extensions->list.array[0]->extensionValue.choice.\
 574       Latest_RRC_Version_Enhanced.buf[0] = 0;
 575    rrcVer->iE_Extensions->list.array[0]->extensionValue.choice.\
 576       Latest_RRC_Version_Enhanced.buf[1] = 5;
 577    rrcVer->iE_Extensions->list.array[0]->extensionValue.choice.\
 578       Latest_RRC_Version_Enhanced.buf[2] = 15;
 579
 580    xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
 581
 582    /* Encode the F1SetupRequest type as UPER */
 583    memset(encBuf, 0, ENC_BUF_MAX_LEN);
 584    encBufSize = 0;
 585    encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
 586
 587    /* Clean up */
 588    CU_FREE(rrcVer->latest_RRC_Version.buf, sizeof(uint8_t));
 589    CU_FREE(cuName->buf, sizeof(cuName->size));
 590    for(idx=0; idx<elementCnt; idx++)
 591    {
 592       CU_FREE(f1SetupRsp->protocolIEs.list.array[idx], sizeof(F1SetupResponseIEs_t));
 593    }
 594    CU_FREE(f1SetupRsp->protocolIEs.list.array, elementCnt * sizeof(F1SetupResponseIEs_t *));
 595    CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 596    CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 597
 598    /* Check encode results */
 599    if(encRetVal.encoded == ENCODE_FAIL)
 600    {
 601       DU_LOG("\nERROR  -->  F1AP : Could not encode F1SetupResponse structure (at %s)\n",\
 602             encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
 603       return RFAILED;
 604    }
 605    else
 606    {
 607       DU_LOG("\nDEBUG  -->  F1AP : Created APER encoded buffer for F1SetupResponse\n");
 608       for(int i=0; i< encBufSize; i++)
 609       {
 610          DU_LOG("%x",encBuf[i]);
 611       }
 612    }
 613
 614    /* Sending msg */
 615    if(SendF1APMsg(CU_APP_MEM_REG, CU_POOL, duId) != ROK)
 616    {
 617       DU_LOG("\nERROR  -->  F1AP : Sending F1 Setup Response failed");
 618       return RFAILED;
 619    }
 620
 621    return ROK;
 622 }/* End of BuildAndSendF1SetupRsp */
 623
 624 /*******************************************************************
 625  *
 626  * @brief Builds and sends the DUUpdateAcknowledge
 627  *
 628  * @details
 629  *
 630  *    Function : BuildAndSendDUUpdateAck
 631  *
 632  *    Functionality: Constructs the DU Update Acknowledge message and sends
 633  *                   it to the DU through SCTP.
 634  *
 635  * @params[in]
 636  *
 637  * @return ROK     - success
 638  *         RFAILED - failure
 639  *
 640  * ****************************************************************/
 641
 642 uint8_t BuildAndSendDUUpdateAck(uint32_t duId)
 643 {
 644    uint8_t   idx;
 645    uint8_t   elementCnt;
 646    F1AP_PDU_t *f1apMsg = NULL;
 647    GNBDUConfigurationUpdateAcknowledge_t *gNBDuCfgAck;
 648    asn_enc_rval_t enRetVal; /* Encoder return value */
 649
 650    DU_LOG("\nINFO  -->  F1AP : Building GNB-DU Config Update Ack\n");
 651
 652    /* Allocate the memory for F1SetupRequest_t */
 653    CU_ALLOC(f1apMsg, (Size)sizeof(F1AP_PDU_t));
 654    if(f1apMsg == NULLP)
 655    {
 656       DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
 657       return RFAILED;
 658    }
 659
 660    f1apMsg->present =  F1AP_PDU_PR_successfulOutcome;
 661
 662    CU_ALLOC(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 663    if(f1apMsg->choice.successfulOutcome == NULLP)
 664    {
 665       DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
 666       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 667       return RFAILED;
 668    }
 669
 670    f1apMsg->choice.successfulOutcome->procedureCode = ProcedureCode_id_gNBDUConfigurationUpdate;
 671    f1apMsg->choice.successfulOutcome->criticality = Criticality_reject;
 672    f1apMsg->choice.successfulOutcome->value.present = SuccessfulOutcome__value_PR_GNBDUConfigurationUpdateAcknowledge;
 673    gNBDuCfgAck = &f1apMsg->choice.successfulOutcome->value.choice.GNBDUConfigurationUpdateAcknowledge;
 674
 675    elementCnt = 1;
 676    gNBDuCfgAck->protocolIEs.list.count = elementCnt;
 677    gNBDuCfgAck->protocolIEs.list.size = elementCnt*sizeof(GNBDUConfigurationUpdateAcknowledgeIEs_t);
 678
 679    /* Initialize the F1Setup members */
 680    CU_ALLOC(gNBDuCfgAck->protocolIEs.list.array, elementCnt * sizeof(GNBDUConfigurationUpdateAcknowledgeIEs_t *));
 681    if(gNBDuCfgAck->protocolIEs.list.array == NULLP)
 682    {
 683       DU_LOG("\nERROR  -->  F1AP : Memory allocation for DuUpdateAcknowledgeIEs failed");
 684       CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 685       CU_FREE(f1apMsg,(Size)sizeof(F1AP_PDU_t));
 686       return RFAILED;
 687    }
 688
 689    for(idx=0; idx<elementCnt; idx++)
 690    {
 691       CU_ALLOC(gNBDuCfgAck->protocolIEs.list.array[idx], sizeof(GNBDUConfigurationUpdateAcknowledgeIEs_t));
 692       if(gNBDuCfgAck->protocolIEs.list.array[idx] == NULLP)
 693       {
 694          CU_FREE(gNBDuCfgAck->protocolIEs.list.array, elementCnt * sizeof(GNBDUConfigurationUpdateAcknowledgeIEs_t *));
 695          CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 696          CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 697          return RFAILED;
 698       }
 699    }
 700
 701    /*TransactionID*/
 702    idx = 0;
 703    gNBDuCfgAck->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_TransactionID ;
 704    gNBDuCfgAck->protocolIEs.list.array[idx]->criticality = Criticality_reject;
 705    gNBDuCfgAck->protocolIEs.list.array[idx]->value.present =\
 706    GNBDUConfigurationUpdateAcknowledgeIEs__value_PR_TransactionID;
 707    gNBDuCfgAck->protocolIEs.list.array[idx]->value.choice.TransactionID = TRANS_ID;
 708
 709    xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
 710
 711    /* Encode the F1SetupRequest type as UPER */
 712    memset(encBuf, 0, ENC_BUF_MAX_LEN);
 713    encBufSize = 0;
 714    enRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
 715
 716    /* Clean up */
 717    for(idx=0; idx<elementCnt; idx++)
 718    {
 719       CU_FREE(gNBDuCfgAck->protocolIEs.list.array[idx], sizeof(GNBDUConfigurationUpdateAcknowledgeIEs_t));
 720    }
 721    CU_FREE(gNBDuCfgAck->protocolIEs.list.array, elementCnt * sizeof(GNBDUConfigurationUpdateAcknowledgeIEs_t *));
 722    CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 723    CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 724
 725    /* Checking encode results */
 726    if(enRetVal.encoded == ENCODE_FAIL)
 727    {
 728       DU_LOG("\nERROR  -->  F1AP : Could not encode DUConfigUpdateAcknowledge structure (at %s)",\
 729       enRetVal.failed_type ? enRetVal.failed_type->name : "unknown");
 730       return RFAILED;
 731    }
 732    else
 733    {
 734       DU_LOG("\nDEBUG  -->  F1AP : Created APER encoded buffer for DuConfigUpdateAcknowledge\n");
 735       for(int i=0; i< encBufSize; i++)
 736       {
 737          DU_LOG("%x",encBuf[i]);
 738       }
 739    }
 740
 741    /* Sending msg */
 742    /* TODO : Hardcoding DU ID to 1 for messages other than F1 Setup Response. This will be made generic in future gerrit */
 743    if(SendF1APMsg(CU_APP_MEM_REG, CU_POOL, duId) != ROK)
 744    {
 745       DU_LOG("\nERROR  -->  F1AP : Sending GNB-DU Config Update Ack failed");
 746       return RFAILED;
 747    }
 748
 749    return ROK;
 750
 751 }/* End of BuildAndSendDUUpdateAck*/
 752
 753 /*******************************************************************
 754 *
 755 * @brief deallocating the memory of  F1reset msg
 756 *
 757 * @details
 758 *
 759 *    Function : FreeF1ResetReq
 760 *
 761 *    Functionality :
 762 *         - freeing memory of F1reset request msg
 763 *
 764 * @params[in]
 765 * @return void
 766 *
 767 *
 768 * ****************************************************************/
 769 void FreeF1ResetReq(F1AP_PDU_t *f1apMsg)
 770 {
 771    uint8_t idx = 0;
 772    Reset_t *f1ResetMsg = NULLP;
 773
 774    if(f1apMsg)
 775    {
 776       if(f1apMsg->choice.initiatingMessage)
 777       {
 778          f1ResetMsg = &f1apMsg->choice.initiatingMessage->value.choice.Reset;
 779          if(f1ResetMsg->protocolIEs.list.array)
 780          {
 781             for(idx=0 ;idx < f1ResetMsg->protocolIEs.list.count ; idx++)
 782             {
 783                if(f1ResetMsg->protocolIEs.list.array[idx])
 784                {
 785                   CU_FREE(f1ResetMsg->protocolIEs.list.array[idx],sizeof(ResetIEs_t));
 786                }
 787             }
 788             CU_FREE(f1ResetMsg->protocolIEs.list.array,f1ResetMsg->protocolIEs.list.size);
 789          }
 790          CU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
 791       }
 792       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 793    }
 794 }
 795 /*******************************************************************
 796  *
 797  * @brief build ansld ans send f1reset msg
 798  *
 799  * @details
 800  *
 801  *    Function : BuildAndSendF1ResetReq
 802  *
 803  *    Functionality: build and send f1reset msg
 804  *
 805  * @return ROK     - success
 806  *         RFAILED - failure
 807  *
 808  * ****************************************************************/
 809 uint8_t BuildAndSendF1ResetReq()
 810 {
 811    uint8_t          elementCnt=0;
 812    uint8_t          idx=0;
 813    uint8_t          ret= RFAILED;
 814    Reset_t          *f1ResetMsg = NULLP;
 815    F1AP_PDU_t       *f1apMsg = NULLP;
 816    asn_enc_rval_t   encRetVal;
 817    DU_LOG("\nINFO  -->  F1AP : Building F1 Reset request \n");
 818    do
 819    {
 820       CU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
 821       if(f1apMsg == NULLP)
 822       {
 823          DU_LOG("\nERROR  -->  F1AP : Memory allocation for the BuildAndSendF1ResetReq's F1AP-PDU failed");
 824          break;
 825       }
 826       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
 827       CU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
 828       if(f1apMsg->choice.initiatingMessage == NULLP)
 829       {
 830          DU_LOG("\nERROR  -->  F1AP : Memory allocation for BuildAndSendF1ResetReq failed");
 831          break;
 832       }
 833       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_Reset;
 834       f1apMsg->choice.initiatingMessage->criticality = Criticality_reject;
 835       f1apMsg->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_Reset;
 836
 837       f1ResetMsg = &f1apMsg->choice.initiatingMessage->value.choice.Reset;
 838
 839       elementCnt = 3;
 840       f1ResetMsg->protocolIEs.list.count = elementCnt;
 841       f1ResetMsg->protocolIEs.list.size = elementCnt * sizeof(ResetIEs_t *);
 842
 843       /* Initialize the F1Reset members */
 844       CU_ALLOC(f1ResetMsg->protocolIEs.list.array,f1ResetMsg->protocolIEs.list.size);
 845       if(f1ResetMsg->protocolIEs.list.array == NULLP)
 846       {
 847          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed for BuildAndSendF1ResetReq");
 848          break;
 849       }
 850       for(idx=0; idx<elementCnt; idx++)
 851       {
 852          CU_ALLOC(f1ResetMsg->protocolIEs.list.array[idx],sizeof(ResetIEs_t));
 853          if(f1ResetMsg->protocolIEs.list.array[idx] == NULLP)
 854          {
 855             DU_LOG("\nERROR  -->  F1AP : Memory allocation failed for BuildAndSendF1ResetReq msg array");
 856             break;
 857          }
 858       }
 859
 860       /*TransactionID*/
 861       idx=0;
 862       f1ResetMsg->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_TransactionID;
 863       f1ResetMsg->protocolIEs.list.array[idx]->criticality = Criticality_reject;
 864       f1ResetMsg->protocolIEs.list.array[idx]->value.present = ResetIEs__value_PR_TransactionID;
 865       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.TransactionID = 1;
 866
 867       /*Cause*/
 868       idx++;
 869       f1ResetMsg->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_Cause;
 870       f1ResetMsg->protocolIEs.list.array[idx]->criticality = Criticality_ignore;
 871       f1ResetMsg->protocolIEs.list.array[idx]->value.present = ResetIEs__value_PR_Cause;
 872       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.Cause.present = Cause_PR_radioNetwork;
 873       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.Cause.choice.radioNetwork = CauseRadioNetwork_action_desirable_for_radio_reasons;
 874
 875       /*Reset Type*/
 876       idx++;
 877       f1ResetMsg->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_ResetType;
 878       f1ResetMsg->protocolIEs.list.array[idx]->criticality = Criticality_reject;
 879       f1ResetMsg->protocolIEs.list.array[idx]->value.present = ResetIEs__value_PR_ResetType;
 880       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.ResetType.present = ResetType_PR_f1_Interface;
 881       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.ResetType.choice.f1_Interface = ResetAll_reset_all;
 882
 883       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
 884
 885       /* Encode the F1SetupRequest type as APER */
 886       memset(encBuf, 0, ENC_BUF_MAX_LEN);
 887       encBufSize = 0;
 888       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
 889             encBuf);
 890
 891       /* Encode results */
 892       if(encRetVal.encoded == ENCODE_FAIL)
 893       {
 894          DU_LOG("\nERROR  -->  F1AP : Could not encode F1Reset structure (at %s)\n",\
 895                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
 896          break;
 897       }
 898       else
 899       {
 900          DU_LOG("\nDEBUG  -->  F1AP : Created APER encoded buffer for F1Reset\n");
 901          for(idx=0; idx< encBufSize; idx++)
 902          {
 903             DU_LOG("%x",encBuf[idx]);
 904          }
 905       }
 906
 907       /* TODO : Hardcoding DU ID to 1 for messages other than F1 Setup Response. This will be made generic in future gerrit */
 908       if(SendF1APMsg(CU_APP_MEM_REG, CU_POOL, DU_ID) != ROK)
 909       {
 910          DU_LOG("\nERROR  -->  F1AP : Sending F1 Reset request failed");
 911          break;
 912       }
 913
 914       ret = ROK;
 915       break;
 916    }while(true);
 917
 918    FreeF1ResetReq(f1apMsg);
 919    return ret;
 920 }
 921
 922 /*******************************************************************
 923  *
 924  * @brief Fills Radio Bearer Config
 925  *
 926  * @details
 927  *
 928  *    Function : fillSrbCfg
 929  *
 930  *    Functionality: Fills Radio Bearer Config
 931  *
 932  * @params[in] SRB_ToAddModList *
 933  *
 934  * @return ROK     - success
 935  *         RFAILED - failure
 936  *
 937  * ****************************************************************/
 938 uint8_t fillSrbCfg(CuUeCb *ueCb, SRB_ToAddModList_t *bearerCfg)
 939 {
 940    uint8_t elementCnt = 0;
 941    uint8_t idx, ieId, srbIdx = 0;
 942
 943    for(srbIdx=0; srbIdx < ueCb->numSrb; srbIdx++)
 944    {
 945       if(ueCb->srbList[srbIdx].cfgSentToUe == false)
 946          elementCnt++;
 947    }
 948
 949    if(bearerCfg != NULLP)
 950    {
 951       bearerCfg->list.count = elementCnt;
 952       bearerCfg->list.size = elementCnt * sizeof(SRB_ToAddMod_t *);
 953       CU_ALLOC(bearerCfg->list.array, bearerCfg->list.size);
 954       if(bearerCfg->list.array != NULLP)
 955       {
 956          for(idx = 0; idx < elementCnt; idx++)
 957          {
 958             CU_ALLOC(bearerCfg->list.array[idx], sizeof(SRB_ToAddMod_t));
 959             if(bearerCfg->list.array[idx] == NULLP)
 960             {
 961                for(ieId = 0; ieId < idx; ieId++)
 962                {
 963                   CU_FREE(bearerCfg->list.array[ieId], sizeof(SRB_ToAddMod_t));
 964                }
 965                CU_FREE(bearerCfg->list.array, bearerCfg->list.size);
 966                return RFAILED;
 967             }
 968          }
 969       }
 970       else
 971       {
 972          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed for bearer list arry in fillSrbCfg");
 973          return RFAILED;
 974       }
 975
 976       idx = 0;
 977       for(srbIdx=0; srbIdx < ueCb->numSrb; srbIdx++)
 978       {
 979          if(ueCb->srbList[srbIdx].cfgSentToUe == false)
 980             bearerCfg->list.array[idx++]->srb_Identity = ueCb->srbList[srbIdx].srbId;
 981       }
 982    }
 983    return ROK;
 984 }
 985
 986 /*******************************************************************
 987  *
 988  * @brief Fills Master CellGroup Info
 989  *
 990  * @details
 991  *
 992  *    Function : fillMasterCellGroup
 993  *
 994  *    Functionality: Fills Master Cell Group IE
 995  *
 996  * @params[in] RRCSetup_IEs_t *
 997  *
 998  * @return ROK     - success
 999  *         RFAILED - failure
1000  *
1001  * ****************************************************************/
1002
1003 uint8_t fillMasterCellGroup(CuUeCb *ueCb, OCTET_STRING_t *masterCellGroup)
1004 {
1005    uint8_t ret = ROK;
1006    masterCellGroup->buf = NULLP;
1007    if(ueCb->f1apMsgDb.duToCuContainer.buf)
1008    {
1009       masterCellGroup->size = ueCb->f1apMsgDb.duToCuContainer.size;
1010       CU_ALLOC(masterCellGroup->buf, masterCellGroup->size);
1011       if(masterCellGroup->buf != NULLP)
1012       {
1013          memcpy(masterCellGroup->buf, ueCb->f1apMsgDb.duToCuContainer.buf, masterCellGroup->size);
1014       }
1015       else
1016       {
1017          DU_LOG( "\nERROR  -->  F1AP : Master Cell Group buffer is NULL");
1018          ret = RFAILED;
1019       }
1020    }
1021    else
1022    {
1023       ret =  RFAILED;
1024    }
1025    return ret;
1026 }
1027
1028 /*******************************************************************
1029  *
1030  * @brief Fills RRC setup IE
1031  *
1032  * @details
1033  *
1034  *    Function : fillRRCSetupIE
1035  *
1036  *    Functionality: Fills RRC Setup IE
1037  *
1038  * @params[in] RRCSetup_IEs_t *
1039  *
1040  * @return ROK     - success
1041  *         RFAILED - failure
1042  *
1043  * ****************************************************************/
1044
1045 uint8_t fillRRCSetupIE(CuUeCb *ueCb, RRCSetup_IEs_t *rrcSetupIE)
1046 {
1047    uint8_t ret = ROK, srbIdx = 0;
1048    if(rrcSetupIE)
1049    {
1050       CU_ALLOC(rrcSetupIE->radioBearerConfig.srb_ToAddModList, sizeof(SRB_ToAddModList_t));
1051       if(rrcSetupIE->radioBearerConfig.srb_ToAddModList != NULLP)
1052       {
1053          ret = fillSrbCfg(ueCb, rrcSetupIE->radioBearerConfig.srb_ToAddModList);
1054       }
1055       if(ret == ROK)
1056       {
1057          ret = fillCellGrpCfg(ueCb, &rrcSetupIE->masterCellGroup, false);
1058       }
1059       else
1060       {
1061          CU_FREE(rrcSetupIE->radioBearerConfig.srb_ToAddModList, sizeof(SRB_ToAddModList_t));
1062          ret = RFAILED;
1063       }
1064
1065       /* If SRB configuration are filled successfully in RRC Setup, mark these
1066        * configurartion as sent to UE */
1067       for(srbIdx=0; srbIdx < ueCb->numSrb; srbIdx++)
1068       {
1069          if(ueCb->srbList[srbIdx].cfgSentToUe == false)
1070             ueCb->srbList[srbIdx].cfgSentToUe = true;
1071       }
1072    }
1073    return ret;
1074 }
1075 /*******************************************************************
1076  *
1077  * @brief Fills DL DCCCH Message required for DLRRCMessageTransfer
1078  *
1079  * @details
1080  *
1081  *    Function : fillDlCcchRrcMsg
1082  *
1083  *    Functionality: Fills DL DCCCH Message required for
1084  *                   DLRRCMessageTransfer
1085  *
1086  * @params[in] RRCContainer_t *rrcContainer
1087  *
1088  * @return ROK     - success
1089  *         RFAILED - failure
1090  *
1091  * ****************************************************************/
1092
1093 uint8_t fillDlCcchRrcMsg(CuUeCb *ueCb, RRCContainer_t *rrcContainer)
1094 {
1095    uint8_t ret = ROK;
1096    uint16_t idx2;
1097    DL_CCCH_Message_t dl_CCCH_Msg;
1098    asn_enc_rval_t    encRetVal;
1099
1100    if(rrcContainer != NULLP)
1101    {
1102       dl_CCCH_Msg.message.present = DL_CCCH_MessageType_PR_c1;
1103
1104       CU_ALLOC(dl_CCCH_Msg.message.choice.c1 , sizeof(DL_CCCH_MessageType_t));
1105       if(dl_CCCH_Msg.message.choice.c1 != NULLP)
1106       {
1107          dl_CCCH_Msg.message.choice.c1->present = DL_CCCH_MessageType__c1_PR_rrcSetup;
1108          CU_ALLOC(dl_CCCH_Msg.message.choice.c1->choice.rrcSetup, sizeof(RRCSetup_t));
1109          if(dl_CCCH_Msg.message.choice.c1->choice.rrcSetup != NULLP)
1110          {
1111             dl_CCCH_Msg.message.choice.c1->choice.rrcSetup->rrc_TransactionIdentifier = 0;
1112             dl_CCCH_Msg.message.choice.c1->choice.rrcSetup->criticalExtensions.present = \
1113                RRCSetup__criticalExtensions_PR_rrcSetup;
1114
1115             /* Fill RRC Setup IE */
1116             CU_ALLOC(dl_CCCH_Msg.message.choice.c1->choice.rrcSetup->criticalExtensions.choice.rrcSetup, \
1117                sizeof(RRCSetup_IEs_t));
1118             if(dl_CCCH_Msg.message.choice.c1->choice.rrcSetup->criticalExtensions.choice.rrcSetup != NULLP)
1119             {
1120                ret = fillRRCSetupIE(ueCb, dl_CCCH_Msg.message.choice.c1->choice.rrcSetup->criticalExtensions.choice.rrcSetup);
1121
1122                if(ret == ROK)
1123                {
1124                   /* encode DL-CCCH message into RRC Container */
1125                   xer_fprint(stdout, &asn_DEF_DL_CCCH_MessageType, &dl_CCCH_Msg);
1126                   memset(encBuf, 0, ENC_BUF_MAX_LEN);
1127                   encBufSize = 0;
1128                   encRetVal = aper_encode(&asn_DEF_DL_CCCH_MessageType, 0, &dl_CCCH_Msg, PrepFinalEncBuf, encBuf);
1129                   /* Encode results */
1130                   if(encRetVal.encoded == ENCODE_FAIL)
1131                   {
1132                      DU_LOG( "\nERROR  -->  F1AP : Could not encode RRCContainer for DL-CCCH Msg(at %s)\n",\
1133                            encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
1134                      return RFAILED;
1135                   }
1136                   else
1137                   {
1138                      DU_LOG("\nDEBUG  -->  F1AP : Created APER encoded buffer for RRCContainer for DL-CCCH Msg\n");
1139                      for(int i = 0; i< encBufSize; i++)
1140                      {
1141                         DU_LOG("%x",encBuf[i]);
1142                      }
1143                      rrcContainer->size = encBufSize;
1144                      CU_ALLOC(rrcContainer->buf, rrcContainer->size);
1145                      if(rrcContainer->buf != NULLP)
1146                      {
1147                         memset(rrcContainer->buf, 0, encBufSize);
1148                         for(idx2 = 0; idx2 < encBufSize; idx2++)
1149                         {
1150                            rrcContainer->buf[idx2] =    encBuf[idx2];
1151                         }
1152                      }
1153                   }
1154                }
1155                else
1156                {
1157                   ret = RFAILED;
1158                }
1159             }
1160             else
1161             {
1162                DU_LOG("\nERROR  -->  F1AP: Memory Alloc failed for RRC Setup Msg at fillDlCcchRrcMsg()");
1163                ret = RFAILED;
1164             }
1165          }
1166          else
1167          {
1168             DU_LOG("\nERROR  -->  F1AP: Memory Alloc failed for RRC Msg at fillDlCcchRrcMsg()");
1169             ret = RFAILED;
1170          }
1171       }
1172       else
1173       {
1174          DU_LOG("\nF1AP: Memory Alloc failed for DL Ccch Msg choice at fillDlCcchRrcMsg()");
1175          ret = RFAILED;
1176       }
1177    }
1178    else
1179    {
1180       DU_LOG("\nERROR  -->  F1AP: RRC Container is NULLP at fillDlCcchRrcMsg()");
1181       ret = RFAILED;
1182    }
1183 }
1184
1185 /*******************************************************************
1186  *
1187  * @brief Fills QOS flow configuration
1188  *
1189  * @details
1190  *
1191  *    Function : fillQosFlowsToAdd
1192  *
1193  *    Functionality: Fills QOS flow configuration
1194  *
1195  * @params[in] struct SDAP_Config__mappedQoS_FlowsToAdd *qosFlow
1196  *
1197  * @return ROK     - success
1198  *         RFAILED - failure
1199  *
1200  * ****************************************************************/
1201 uint8_t fillQosFlowsToAdd(struct SDAP_Config__mappedQoS_FlowsToAdd *qosFlow)
1202 {
1203    uint8_t idx, ied, elementCnt;
1204
1205    elementCnt = 1;
1206    qosFlow->list.count = elementCnt;
1207    qosFlow->list.size  = elementCnt * sizeof(QFI_t *);
1208    CU_ALLOC(qosFlow->list.array, qosFlow->list.size);
1209    if(qosFlow->list.array != NULLP)
1210    {
1211       for(idx = 0; idx < elementCnt; idx++)
1212       {
1213          CU_ALLOC(qosFlow->list.array[idx], sizeof(QFI_t));
1214          if(qosFlow->list.array[idx] == NULLP)
1215          {
1216             for(ied = 0; ied < idx; ied++)
1217             {
1218                CU_FREE(qosFlow->list.array[idx], sizeof(QFI_t));
1219             }
1220             CU_FREE(qosFlow->list.array, qosFlow->list.size);
1221             return RFAILED;
1222          }
1223       }
1224    }
1225    idx = 0;
1226    *qosFlow->list.array[idx] = 9;
1227    return ROK;
1228 }
1229
1230 /*******************************************************************
1231  *
1232  * @brief Fills CN Assoc for Drb to Add/Mod List
1233  *
1234  * @details
1235  *
1236  *    Function : fillCnAssoc
1237  *
1238  *    Functionality: Fills CN Assoc for Drb to Add/Mod List
1239  *
1240  * @params[in] struct DRB_ToAddMod__cnAssociation *
1241  *
1242  * @return ROK     - success
1243  *         RFAILED - failure
1244  *
1245  * ****************************************************************/
1246
1247 uint8_t fillCnAssoc(struct DRB_ToAddMod__cnAssociation *cnAssoc)
1248 {
1249    uint8_t ret = ROK;
1250
1251    cnAssoc->present = DRB_ToAddMod__cnAssociation_PR_sdap_Config;
1252    if(cnAssoc->present == DRB_ToAddMod__cnAssociation_PR_eps_BearerIdentity)
1253    {
1254       cnAssoc->choice.eps_BearerIdentity = 5;
1255    }
1256    if(cnAssoc->present == DRB_ToAddMod__cnAssociation_PR_sdap_Config)
1257    {
1258       CU_ALLOC(cnAssoc->choice.sdap_Config, sizeof(SDAP_Config_t));
1259       if(cnAssoc->choice.sdap_Config)
1260       {
1261          cnAssoc->choice.sdap_Config->pdu_Session = 5;
1262          cnAssoc->choice.sdap_Config->sdap_HeaderDL = 0;
1263          cnAssoc->choice.sdap_Config->sdap_HeaderUL = 0;
1264          cnAssoc->choice.sdap_Config->defaultDRB = true;
1265          cnAssoc->choice.sdap_Config->mappedQoS_FlowsToAdd = NULLP;
1266          cnAssoc->choice.sdap_Config->mappedQoS_FlowsToRelease = NULLP;
1267          CU_ALLOC(cnAssoc->choice.sdap_Config->mappedQoS_FlowsToAdd, \
1268                sizeof(struct SDAP_Config__mappedQoS_FlowsToAdd));
1269          if(cnAssoc->choice.sdap_Config->mappedQoS_FlowsToAdd)
1270          {
1271             ret = fillQosFlowsToAdd(cnAssoc->choice.sdap_Config->mappedQoS_FlowsToAdd);
1272          }
1273          else
1274          {
1275             DU_LOG("\nERROR  -->  F1AP: Memory alloc failed at mappedQoS_FlowsToAdd in fillCnAssoc()");
1276             CU_FREE(cnAssoc->choice.sdap_Config, sizeof(SDAP_Config_t));
1277             ret = RFAILED;
1278          }
1279       }
1280       else
1281       {
1282          DU_LOG("\nERROR  -->  F1AP: Mem alloc failed at fillCnAssoc()");
1283          ret = RFAILED;
1284       }
1285    }
1286    return ret;
1287 }
1288
1289 /*******************************************************************
1290  *
1291  * @brief Fills Radio Bearer Config for Drb
1292  *
1293  * @details
1294  *
1295  *    Function : fillDrbCfg
1296  *
1297  *    Functionality: Fills Radio Bearer Config for Drb
1298  *
1299  * @params[in] drbId, DRB_ToAddModList *
1300  *
1301  * @return ROK     - success
1302  *         RFAILED - failure
1303  *
1304  * ****************************************************************/
1305 uint8_t fillDrbCfg(uint8_t drbId, DRB_ToAddModList_t *drbCfg)
1306 {
1307    uint8_t idx, ied, ret, elementCnt;
1308
1309    ret = ROK;
1310    if(drbCfg != NULLP)
1311    {
1312       elementCnt = 1;
1313       drbCfg->list.count = elementCnt;
1314       drbCfg->list.size =\
1315                          elementCnt * sizeof(DRB_ToAddMod_t *);
1316       CU_ALLOC(drbCfg->list.array, drbCfg->list.size);
1317       if(drbCfg->list.array != NULLP)
1318       {
1319          for(idx = 0; idx < elementCnt; idx++)
1320          {
1321             CU_ALLOC(drbCfg->list.array[idx], sizeof(DRB_ToAddMod_t));
1322             if(drbCfg->list.array[idx] == NULLP)
1323             {
1324                for(ied = 0; ied < idx; ied++)
1325                {
1326                   CU_FREE(drbCfg->list.array[idx], sizeof(DRB_ToAddMod_t));
1327                }
1328                CU_FREE(drbCfg->list.array, drbCfg->list.size);
1329                return RFAILED;
1330             }
1331          }
1332       }
1333       else
1334       {
1335          return RFAILED;
1336       }
1337       idx = 0;
1338       /* CN ASSOCIATION */
1339       CU_ALLOC(drbCfg->list.array[idx]->cnAssociation, sizeof(struct DRB_ToAddMod__cnAssociation));
1340       if(drbCfg->list.array[idx]->cnAssociation)
1341       {
1342          ret = fillCnAssoc(drbCfg->list.array[idx]->cnAssociation);
1343       }
1344       /* DRB */
1345       drbCfg->list.array[idx]->drb_Identity = drbId;
1346    }
1347    return ret;
1348 }
1349
1350 /*******************************************************************
1351  *
1352  * @brief Fills RRC Reconfig Message required for DLRRCMessageTransfer
1353  *
1354  * @details
1355  *
1356  *    Function : fillRrcReconfigIE
1357  *
1358  *    Functionality: Fills RRC Reconfig Message required for
1359  *                   DLRRCMessageTransfer
1360  *
1361  * @params[in] RRCReconfiguration_IEs_t* rrcReconfig
1362  *
1363  * @return ROK     - success
1364  *         RFAILED - failure
1365  *
1366  * ****************************************************************/
1367
1368 uint8_t fillRrcReconfigIE(RRCReconfiguration_IEs_t *rrcReconfigMsg)
1369 {
1370    uint8_t ret = ROK;
1371    CU_ALLOC(rrcReconfigMsg->radioBearerConfig, sizeof(RadioBearerConfig_t));
1372    if(rrcReconfigMsg->radioBearerConfig)
1373    {
1374       CU_ALLOC(rrcReconfigMsg->radioBearerConfig->srb_ToAddModList, sizeof(SRB_ToAddModList_t));
1375       if(rrcReconfigMsg->radioBearerConfig->srb_ToAddModList != NULLP)
1376       {
1377          ret = fillSrbCfg(SRB2, rrcReconfigMsg->radioBearerConfig->srb_ToAddModList);
1378
1379       }
1380       if(ret == ROK)
1381       {
1382          CU_ALLOC(rrcReconfigMsg->radioBearerConfig->drb_ToAddModList, sizeof(DRB_ToAddModList_t));
1383          if(rrcReconfigMsg->radioBearerConfig->drb_ToAddModList != NULLP)
1384          {
1385             ret = fillDrbCfg(DRB1, rrcReconfigMsg->radioBearerConfig->drb_ToAddModList);
1386             if(ret == RFAILED)
1387             {
1388                DU_LOG("\nERROR  -->  F1AP : Failed to fill DrbCfg at fillRrcReconfigIE()");
1389                CU_FREE(rrcReconfigMsg->radioBearerConfig->srb_ToAddModList, sizeof(SRB_ToAddModList_t));
1390                CU_FREE(rrcReconfigMsg->radioBearerConfig->drb_ToAddModList, sizeof(DRB_ToAddModList_t));
1391             }
1392          }
1393       }
1394       else
1395       {
1396          DU_LOG("\nERROR  -->  F1AP : memory Alloc failed at fillRrcReconfigIE()");
1397          CU_FREE(rrcReconfigMsg->radioBearerConfig->srb_ToAddModList, sizeof(SRB_ToAddModList_t));
1398       }
1399    }
1400
1401    return ret;
1402 }
1403 /*******************************************************************
1404  *
1405  * @brief Fills DL DCCH Message required for DLRRCMessageTransfer
1406  *
1407  * @details
1408  *
1409  *    Function : fillDlDcchRrcMsg
1410  *
1411  *    Functionality: Fills DL DCCH Message required for
1412  *                   DLRRCMessageTransfer
1413  *
1414  * @params[in] RRCContainer_t *rrcContainer
1415  *
1416  * @return ROK     - success
1417  *         RFAILED - failure
1418  *
1419  * ****************************************************************/
1420
1421 uint8_t fillDlDcchRrcMsg(CuUeCb *ueCb, RRCContainer_t *rrcContainer)
1422 {
1423    uint8_t ret = ROK;
1424    uint16_t idx2 = 0, drbIdx = 0, srbIdx = 0;
1425    DL_DCCH_Message_t dl_DCCH_Msg;
1426    memset(&dl_DCCH_Msg, 0, sizeof(DL_DCCH_Message_t));
1427    asn_enc_rval_t        encRetVal;
1428
1429    if(rrcContainer != NULLP)
1430    {
1431       dl_DCCH_Msg.message.present = DL_DCCH_MessageType_PR_c1;
1432
1433       CU_ALLOC(dl_DCCH_Msg.message.choice.c1 , sizeof(DL_DCCH_MessageType_t));
1434       if(dl_DCCH_Msg.message.choice.c1 != NULLP)
1435       {
1436          dl_DCCH_Msg.message.choice.c1->present = DL_DCCH_MessageType__c1_PR_rrcReconfiguration;
1437          CU_ALLOC(dl_DCCH_Msg.message.choice.c1->choice.rrcReconfiguration, sizeof(RRCReconfiguration_t));
1438          if(dl_DCCH_Msg.message.choice.c1->choice.rrcReconfiguration != NULLP)
1439          {
1440             DU_LOG("\nDEBUG --> F1AP : Filling DL DCCH RRC Reconfiguration Message ");
1441             fillRrcReconfig(ueCb, dl_DCCH_Msg.message.choice.c1->choice.rrcReconfiguration, false);
1442             if(ret == ROK)
1443             {
1444                /* If RB configuration are filled successfully in RRC Reconfiguration, mark these
1445                 * configurartion as sent to UE */
1446                for(srbIdx=0; srbIdx < ueCb->numSrb; srbIdx++)
1447                {
1448                   if(ueCb->srbList[srbIdx].cfgSentToUe == false)
1449                      ueCb->srbList[srbIdx].cfgSentToUe = true;
1450                }
1451                for(drbIdx=0; drbIdx < ueCb->numDrb; drbIdx++)
1452                {
1453                   if(ueCb->drbList[drbIdx].cfgSentToUe == false)
1454                      ueCb->drbList[drbIdx].cfgSentToUe = true;
1455                }
1456
1457                /* encode DL-DCCH message into RRC Container */
1458                xer_fprint(stdout, &asn_DEF_DL_DCCH_MessageType, &dl_DCCH_Msg);
1459                memset(encBuf, 0, ENC_BUF_MAX_LEN);
1460                encBufSize = 0;
1461                encRetVal = aper_encode(&asn_DEF_DL_DCCH_MessageType, 0, &dl_DCCH_Msg, PrepFinalEncBuf, encBuf);
1462                /* Encode results */
1463                if(encRetVal.encoded == ENCODE_FAIL)
1464                {
1465                   DU_LOG( "\nERROR  -->  F1AP : Could not encode RRCContainer for DL-DCCH Msg (at %s)\n",\
1466                         encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
1467                   return RFAILED;
1468                }
1469                else
1470                {
1471                   DU_LOG("\nDEBUG  -->  F1AP : Created APER encoded buffer for RRCContainer for DL-DCCH Msg\n");
1472                   for(int i = 0; i< encBufSize; i++)
1473                   {
1474                      DU_LOG("%x",encBuf[i]);
1475                   }
1476                   rrcContainer->size = encBufSize;
1477                   CU_ALLOC(rrcContainer->buf, rrcContainer->size);
1478                   if(rrcContainer->buf != NULLP)
1479                   {
1480                      memset(rrcContainer->buf, 0, encBufSize);
1481                      for(idx2 = 0; idx2 < encBufSize; idx2++)
1482                      {
1483                         rrcContainer->buf[idx2] =       encBuf[idx2];
1484                      }
1485                   }
1486                }
1487             }
1488          }
1489          else
1490          {
1491             DU_LOG("\nERROR  -->  F1AP: Memory Alloc failed for RRC Msg at fillDlDcchRrcMsg()");
1492             ret = RFAILED;
1493          }
1494       }
1495       else
1496       {
1497          DU_LOG("\nERROR  -->  F1AP: Memory Alloc failed for DL Dcch Msg choice at fillDlDcchRrcMsg()");
1498          ret = RFAILED;
1499       }
1500    }
1501    else
1502    {
1503       DU_LOG("\nERROR  -->  F1AP: RRC Container is NULLP at fillDlDcchRrcMsg()");
1504       ret = RFAILED;
1505    }
1506    return ret;
1507 }
1508
1509 /*******************************************************************
1510  *
1511  * @brief Builds RRC Container IE required for DLRRCMessageTransfer
1512  *
1513  * @details
1514  *
1515  *    Function : BuildDLRRCContainer
1516  *
1517  *    Functionality: Builds RRC Container IE required for
1518  *                   DLRRCMessageTransfer
1519  *
1520  * @params[in]
1521  *
1522  * @return ROK     - success
1523  *         RFAILED - failure
1524  *
1525  * ****************************************************************/
1526
1527 uint8_t BuildDLRRCContainer(CuUeCb *ueCb, uint8_t rrcMsgType, RRCContainer_t *rrcContainer)
1528 {
1529    uint8_t ret, bufLen;
1530
1531    ret =ROK;
1532    if(rrcMsgType == RRC_SETUP)
1533    {
1534       ret = fillDlCcchRrcMsg(ueCb, rrcContainer);
1535       if(ret == RFAILED)
1536          DU_LOG("\nERROR  -->  F1AP: Failed to fill DL-CCCH Msg at RRC SETUP");
1537    }
1538    else if(rrcMsgType == REGISTRATION_ACCEPT)
1539    {
1540       /*Hardcoded RRC Container from reference logs*/
1541       char buf[14] ={0x00, 0x03, 0x2a, 0x80, 0xaf, 0xc0, 0x08, 0x40, 0x20, 0x20, 0x00, 0x00, 0x00, 0x00};
1542       bufLen =14;
1543       rrcContainer->size = bufLen;
1544       CU_ALLOC(rrcContainer->buf, rrcContainer->size);
1545       if(rrcContainer->buf != NULLP)
1546       {
1547          memset(rrcContainer->buf, 0, bufLen);
1548          memcpy(rrcContainer->buf, buf, bufLen);
1549       }
1550       else
1551       {
1552          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure for RRC Container buffer");
1553          ret = RFAILED;
1554       }
1555    }
1556    else if(rrcMsgType == RRC_RECONFIG)
1557    {
1558       DU_LOG("\nDEBUG --> F1AP : Filling DL DCCH RRC Message ");
1559       ret = fillDlDcchRrcMsg(ueCb, rrcContainer);
1560       if(ret == RFAILED)
1561          DU_LOG("\nERROR  -->  F1AP: Failed to fill DL-DCCH Msg for RRC Reconfiguration");
1562    }
1563
1564    return ret;
1565 }
1566
1567 /*******************************************************************
1568  *
1569  * @brief Frees the DLRRCMessageTransfer
1570  *
1571  * @details
1572  *
1573  *    Function : freeDlRrcMessageTransfer
1574  *
1575  *    Functionality: Frees the DLRRCMessageTransfer
1576  *
1577  * @params[in]
1578  *
1579  * @return ROK     - success
1580  *         RFAILED - failure
1581  *
1582  * ****************************************************************/
1583 void freeDlRrcMessageTransfer(F1AP_PDU_t *f1apMsg)
1584 {
1585    uint8_t idx=0;
1586    DLRRCMessageTransfer_t  *dlRRCMsg = NULLP;
1587
1588    if(f1apMsg)
1589    {
1590       dlRRCMsg = &f1apMsg->choice.initiatingMessage->value.choice.DLRRCMessageTransfer;
1591       if(dlRRCMsg->protocolIEs.list.array)
1592       {
1593          idx = 3;
1594          CU_FREE(dlRRCMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.buf, \
1595             dlRRCMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.size);
1596          for(idx=0; idx<dlRRCMsg->protocolIEs.list.count; idx++)
1597          {
1598             CU_FREE(dlRRCMsg->protocolIEs.list.array[idx], sizeof(DLRRCMessageTransferIEs_t));
1599          }
1600          CU_FREE(dlRRCMsg->protocolIEs.list.array, dlRRCMsg->protocolIEs.list.size);
1601       }
1602       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
1603    }
1604 }
1605
1606 /*******************************************************************
1607  *
1608  * @brief Builds and sends the DLRRCMessageTransfer
1609  *
1610  * @details
1611  *
1612  *    Function : BuildAndSendDLRRCMessageTransfer
1613  *
1614  *    Functionality: Constructs the DL RRC Message Transfer and sends
1615  *                   it to the CU through SCTP.
1616  *
1617  * @params[in]
1618  *
1619  * @return ROK     - success
1620  *         RFAILED - failure
1621  *
1622  * ****************************************************************/
1623 uint8_t BuildAndSendDLRRCMessageTransfer(uint32_t duId, CuUeCb *ueCb, uint8_t srbId, uint8_t rrcMsgType)
1624 {
1625    uint8_t   elementCnt = 0;
1626    uint8_t  ieId;
1627    uint8_t  idx;
1628    F1AP_PDU_t  *f1apMsg = NULLP;
1629    DLRRCMessageTransfer_t  *dlRRCMsg = NULLP;
1630    asn_enc_rval_t   encRetVal;        /* Encoder return value */
1631
1632    DU_LOG("\nINFO  -->  F1AP : Building DL RRC Message Transfer Message\n");
1633
1634    CU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
1635    if(f1apMsg == NULLP)
1636    {
1637       DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
1638       return RFAILED;
1639    }
1640
1641    f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
1642    CU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
1643    if(f1apMsg->choice.initiatingMessage == NULLP)
1644    {
1645       DU_LOG("\nERROR  -->  F1AP : Memory allocation for  F1AP-PDU failed");
1646       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
1647       return RFAILED;
1648    }
1649
1650    f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_DLRRCMessageTransfer;
1651    f1apMsg->choice.initiatingMessage->criticality = Criticality_ignore;
1652    f1apMsg->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_DLRRCMessageTransfer;
1653    dlRRCMsg = &f1apMsg->choice.initiatingMessage->value.choice.DLRRCMessageTransfer;
1654
1655    elementCnt = 4;
1656    dlRRCMsg->protocolIEs.list.count = elementCnt;
1657    dlRRCMsg->protocolIEs.list.size = elementCnt * sizeof(DLRRCMessageTransferIEs_t *);
1658
1659    /* Initialize the F1Setup members */
1660    CU_ALLOC(dlRRCMsg->protocolIEs.list.array, dlRRCMsg->protocolIEs.list.size);
1661    if(dlRRCMsg->protocolIEs.list.array == NULLP)
1662    {
1663       DU_LOG("\nERROR  -->  F1AP : Memory allocation for DL RRC MessageTransferIEs failed");
1664       CU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
1665       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
1666       return RFAILED;
1667    }
1668
1669    for(idx=0; idx<elementCnt; idx++)
1670    {
1671       CU_ALLOC(dlRRCMsg->protocolIEs.list.array[idx], sizeof(DLRRCMessageTransferIEs_t));
1672       if(dlRRCMsg->protocolIEs.list.array[idx] == NULLP)
1673       {
1674          for(ieId=0; ieId<idx; ieId++)
1675          {
1676             CU_FREE(dlRRCMsg->protocolIEs.list.array[ieId], sizeof(DLRRCMessageTransferIEs_t));
1677          }
1678          CU_FREE(dlRRCMsg->protocolIEs.list.array, dlRRCMsg->protocolIEs.list.size);
1679          CU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
1680          CU_FREE(f1apMsg,sizeof(F1AP_PDU_t));
1681          return RFAILED;
1682       }
1683    }
1684
1685    /* GNB CU UE F1AP ID */
1686    idx = 0;
1687    dlRRCMsg->protocolIEs.list.array[idx]->id  = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
1688    dlRRCMsg->protocolIEs.list.array[idx]->criticality  = Criticality_reject;
1689    dlRRCMsg->protocolIEs.list.array[idx]->value.present = DLRRCMessageTransferIEs__value_PR_GNB_CU_UE_F1AP_ID;
1690    dlRRCMsg->protocolIEs.list.array[idx]->value.choice.GNB_CU_UE_F1AP_ID = ueCb->gnbCuUeF1apId;
1691
1692    /* GNB DU UE F1AP ID */
1693    idx++;
1694    dlRRCMsg->protocolIEs.list.array[idx]->id  = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
1695    dlRRCMsg->protocolIEs.list.array[idx]->criticality  = Criticality_reject;
1696    dlRRCMsg->protocolIEs.list.array[idx]->value.present = DLRRCMessageTransferIEs__value_PR_GNB_DU_UE_F1AP_ID;
1697    dlRRCMsg->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID = ueCb->gnbDuUeF1apId;;
1698
1699    /* SRBID */
1700    idx++;
1701    dlRRCMsg->protocolIEs.list.array[idx]->id  = ProtocolIE_ID_id_SRBID;
1702    dlRRCMsg->protocolIEs.list.array[idx]->criticality  = Criticality_reject;
1703    dlRRCMsg->protocolIEs.list.array[idx]->value.present = DLRRCMessageTransferIEs__value_PR_SRBID;
1704    dlRRCMsg->protocolIEs.list.array[idx]->value.choice.SRBID = srbId;
1705
1706    /* RRCContainer */
1707    idx++;
1708    dlRRCMsg->protocolIEs.list.array[idx]->id  = ProtocolIE_ID_id_RRCContainer;
1709    dlRRCMsg->protocolIEs.list.array[idx]->criticality = Criticality_reject;
1710    dlRRCMsg->protocolIEs.list.array[idx]->value.present = DLRRCMessageTransferIEs__value_PR_RRCContainer;
1711    BuildDLRRCContainer(ueCb, rrcMsgType, &dlRRCMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer);
1712
1713    xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
1714
1715    /* Encode the F1SetupRequest type as APER */
1716    memset(encBuf, 0, ENC_BUF_MAX_LEN);
1717    encBufSize = 0;
1718    encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
1719          encBuf);
1720    /* Encode results */
1721    if(encRetVal.encoded == ENCODE_FAIL)
1722    {
1723       DU_LOG( "\nERROR  -->  F1AP : Could not encode DL RRC Message Transfer structure (at %s)\n",\
1724             encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
1725       return RFAILED;
1726    }
1727    else
1728    {
1729       DU_LOG("\nDEBUG  -->  F1AP : Created APER encoded buffer for DL RRC Message transfer\n");
1730       for(int i=0; i< encBufSize; i++)
1731       {
1732          DU_LOG("%x",encBuf[i]);
1733       }
1734    }
1735
1736    /* Sending  msg  */
1737    if(SendF1APMsg(CU_APP_MEM_REG,CU_POOL, duId)  !=  ROK)
1738    {
1739       DU_LOG("\nERROR  -->  F1AP : Sending  DL RRC Message Transfer Failed");
1740       return RFAILED;
1741    }
1742    freeDlRrcMessageTransfer(f1apMsg);
1743    return ROK;
1744 }/* End of BuildAndSendDLRRCMessageTransfer */
1745
1746 /*******************************************************************
1747  *
1748  * @brief Function to set the Dl RRC Msg Type
1749  *
1750  * @details
1751  *
1752  *    Function : setDlRRCMsgType
1753  *
1754  *    Functionality: Constructs the UE Setup Response and sends
1755  *                   it to the DU through SCTP.
1756  *
1757  * @params[in]
1758  *
1759  * @return ROK     - success
1760  *         RFAILED - failure
1761  *
1762  * ****************************************************************/
1763
1764 uint8_t setDlRRCMsgType(CuUeCb *ueCb)
1765 {
1766    uint8_t rrcMsgType = 0;
1767    switch(ueCb->f1apMsgDb.dlRrcMsgCount)
1768    {
1769       case RRC_SETUP:
1770          rrcMsgType = RRC_SETUP;
1771          break;
1772       case REGISTRATION_ACCEPT:
1773          rrcMsgType = REGISTRATION_ACCEPT;
1774          break;
1775       case UE_CONTEXT_SETUP_REQ:
1776          rrcMsgType = UE_CONTEXT_SETUP_REQ;
1777          break;
1778       case SECURITY_MODE_COMPLETE:
1779          rrcMsgType = SECURITY_MODE_COMPLETE;
1780          break;
1781       case RRC_RECONFIG:
1782          rrcMsgType = RRC_RECONFIG;
1783          break;
1784       case RRC_RECONFIG_COMPLETE:
1785          rrcMsgType = RRC_RECONFIG_COMPLETE;
1786          break;
1787       case UE_CONTEXT_MOD_REQ:
1788          rrcMsgType = UE_CONTEXT_MOD_REQ;
1789          break;
1790       default:
1791          break;
1792    }
1793    return rrcMsgType;
1794 }
1795
1796 /*******************************************************************
1797  *
1798  * @brief Extract configuration from CellGroupConfig
1799  *
1800  * @details
1801  *
1802  *    Function : extractCellGroupConfig
1803  *
1804  *    Functionality: Extract configuration from CellGroupConfig
1805  *        and store in local database
1806  *
1807  * @params[in] UE control block
1808  *             Cell Group Config
1809  *
1810  * @return ROK     - success
1811  *         RFAILED - failure
1812  *
1813  * ****************************************************************/
1814 uint8_t extractCellGroupConfig(CuUeCb *ueCb, CellGroupConfigRrc_t *cellGrpCfg)
1815 {
1816    uint8_t rbIdx, srbIdx, drbIdx;
1817    bool    srbFound, drbFound;
1818    SrbInfo *srbCfgDb = NULLP;
1819    DrbInfo *drbCfgDb = NULLP;
1820    RlcLcCfg *rlcLcCfgDb = NULLP;
1821    MacLcCfg *macLcCfgDb = NULLP;
1822    RLC_BearerConfig_t *rlcCfg = NULLP;
1823    RLC_Config_t *rlcLcCfg = NULLP;
1824    LogicalChannelConfig_t *macLcCfg = NULLP;
1825
1826    if(ueCb == NULLP)
1827    {
1828       DU_LOG("\nERROR  -->  F1AP: extractCellGroupConfig(): UE Cb is NULL");
1829       return RFAILED;
1830    }
1831
1832    if(cellGrpCfg == NULLP)
1833    {
1834       DU_LOG("\nERROR  -->  F1AP: extractCellGroupConfig(): cellGrpCfg is NULL");
1835       return RFAILED;
1836    }
1837
1838    for(rbIdx = 0; rbIdx < cellGrpCfg->rlc_BearerToAddModList->list.count; rbIdx++)
1839    {
1840       srbFound = false;
1841       drbFound = false;
1842
1843       rlcCfg = cellGrpCfg->rlc_BearerToAddModList->list.array[rbIdx];
1844
1845       /* Update SRB configuration in local DB */
1846       if(rlcCfg->servedRadioBearer->present == RLC_BearerConfig__servedRadioBearer_PR_srb_Identity)
1847       {
1848          /* Search if SRB entry is already present in DB */
1849          for(srbIdx = 0; srbIdx < ueCb->numSrb; srbIdx++)
1850          {
1851             if(ueCb->srbList[srbIdx].srbId == rlcCfg->servedRadioBearer->choice.srb_Identity)
1852             {
1853               srbCfgDb = &ueCb->srbList[srbIdx];
1854               srbFound = true;
1855               break;
1856             }
1857          }
1858
1859          /* If not, add SRB to UE CB's SRB list */
1860          if(!srbFound)
1861          {
1862             ueCb->srbList[ueCb->numSrb].srbId = rlcCfg->servedRadioBearer->choice.srb_Identity;
1863             srbCfgDb = &ueCb->srbList[ueCb->numSrb];
1864             ueCb->numSrb++;
1865          }
1866
1867          srbCfgDb->lcId = rlcCfg->logicalChannelIdentity;
1868          srbCfgDb->cfgSentToUe = false;
1869          rlcLcCfgDb = &srbCfgDb->rlcLcCfg;
1870          macLcCfgDb = &srbCfgDb->macLcCfg;
1871       }
1872
1873       /* Update DRB configuration in local DB */
1874       if(rlcCfg->servedRadioBearer->present == RLC_BearerConfig__servedRadioBearer_PR_drb_Identity)
1875       {
1876          /* Search if DRB entry is already present in DB */
1877          for(drbIdx = 0; drbIdx < ueCb->numDrb; drbIdx++)
1878          {
1879             if(ueCb->drbList[drbIdx].drbId == rlcCfg->servedRadioBearer->choice.drb_Identity)
1880             {
1881               drbCfgDb = &ueCb->drbList[drbIdx];
1882               drbFound = true;
1883               break;
1884             }
1885          }
1886
1887          /* If not, add DRB to UE CB's SRB list */
1888          if(!drbFound)
1889          {
1890             ueCb->drbList[ueCb->numDrb].drbId = rlcCfg->servedRadioBearer->choice.drb_Identity;
1891             drbCfgDb = &ueCb->drbList[ueCb->numDrb];
1892             ueCb->numDrb++;
1893          }
1894
1895          drbCfgDb->lcId = rlcCfg->logicalChannelIdentity;
1896          drbCfgDb->cfgSentToUe = false;
1897          rlcLcCfgDb = &drbCfgDb->rlcLcCfg;
1898          macLcCfgDb = &drbCfgDb->macLcCfg;
1899       }
1900
1901
1902       /* Update RLC configuration for this RB */
1903       rlcLcCfg = rlcCfg->rlc_Config;
1904       rlcLcCfgDb->rlcMode = rlcLcCfg->present;
1905       switch(rlcLcCfgDb->rlcMode)
1906       {
1907          case RLC_Config_PR_am:
1908             {
1909                rlcLcCfgDb->u.amCfg.ulAmCfg.snLenUl = *(rlcLcCfg->choice.am->ul_AM_RLC.sn_FieldLength);
1910                rlcLcCfgDb->u.amCfg.ulAmCfg.pollRetxTmr = rlcLcCfg->choice.am->ul_AM_RLC.t_PollRetransmit ;
1911                rlcLcCfgDb->u.amCfg.ulAmCfg.pollPdu = rlcLcCfg->choice.am->ul_AM_RLC.pollPDU ;
1912                rlcLcCfgDb->u.amCfg.ulAmCfg.pollByte = rlcLcCfg->choice.am->ul_AM_RLC.pollByte ;
1913                rlcLcCfgDb->u.amCfg.ulAmCfg.maxRetxTh = rlcLcCfg->choice.am->ul_AM_RLC.maxRetxThreshold ;
1914
1915                rlcLcCfgDb->u.amCfg.dlAmCfg.snLenDl = *(rlcLcCfg->choice.am->dl_AM_RLC.sn_FieldLength);
1916                rlcLcCfgDb->u.amCfg.dlAmCfg.reAssemTmr = rlcLcCfg->choice.am->dl_AM_RLC.t_Reassembly;
1917                rlcLcCfgDb->u.amCfg.dlAmCfg.statProhTmr = rlcLcCfg->choice.am->dl_AM_RLC.t_StatusProhibit;
1918                break;
1919             }
1920
1921          case RLC_Config_PR_um_Bi_Directional:
1922             {
1923                rlcLcCfgDb->u.umBiDirCfg.ulUmCfg.snLenUlUm = *(rlcLcCfg->choice.um_Bi_Directional->ul_UM_RLC.sn_FieldLength);
1924
1925                rlcLcCfgDb->u.umBiDirCfg.dlUmCfg.snLenDlUm = *(rlcLcCfg->choice.um_Bi_Directional->dl_UM_RLC.sn_FieldLength);
1926                rlcLcCfgDb->u.umBiDirCfg.dlUmCfg.reAssemTmr = rlcLcCfg->choice.um_Bi_Directional->dl_UM_RLC.t_Reassembly;
1927                break;
1928             }
1929       }
1930
1931       /* Update MAC configuration for this LC */
1932       macLcCfg = rlcCfg->mac_LogicalChannelConfig;
1933       macLcCfgDb->priority = macLcCfg->ul_SpecificParameters->priority ;
1934       macLcCfgDb->lcGroup = *(macLcCfg->ul_SpecificParameters->logicalChannelGroup) ;
1935       macLcCfgDb->schReqId = *(macLcCfg->ul_SpecificParameters->schedulingRequestID) ;
1936       macLcCfgDb->pbr = macLcCfg->ul_SpecificParameters->prioritisedBitRate ;
1937       macLcCfgDb->bsd = macLcCfg->ul_SpecificParameters->bucketSizeDuration ;
1938    }
1939    return ROK;
1940 }
1941
1942 /*******************************************************************
1943  *
1944  * @brief Function to decode DU to CU RRC container
1945  *
1946  * @details
1947  *
1948  *    Function : extractDuToCuRrcCont
1949  *
1950  *    Functionality: Function to decode DU to CU RRC container
1951  *
1952  * @params[in] UE Cb
1953  *             RRC conatiner octect string to be decoded
1954  *
1955  * @return ROK     - success
1956  *         RFAILED - failure
1957  *
1958  * ****************************************************************/
1959 uint8_t extractDuToCuRrcCont(CuUeCb *ueCb, OCTET_STRING_t rrcCont)
1960 {
1961    CellGroupConfigRrc_t  cellGrpCfg, *cellGrpCfgMsg = NULLP;
1962    asn_dec_rval_t rval; /* Decoder return value */
1963
1964    /* Copy the received container to UeCb */
1965    memcpy(&ueCb->f1apMsgDb.duToCuContainer, &rrcCont, sizeof(OCTET_STRING_t));
1966
1967    /* Decoding DU to CU RRC container octet string to cell group config */
1968    cellGrpCfgMsg = &cellGrpCfg;
1969    memset(cellGrpCfgMsg, 0, sizeof(CellGroupConfigRrc_t));
1970
1971    rval = aper_decode(0, &asn_DEF_CellGroupConfigRrc, (void **)&cellGrpCfgMsg, rrcCont.buf, rrcCont.size, 0, 0);
1972
1973    if(rval.code == RC_FAIL || rval.code == RC_WMORE)
1974    {
1975       DU_LOG("\nERROR  -->  F1AP : ASN decode failed");
1976       return RFAILED;
1977    }
1978    printf("\n");
1979    xer_fprint(stdout, &asn_DEF_CellGroupConfigRrc, cellGrpCfgMsg);
1980
1981    if((extractCellGroupConfig(ueCb, cellGrpCfgMsg)) != ROK)
1982    {
1983       DU_LOG("\nERROR  -->  F1AP : Failed to extract cell group config");
1984       return RFAILED;
1985    }
1986
1987    return ROK;
1988 }
1989
1990 /*******************************************************************
1991  *
1992  * @brief Function to build Initial UL RRC Message
1993  *
1994  * @details
1995  *
1996  *    Function : procInitULRRCMsg
1997  *
1998  *    Functionality: Function to build Initial UL RRC Message
1999  *
2000  * @params[in]
2001  *
2002  * @return ROK     - success
2003  *         RFAILED - failure
2004  *
2005  * ****************************************************************/
2006
2007 uint8_t procInitULRRCMsg(uint32_t duId, F1AP_PDU_t *f1apMsg)
2008 {
2009    uint8_t idx,cellIdx=0, duIdx=0, rrcMsgType, gnbDuUeF1apId;
2010    uint8_t ret =ROK;
2011    uint32_t nrCellId, crnti;
2012    DuDb     *duDb;
2013    CuCellCb *cellCb;
2014    CuUeCb   *ueCb;
2015    InitialULRRCMessageTransfer_t *initULRRCMsg = NULLP;
2016
2017    DU_LOG("\nINFO   -->  F1AP : filling the required values in DB in procInitULRRCMsg");
2018
2019    SEARCH_DU_DB(duIdx, duId, duDb);
2020    initULRRCMsg = &f1apMsg->choice.initiatingMessage->value.choice.InitialULRRCMessageTransfer;
2021
2022    for(idx=0; idx < initULRRCMsg->protocolIEs.list.count; idx++)
2023    {
2024       switch(initULRRCMsg->protocolIEs.list.array[idx]->id)
2025       {
2026          case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
2027             gnbDuUeF1apId = initULRRCMsg->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID;
2028             break;
2029
2030          case ProtocolIE_ID_id_NRCGI:
2031             nrCellId = initULRRCMsg->protocolIEs.list.array[idx]->value.choice.NRCGI.nRCellIdentity.buf[4] >>
2032                initULRRCMsg->protocolIEs.list.array[idx]->value.choice.NRCGI.nRCellIdentity.bits_unused;
2033             SEARCH_CELL_DB(cellIdx, duDb, nrCellId, cellCb);
2034             if(cellCb == NULLP)
2035                return RFAILED;
2036             break;
2037
2038          case ProtocolIE_ID_id_C_RNTI:
2039             crnti = initULRRCMsg->protocolIEs.list.array[idx]->value.choice.C_RNTI;
2040             if(duDb->ueCb[gnbDuUeF1apId-1].gnbDuUeF1apId == 0)
2041             {
2042                ueCb = &duDb->ueCb[gnbDuUeF1apId-1];
2043                memset(ueCb, 0, sizeof(CuUeCb));
2044                ueCb->cellCb = cellCb;
2045                ueCb->crnti = crnti;
2046                ueCb->gnbDuUeF1apId = gnbDuUeF1apId;
2047                ueCb->gnbCuUeF1apId = ++cuCb.gnbCuUeF1apIdGenerator;
2048                ueCb->state = UE_ATTACH_IN_PROGRESS;
2049                (duDb->numUe)++;
2050
2051                cellCb->ueCb[cellCb->numUe] = ueCb;
2052                cellCb->numUe++;
2053             }
2054             break;
2055
2056          case ProtocolIE_ID_id_RRCContainer:
2057             break;
2058
2059          case ProtocolIE_ID_id_DUtoCURRCContainer:
2060             {
2061                if((initULRRCMsg->protocolIEs.list.array[idx]->value.choice.DUtoCURRCContainer.size > 0) && \
2062                   (initULRRCMsg->protocolIEs.list.array[idx]->value.choice.DUtoCURRCContainer.buf != NULLP))
2063                {
2064                   DU_LOG("\nINFO  -->  Received Du to Cu RRC Container ");
2065                   ueCb->f1apMsgDb.duToCuContainer.size = initULRRCMsg->protocolIEs.list.array[idx]->value.choice.DUtoCURRCContainer.size;
2066                   CU_ALLOC(ueCb->f1apMsgDb.duToCuContainer.buf, ueCb->f1apMsgDb.duToCuContainer.size);
2067                   if(ueCb->f1apMsgDb.duToCuContainer.buf != NULLP)
2068                   {
2069                      memcpy(ueCb->f1apMsgDb.duToCuContainer.buf, \
2070                         initULRRCMsg->protocolIEs.list.array[idx]->value.choice.DUtoCURRCContainer.buf, \
2071                         ueCb->f1apMsgDb.duToCuContainer.size);
2072                   }
2073                   if((extractDuToCuRrcCont(ueCb, initULRRCMsg->protocolIEs.list.array[idx]->value.choice.DUtoCURRCContainer)) != ROK)
2074                   {
2075                      DU_LOG("\nERROR  --> F1AP : Failed to extract DU to CU RRC Container ");
2076                      ret = RFAILED;
2077                   }
2078                }
2079                else
2080                {
2081                   DU_LOG("\nERROR  -->  Failed to receive Du to Cu RRC Container ");
2082                   ret = RFAILED;
2083                }
2084                break;
2085             }
2086
2087          default:
2088             DU_LOG("\nERROR  -->  Invalid Event %ld", initULRRCMsg->protocolIEs.list.array[idx]->id);
2089             break;
2090       }
2091       if(ret == RFAILED)
2092          break;
2093    }
2094
2095    if(ret == ROK)
2096    {
2097       ueCb->f1apMsgDb.dlRrcMsgCount++;
2098       rrcMsgType = setDlRRCMsgType(ueCb);
2099       ret = BuildAndSendDLRRCMessageTransfer(duId, ueCb, SRB0, rrcMsgType);
2100    }
2101    return ret;
2102 }
2103
2104 /*******************************************************************
2105  *
2106  * @brief Builds Nrcgi
2107  *
2108  * @details
2109  *
2110  *    Function : BuildNrcgi
2111  *
2112  *    Functionality: Building the PLMN ID and NR Cell id
2113  *
2114  * @params[in] NRCGI_t *nrcgi
2115  * @return ROK     - success
2116  *         RFAILED - failure
2117  *
2118  * ****************************************************************/
2119 uint8_t BuildNrcgi(NRCGI_t *nrcgi, uint32_t nrCellId)
2120 {
2121    uint8_t ret;
2122    uint8_t unused_bits = 4;
2123    uint8_t byteSize = 5;
2124
2125    /* Allocate Buffer Memory */
2126    nrcgi->pLMN_Identity.size = 3 * sizeof(uint8_t);
2127    CU_ALLOC(nrcgi->pLMN_Identity.buf, nrcgi->pLMN_Identity.size);
2128    if(nrcgi->pLMN_Identity.buf == NULLP)
2129    {
2130       return RFAILED;
2131    }
2132    ret = buildPlmnId(cuCb.cuCfgParams.plmn , nrcgi->pLMN_Identity.buf);
2133
2134    if(ret != ROK)
2135    {
2136       return RFAILED;
2137    }
2138    nrcgi->nRCellIdentity.size = byteSize * sizeof(uint8_t);
2139    CU_ALLOC(nrcgi->nRCellIdentity.buf, nrcgi->nRCellIdentity.size);
2140    if(nrcgi->nRCellIdentity.buf == NULLP)
2141    {
2142       return RFAILED;
2143    }
2144    fillBitString(&nrcgi->nRCellIdentity, unused_bits, byteSize, nrCellId);
2145
2146    return ROK;
2147 }
2148 /*******************************************************************
2149  *
2150  * @brief Builds Special cell list for UE Setup Request
2151  *
2152  * @details
2153  *
2154  *    Function : BuildSplCellList
2155  *
2156  *    Functionality: Constructs the Special Cell list for UESetReq
2157  *
2158  * @params[in] SCell_ToBeSetup_List_t *spCellLst
2159  *
2160  * @return ROK     - success
2161  *         RFAILED - failure
2162  *
2163  * ****************************************************************/
2164 uint8_t BuildSplCellList(CuUeCb *ueCb, SCell_ToBeSetup_List_t *spCellLst)
2165 {
2166    uint8_t  cellCnt;
2167    uint8_t  idx;
2168    uint8_t  ret;
2169    cellCnt = 1;
2170    spCellLst->list.count = cellCnt;
2171    spCellLst->list.size = cellCnt * sizeof(SCell_ToBeSetup_ItemIEs_t *);
2172    CU_ALLOC(spCellLst->list.array,spCellLst->list.size);
2173    if(spCellLst->list.array == NULLP)
2174    {
2175       return RFAILED;
2176    }
2177    for(idx=0; idx<cellCnt; idx++)
2178    {
2179       CU_ALLOC(spCellLst->list.array[idx],sizeof(SCell_ToBeSetup_ItemIEs_t));
2180       if(spCellLst->list.array[idx] == NULLP)
2181       {
2182          return RFAILED;
2183       }
2184    }
2185    idx = 0;
2186    spCellLst->list.array[idx]->id = ProtocolIE_ID_id_SCell_ToBeSetup_Item;
2187    spCellLst->list.array[idx]->criticality = Criticality_ignore;
2188    spCellLst->list.array[idx]->value.present = SCell_ToBeSetup_ItemIEs__value_PR_SCell_ToBeSetup_Item;
2189
2190    /* Special Cell ID -NRCGI */
2191    ret = BuildNrcgi(&spCellLst->list.array[idx]->value.choice.SCell_ToBeSetup_Item.sCell_ID, ueCb->cellCb->nrCellId);
2192    if(ret != ROK)
2193    {
2194       return RFAILED;
2195    }
2196    /*Special Cell Index*/
2197    spCellLst->list.array[idx]->value.choice.SCell_ToBeSetup_Item.sCellIndex = 1;
2198    return ROK;
2199 }/* End of BuildSplCellList*/
2200
2201 /*******************************************************************
2202  *
2203  * @brief Builds SRBS to be setup
2204  *
2205  * @details
2206  *
2207  *    Function : BuildSRBSetup
2208  *
2209  *    Functionality: Constructs the SRB's for UESetReq
2210  *
2211  * @params[in] SRBs_ToBeSetup_List_t *srbSet
2212  *
2213  * @return ROK     - success
2214  *         RFAILED - failure
2215  *
2216  * ****************************************************************/
2217 uint8_t BuildSRBSetup(CuUeCb *ueCb, SRBs_ToBeSetup_List_t *srbSet)
2218 {
2219    uint8_t idx;
2220    uint8_t srbCnt;
2221
2222    if(ueCb->state == UE_HANDOVER_IN_PROGRESS)
2223       srbCnt = ueCb->numSrb;
2224    else
2225       srbCnt = 1;
2226    srbSet->list.count = srbCnt;
2227    srbSet->list.size = srbCnt*sizeof(SRBs_ToBeSetup_ItemIEs_t *);
2228    CU_ALLOC(srbSet->list.array,srbSet->list.size);
2229    if(srbSet->list.array == NULLP)
2230    {
2231       DU_LOG("\nERROR  --> F1AP : BuildSRBSetup() : Memory allocation failed for SRB to be setup list's array");
2232       return RFAILED;
2233    }
2234
2235    for(idx=0; idx<srbCnt; idx++)
2236    {
2237       CU_ALLOC(srbSet->list.array[idx],sizeof(SRBs_ToBeSetup_ItemIEs_t));
2238       if(srbSet->list.array[idx] == NULLP)
2239       {
2240          DU_LOG("\nERROR  --> F1AP : BuildSRBSetup() : Memory allocation failed for SRB to be setup list's array element");
2241          return RFAILED;
2242       }
2243    }
2244
2245    if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
2246    {
2247       idx = 0;
2248       srbSet->list.array[idx]->id = ProtocolIE_ID_id_SRBs_ToBeSetup_Item;
2249       srbSet->list.array[idx]->criticality = Criticality_ignore;
2250       srbSet->list.array[idx]->value.present = SRBs_ToBeSetup_ItemIEs__value_PR_SRBs_ToBeSetup_Item;
2251       srbSet->list.array[idx]->value.choice.SRBs_ToBeSetup_Item.sRBID = 2;
2252       ueCb->srbList[ueCb->numSrb].srbId = srbSet->list.array[idx]->value.choice.SRBs_ToBeSetup_Item.sRBID;
2253       ueCb->numSrb++;
2254    }
2255    else
2256    {
2257       for(idx=0; idx<srbCnt; idx++)
2258       {
2259          srbSet->list.array[idx]->id = ProtocolIE_ID_id_SRBs_ToBeSetup_Item;
2260          srbSet->list.array[idx]->criticality = Criticality_ignore;
2261          srbSet->list.array[idx]->value.present = SRBs_ToBeSetup_ItemIEs__value_PR_SRBs_ToBeSetup_Item;
2262          srbSet->list.array[idx]->value.choice.SRBs_ToBeSetup_Item.sRBID = ueCb->srbList[idx].srbId;
2263       }
2264    }
2265    return ROK;
2266 }/* End of BuildSRBSetup*/
2267
2268 /*******************************************************************
2269  *
2270  * @brief Builds QOS Info for DRB Setum Item
2271  *
2272  * @details
2273  *
2274  *    Function : BuildQOSInfo
2275  *
2276  *    Functionality: Constructs the QOS Info for DRB Setup Item
2277  *
2278  * @params[in] QoSInformation_t *qosinfo
2279  *             int16_t pduSessionID
2280  *
2281  * @return ROK     - success
2282  *         RFAILED - failure
2283  *
2284  * ****************************************************************/
2285 uint8_t BuildQOSInfo(QosInfo *qosInfo, QoSFlowLevelQoSParameters_t *drbQos, uint8_t actionType, int16_t pduSessionID, bool hoInProgress)
2286 {
2287    uint8_t elementCnt = 0, qosCntIdx = 0;
2288    ProtocolExtensionContainer_4624P74_t *qosIeExt = NULLP;
2289
2290    /* NonDynamic5QIDescriptor */
2291    drbQos->qoS_Characteristics.present = QoS_Characteristics_PR_non_Dynamic_5QI;
2292    CU_ALLOC(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI,sizeof(NonDynamic5QIDescriptor_t));
2293    if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI == NULLP)
2294    {
2295       return RFAILED;
2296    }
2297
2298    if(hoInProgress)
2299       drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->fiveQI = qosInfo->nonDynFiveQI ;
2300    else
2301    {
2302       /*FiveQI*/
2303       if(actionType == ProtocolIE_ID_id_DRBs_ToBeModified_Item)
2304          drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->fiveQI = FIVE_QI_VALUE8;
2305       else
2306          drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->fiveQI = FIVE_QI_VALUE9;
2307
2308       qosInfo->nonDynFiveQI = drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->fiveQI;
2309    }
2310
2311    if(!hoInProgress)
2312    {
2313       /*AveragingWindow*/
2314       CU_ALLOC(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow, sizeof(AveragingWindow_t));
2315       if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow == NULLP)
2316       {
2317          return RFAILED;
2318       }
2319       *(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow) = 0;
2320       qosInfo->avgWindow = *(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow);
2321
2322       /*MaxDataBurstVolume*/
2323       CU_ALLOC(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume, sizeof(MaxDataBurstVolume_t));
2324       if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume == NULLP)
2325       {
2326          return RFAILED;
2327       }
2328       *(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume) = 0;
2329       qosInfo->maxBurstDataVol = *(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume);
2330    }
2331
2332    /*nRGRAN Allocation Retention Priority*/
2333    if(hoInProgress)
2334    {
2335       drbQos->nGRANallocationRetentionPriority.priorityLevel = qosInfo->priorityLevel;
2336       drbQos->nGRANallocationRetentionPriority.pre_emptionCapability = qosInfo->preemptionCapability;
2337       drbQos->nGRANallocationRetentionPriority.pre_emptionVulnerability = qosInfo->preemptionVulnerability;
2338    }
2339    else
2340    {
2341       drbQos->nGRANallocationRetentionPriority.priorityLevel = PriorityLevel_lowest;
2342       drbQos->nGRANallocationRetentionPriority.pre_emptionCapability = Pre_emptionCapability_may_trigger_pre_emption;
2343       drbQos->nGRANallocationRetentionPriority.pre_emptionVulnerability = Pre_emptionVulnerability_not_pre_emptable;
2344
2345       qosInfo->priorityLevel = PriorityLevel_lowest;
2346       qosInfo->preemptionCapability = Pre_emptionCapability_may_trigger_pre_emption;
2347       qosInfo->preemptionVulnerability = Pre_emptionVulnerability_not_pre_emptable;
2348    }
2349
2350    /* PDU session ID */
2351    if(!hoInProgress)
2352    {
2353       /*If PDU Session ID is INVALID thus not to be included in Qos IE, skip the PDU Session IE */
2354       if(pduSessionID <= INVALID_PDU_SESSION_ID)
2355       {
2356          DU_LOG("\nINFO  --> F1AP : Invalid PDU_SESSION_ID");
2357          return ROK;
2358       }
2359
2360       CU_ALLOC(drbQos->iE_Extensions, sizeof(ProtocolExtensionContainer_4624P74_t));
2361       qosIeExt = (ProtocolExtensionContainer_4624P74_t *)drbQos->iE_Extensions;
2362
2363       if(qosIeExt)
2364       {
2365          elementCnt = NUM_QOS_EXT;
2366          qosIeExt->list.count = elementCnt;
2367          qosIeExt->list.size = elementCnt * sizeof(QoSFlowLevelQoSParameters_ExtIEs_t *);
2368
2369          /*Initialize QoSFlowLevelQoSParameters_ExtIEs_t*/
2370          CU_ALLOC(qosIeExt->list.array, qosIeExt->list.size);
2371
2372          if(qosIeExt->list.array == NULLP)
2373          {
2374             DU_LOG("\nERROR  -->        F1AP : Memory allocation for QoSFlowLevelQoSParameters_ExtIEs_t failed");
2375             return  RFAILED;
2376          }
2377
2378          for(qosCntIdx=0; qosCntIdx < elementCnt; qosCntIdx++)
2379          {
2380             CU_ALLOC(qosIeExt->list.array[qosCntIdx], sizeof(QoSFlowLevelQoSParameters_ExtIEs_t));
2381             if(qosIeExt->list.array[qosCntIdx] == NULLP)
2382             {
2383                DU_LOG("\nERROR  -->     F1AP : Memory allocation for QoSFlowLevelQoSParameters_ExtIEs_t array failed");
2384                return  RFAILED;
2385             }
2386             /*Filling QoSFlowLevelQoSParameters_ExtIEs_t*/
2387             qosIeExt->list.array[qosCntIdx]->id = ProtocolIE_ID_id_PDUSessionID;
2388             /*Below Criticality mentioned in Spec38.473, 15.4.1 and later*/
2389             qosIeExt->list.array[qosCntIdx]->criticality = Criticality_ignore;
2390             qosIeExt->list.array[qosCntIdx]->extensionValue.present = \
2391                                                                       QoSFlowLevelQoSParameters_ExtIEs__extensionValue_PR_PDUSessionID;
2392             qosIeExt->list.array[qosCntIdx]->extensionValue.choice.PDUSessionID = (PDUSessionID_t)pduSessionID;
2393             qosInfo->pduSessionId = pduSessionID;
2394          }
2395       }
2396       else
2397       {
2398          DU_LOG("\nERROR  -->   F1AP : Memory allocation for QosIE_extension failed");
2399          return RFAILED;
2400       }
2401    }
2402    return ROK;
2403 }/*End of BuildQOSInfo*/
2404
2405 /*******************************************************************
2406  *
2407  * @brief Builds SNSSAI
2408  *
2409  * @details
2410  *
2411  *    Function : BuildSNSSAI
2412  *
2413  *    Functionality: Constructs the SNSSAI For DRB list
2414  *
2415  * @params[in] SNSSAI_t *snssai
2416  *             Snssai  *snssaiToCopy S-NSSAI from CuCfgParam to be copied
2417  *
2418  * @return ROK     - success
2419  *         RFAILED - failure
2420  *
2421  * ****************************************************************/
2422 uint8_t BuildSNSSAI(DrbInfo *drbInfo, SNSSAI_t *snssai, Snssai *snssaiToCopy, bool hoInProgress)
2423 {
2424    /*SNSSAI*/
2425    /*ssT*/
2426    snssai->sST.size = sizeof(uint8_t);
2427    CU_ALLOC(snssai->sST.buf, snssai->sST.size);
2428    if(snssai->sST.buf == NULLP)
2429    {
2430       return RFAILED;
2431    }
2432    if(!hoInProgress)
2433       memcpy(snssai->sST.buf, &snssaiToCopy->sst, snssai->sST.size);
2434    else
2435       memcpy(snssai->sST.buf, &drbInfo->snssai->sst, snssai->sST.size);
2436
2437    /*sD*/
2438    CU_ALLOC(snssai->sD, sizeof(OCTET_STRING_t));
2439    if(snssai->sD == NULLP)
2440    {
2441       return RFAILED;
2442    }
2443    snssai->sD->size = 3 * sizeof(uint8_t);
2444    CU_ALLOC(snssai->sD->buf, snssai->sD->size);
2445    if(snssai->sD->buf == NULLP)
2446    {
2447       return RFAILED;
2448    }
2449    if(!hoInProgress)
2450       memcpy(snssai->sD->buf, snssaiToCopy->sd, snssai->sD->size);
2451    else
2452       memcpy(snssai->sD->buf, drbInfo->snssai->sd, snssai->sD->size);
2453
2454    if(!hoInProgress)
2455       drbInfo->snssai = snssaiToCopy;
2456    return ROK;
2457 }/*End of BuildSNSSAI*/
2458
2459 /*******************************************************************
2460  *
2461  * @brief Builds the flow map.
2462  *
2463  * @details
2464  *
2465  *    Function : BuildFlowsMap
2466  *
2467  *    Functionality: Constructs the flowmap For DRB list
2468  *
2469  * @params[in] Flows_Mapped_To_DRB_List_t *flowMap
2470  *
2471  * @return ROK     - success
2472  *         RFAILED - failure
2473  *
2474  * ****************************************************************/
2475 uint8_t BuildFlowsMap(DrbInfo *drbInfo, Flows_Mapped_To_DRB_List_t *flowMap , uint8_t actionType, bool hoInProgress)
2476 {
2477    uint8_t  ret = ROK, idx = 0, flowCnt = 0, flowIdx = 0;
2478    FlowsMapped *qosFlow;
2479
2480    if(!hoInProgress)
2481       flowCnt = 1;
2482    else
2483       flowCnt = drbInfo->numFlowMap;
2484    flowMap->list.count = flowCnt;
2485    flowMap->list.size = flowCnt * sizeof(Flows_Mapped_To_DRB_Item_t *);
2486    CU_ALLOC(flowMap->list.array,flowMap->list.size);
2487    if(flowMap->list.array == NULLP)
2488    {
2489       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed for array in BuildFlowsMap()");
2490       return RFAILED;
2491    }
2492    for(idx=0; idx<flowCnt; idx++)
2493    {
2494       CU_ALLOC(flowMap->list.array[idx],sizeof(Flows_Mapped_To_DRB_Item_t));
2495       if(flowMap->list.array[idx] == NULLP)
2496       {
2497          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed for arrayIdx[%d] in BuildFlowsMap()", idx);
2498          return RFAILED;
2499       }
2500
2501       if(!hoInProgress)
2502       {
2503          flowMap->list.array[idx]->qoSFlowIdentifier = 0;
2504          if(actionType == ProtocolIE_ID_id_DRBs_ToBeModified_Item)
2505          {
2506             for(flowIdx =0; flowIdx < drbInfo->numFlowMap; flowIdx++)
2507             {
2508                if(drbInfo->flowMapList[flowIdx].qosFlowId == flowMap->list.array[idx]->qoSFlowIdentifier)
2509                {
2510                   qosFlow = &drbInfo->flowMapList[flowIdx];
2511                   break;
2512                }
2513             }
2514          }
2515          else
2516          {
2517             qosFlow = &drbInfo->flowMapList[drbInfo->numFlowMap];
2518             qosFlow->qosFlowId = flowMap->list.array[idx]->qoSFlowIdentifier;
2519          }
2520       }
2521       else
2522       {
2523          qosFlow = &drbInfo->flowMapList[idx];
2524          flowMap->list.array[idx]->qoSFlowIdentifier = qosFlow->qosFlowId;
2525       }
2526
2527       ret = BuildQOSInfo(&qosFlow->qos, &flowMap->list.array[idx]->qoSFlowLevelQoSParameters,\
2528             actionType, INVALID_PDU_SESSION_ID, hoInProgress);
2529       if(ret != ROK)
2530       {
2531          DU_LOG("\nERROR  -->  F1AP : Failed to Build QOS Info in BuildFlowsMap()");
2532          return RFAILED;
2533       }
2534
2535       if((!hoInProgress) && (actionType != ProtocolIE_ID_id_DRBs_ToBeModified_Item))
2536          drbInfo->numFlowMap++;
2537    }
2538    return ROK;
2539 }/*End of BuildFlowsMap*/
2540
2541 /*******************************************************************
2542  *
2543  * @brief Builds the Uplink Tunnel Info
2544  *
2545  * @details
2546  *
2547  *    Function : BuildULTnlInfo
2548  *
2549  *    Functionality: Constructs the UL TnlInfo For DRB list
2550  *
2551  * @params[in]  UPTNLInformation_ToBeSetup_List_t *ulInfo
2552  *
2553  * @return ROK     - success
2554  *         RFAILED - failure
2555  *
2556  * ****************************************************************/
2557 uint8_t BuildULTnlInfo(uint8_t duId, TnlInfo *ulUpTnlInfo, ULUPTNLInformation_ToBeSetup_List_t *ulInfo, bool hoInProgress)
2558 {
2559    uint8_t idx;
2560    uint8_t ulCnt;
2561
2562    ulCnt = 1;
2563    ulInfo->list.count = ulCnt;
2564    ulInfo->list.size = ulCnt * sizeof(ULUPTNLInformation_ToBeSetup_Item_t *);
2565    CU_ALLOC(ulInfo->list.array,ulInfo->list.size);
2566    if(ulInfo->list.array == NULLP)
2567    {
2568       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed for array in BuildULTnlInfo()");
2569       return RFAILED;
2570    }
2571    for(idx=0; idx<ulCnt; idx++)
2572    {
2573       CU_ALLOC(ulInfo->list.array[idx],sizeof(ULUPTNLInformation_ToBeSetup_Item_t));
2574       if(ulInfo->list.array[idx] == NULLP)
2575       {
2576          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed for arrayIdx [%d] in BuildULTnlInfo()", idx);
2577               return RFAILED;
2578       }
2579    }
2580    idx = 0;
2581    ulInfo->list.array[idx]->uLUPTNLInformation.present = UPTransportLayerInformation_PR_gTPTunnel;
2582    /*GTP TUNNEL*/
2583    CU_ALLOC(ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel, sizeof(GTPTunnel_t));
2584    if(ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel == NULLP)
2585    {
2586       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed for gTPTunnel in BuildULTnlInfo()");
2587       return RFAILED;
2588    }
2589    ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.size     = 4*sizeof(uint8_t);
2590    CU_ALLOC(ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf, \
2591       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.size);
2592    if(ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf == NULLP)
2593    {
2594       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed for gtp tunnel arrayIdx[%d] in BuildULTnlInfo()", idx);
2595       return RFAILED;
2596    }
2597
2598    if(!hoInProgress)
2599    {
2600       /* NOTE: Below IP address must be changed if running on different IP configuration */
2601       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[0] = 192;
2602       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[1] = 168;
2603       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[2] = 130;
2604       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[3] = 82;
2605       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.bits_unused = 0;
2606
2607       ulUpTnlInfo->address[0] = ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[0];
2608       ulUpTnlInfo->address[1] = ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[1];
2609       ulUpTnlInfo->address[2] = ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[2];
2610       ulUpTnlInfo->address[3] = ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[3];
2611    }
2612    else
2613    {
2614       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[0] = ulUpTnlInfo->address[0];
2615       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[1] = ulUpTnlInfo->address[1];
2616       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[2] = ulUpTnlInfo->address[2];
2617       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[3] = ulUpTnlInfo->address[3];
2618       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.bits_unused = 0;
2619    }
2620
2621    /*GTP TEID*/
2622    ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.size = 4 * sizeof(uint8_t);
2623    CU_ALLOC(ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf, \
2624       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.size);
2625    if(ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf == NULLP)
2626    {
2627       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed for gtp tunnel buffer in BuildULTnlInfo()");
2628       return RFAILED;
2629    }
2630
2631    if(!hoInProgress)
2632    {
2633       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[0] = 0;
2634       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[1] = 0;
2635       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[2] = 0;
2636       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[3] = cuCb.cuCfgParams.egtpParams.currTunnelId++;
2637
2638       ulUpTnlInfo->teId[0] = ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[0];
2639       ulUpTnlInfo->teId[1] = ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[1];
2640       ulUpTnlInfo->teId[2] = ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[2];
2641       ulUpTnlInfo->teId[3] = ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[3];
2642    }
2643    else
2644    {
2645       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[0] = ulUpTnlInfo->teId[0];
2646       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[1] = ulUpTnlInfo->teId[1];
2647       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[2] = ulUpTnlInfo->teId[2];
2648       ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[3] = ulUpTnlInfo->teId[3];
2649    }
2650    return ROK;
2651 }/*End of BuildULTnlInfo*/
2652
2653 /*******************************************************************
2654  *
2655  * @brief Builds DRBS to be setup
2656  *
2657  * @details
2658  *
2659  *    Function : BuildDRBSetup
2660  *
2661  *    Functionality: Constructs the DRB's for UESetReq
2662  *
2663  * @params[in] DRBs_ToBeSetup_List_t *drbSet
2664  *
2665  * @return ROK     - success
2666  *         RFAILED - failure
2667  *
2668  * ****************************************************************/
2669 uint8_t BuildDRBSetup(uint32_t duId, CuUeCb *ueCb, DRBs_ToBeSetup_List_t *drbSet)
2670 {
2671    uint8_t idx = 0, extIeIdx = 0;
2672    uint8_t elementCnt = 0, drbCnt = 0;
2673    uint8_t BuildQOSInforet = 0,BuildSNSSAIret = 0;
2674    uint8_t BuildFlowsMapret =0, BuildULTnlInforet =0;
2675    DRBs_ToBeSetup_Item_t *drbSetItem;
2676    ProtocolExtensionContainer_4624P33_t *drbToBeSetupExt;
2677    DRBs_ToBeSetup_ItemExtIEs_t *drbToBeSetupExtIe = NULLP;
2678
2679    if(ueCb->state == UE_HANDOVER_IN_PROGRESS)
2680       drbCnt = ueCb->numDrb;
2681    else
2682       drbCnt = MAX_DRB_SET_UE_CONTEXT_SETUP_REQ;
2683    drbSet->list.count = drbCnt;
2684
2685    drbSet->list.size = drbCnt*sizeof(DRBs_ToBeSetup_ItemIEs_t *);
2686    CU_ALLOC(drbSet->list.array,drbSet->list.size);
2687    if(drbSet->list.array == NULLP)
2688    {
2689       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDRBSetup");
2690       return RFAILED;
2691    }
2692
2693    for(idx=0; idx<drbCnt; idx++)
2694    {
2695       CU_ALLOC(drbSet->list.array[idx],sizeof(DRBs_ToBeSetup_ItemIEs_t));
2696       if(drbSet->list.array[idx] == NULLP)
2697       {
2698          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDRBSetup for arry idx [%d]", idx);
2699          return RFAILED;
2700       }
2701
2702       drbSet->list.array[idx]->id = ProtocolIE_ID_id_DRBs_ToBeSetup_Item;
2703       drbSet->list.array[idx]->criticality = Criticality_ignore;
2704       drbSet->list.array[idx]->value.present = DRBs_ToBeSetup_ItemIEs__value_PR_DRBs_ToBeSetup_Item;
2705       drbSetItem = &drbSet->list.array[idx]->value.choice.DRBs_ToBeSetup_Item;
2706       /*dRBID*/
2707       if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
2708       {
2709          drbSetItem->dRBID = idx + 1;
2710          ueCb->drbList[ueCb->numDrb].drbId = drbSetItem->dRBID;
2711       }
2712       else
2713          drbSetItem->dRBID = ueCb->drbList[idx].drbId;
2714
2715       /*qoSInformation*/
2716       drbSetItem->qoSInformation.present = QoSInformation_PR_choice_extension;
2717       CU_ALLOC(drbSetItem->qoSInformation.choice.choice_extension,sizeof(QoSInformation_ExtIEs_t));
2718       if(drbSetItem->qoSInformation.choice.choice_extension == NULLP)
2719       {
2720          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed for QOS choice extension in BuildDRBSetup");
2721          return RFAILED;
2722       }
2723       drbSetItem->qoSInformation.choice.choice_extension->id = ProtocolIE_ID_id_DRB_Information;
2724       drbSetItem->qoSInformation.choice.choice_extension->criticality = Criticality_ignore;
2725       drbSetItem->qoSInformation.choice.choice_extension->value.present = QoSInformation_ExtIEs__value_PR_DRB_Information;
2726       if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
2727          BuildQOSInforet =  BuildQOSInfo(&ueCb->drbList[ueCb->numDrb].qos, &drbSetItem->qoSInformation.choice.\
2728                choice_extension->value.choice.DRB_Information.dRB_QoS, ProtocolIE_ID_id_DRBs_ToBeSetup_Item, PDU_SESSION_ID_1, FALSE);
2729       else
2730          BuildQOSInforet =  BuildQOSInfo(&ueCb->drbList[idx].qos, &drbSetItem->qoSInformation.choice.\
2731                choice_extension->value.choice.DRB_Information.dRB_QoS, ProtocolIE_ID_id_DRBs_ToBeSetup_Item, PDU_SESSION_ID_1, TRUE);
2732       if(BuildQOSInforet != ROK)
2733       {
2734          DU_LOG("\nERROR  -->  F1AP : Failed to build QOS Info in BuildDRBSetup");
2735          return RFAILED;
2736       }
2737
2738       /*SNSSAI*/
2739       if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
2740          BuildSNSSAIret = BuildSNSSAI(&ueCb->drbList[ueCb->numDrb], &drbSetItem->qoSInformation.choice.\
2741                choice_extension->value.choice.DRB_Information.sNSSAI, cuCb.snssaiList[0], FALSE);
2742       else
2743          BuildSNSSAIret = BuildSNSSAI(&ueCb->drbList[idx], &drbSetItem->qoSInformation.choice.\
2744                choice_extension->value.choice.DRB_Information.sNSSAI, cuCb.snssaiList[0], TRUE);
2745       if(BuildSNSSAIret != ROK)
2746       {
2747          DU_LOG("\nERROR  -->  F1AP : Failed to build SNSSAI Info in BuildDRBSetup");
2748          return RFAILED;
2749       }
2750
2751       /*Flows mapped to DRB List*/
2752       if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
2753          BuildFlowsMapret = BuildFlowsMap(&ueCb->drbList[ueCb->numDrb], &drbSetItem->qoSInformation.choice.choice_extension->\
2754                value.choice.DRB_Information.flows_Mapped_To_DRB_List, ProtocolIE_ID_id_DRBs_ToBeSetup_Item, FALSE);
2755       else
2756          BuildFlowsMapret = BuildFlowsMap(&ueCb->drbList[idx], &drbSetItem->qoSInformation.choice.choice_extension->\
2757                value.choice.DRB_Information.flows_Mapped_To_DRB_List, ProtocolIE_ID_id_DRBs_ToBeSetup_Item, TRUE);
2758       if(BuildFlowsMapret != ROK)
2759       {
2760          DU_LOG("\nERROR  -->  F1AP : Failed to build Flow Map Info in BuildDRBSetup");
2761          return RFAILED;
2762       }
2763
2764       /*ULUPTNLInformation To Be Setup List*/
2765       if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
2766          BuildULTnlInforet = BuildULTnlInfo(duId, &ueCb->drbList[ueCb->numDrb].ulUpTnlInfo, &drbSetItem->uLUPTNLInformation_ToBeSetup_List,\
2767                FALSE);
2768       else
2769          BuildULTnlInforet = BuildULTnlInfo(duId, &ueCb->drbList[idx].ulUpTnlInfo, &drbSetItem->uLUPTNLInformation_ToBeSetup_List,\
2770                TRUE);
2771       if(BuildULTnlInforet != ROK)
2772       {
2773          DU_LOG("\nERROR  -->  F1AP : Failed to build tunnel Info in BuildDRBSetup");
2774          return RFAILED;
2775       }
2776
2777       /*RLCMode*/
2778       if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
2779       {
2780          drbSetItem->rLCMode = RLCMode_rlc_um_bidirectional;
2781          ueCb->drbList[ueCb->numDrb].rlcMode = drbSetItem->rLCMode;
2782       }
2783       else
2784          drbSetItem->rLCMode = ueCb->drbList[idx].rlcMode;
2785
2786       /* DL PDCP SN Length */
2787       if(ueCb->state == UE_HANDOVER_IN_PROGRESS)
2788       {
2789          CU_ALLOC(drbToBeSetupExt, sizeof(ProtocolExtensionContainer_4624P33_t));
2790          if(!drbToBeSetupExt)
2791          {
2792             DU_LOG("\nERROR  -->  F1AP : Failed to allocate memory for extension IE list in BuildDRBSetup");
2793             return RFAILED;
2794          }
2795
2796          elementCnt = 1;
2797          drbToBeSetupExt->list.count = elementCnt;
2798          drbToBeSetupExt->list.size = drbToBeSetupExt->list.count * sizeof(DRBs_ToBeSetup_ItemExtIEs_t *);
2799
2800          CU_ALLOC(drbToBeSetupExt->list.array, drbToBeSetupExt->list.size);
2801          if(!drbToBeSetupExt->list.array)
2802          {
2803              DU_LOG("\nERROR  -->  F1AP : Failed to allocated memory for extension array in BuildDRBSetup");
2804              return RFAILED;
2805          }
2806
2807          for(extIeIdx=0; extIeIdx < drbToBeSetupExt->list.count; extIeIdx++)
2808          {
2809             CU_ALLOC(drbToBeSetupExt->list.array[extIeIdx], sizeof(DRBs_ToBeSetup_ItemExtIEs_t));
2810             if(!drbToBeSetupExt->list.array[extIeIdx])
2811             {
2812                DU_LOG("\nERROR  -->  F1AP : Failed to allocated memory for extension array element in BuildDRBSetup");
2813                return RFAILED;
2814             }
2815          }
2816
2817          extIeIdx = 0;
2818          drbToBeSetupExtIe = drbToBeSetupExt->list.array[extIeIdx];
2819
2820          drbToBeSetupExtIe->id = ProtocolIE_ID_id_DLPDCPSNLength;
2821          drbToBeSetupExtIe->criticality = Criticality_ignore;
2822          drbToBeSetupExtIe->extensionValue.present = DRBs_ToBeSetup_ItemExtIEs__extensionValue_PR_PDCPSNLength;
2823          drbToBeSetupExtIe->extensionValue.choice.PDCPSNLength = PDCPSNLength_twelve_bits;
2824          drbSetItem->iE_Extensions = drbToBeSetupExt;
2825       }
2826
2827       if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
2828          ueCb->numDrb++;
2829    }
2830    return ROK;
2831 }/* End of BuildDRBSetup*/
2832
2833 /*******************************************************************
2834  *
2835  * @brief Deallocating memory of function BuildAndSendUESetReq
2836  *
2837  * @details
2838  *
2839  *    Function : FreeNrcgi
2840  *
2841  *    Functionality: Deallocating memory for function BuildNrcgi
2842  *
2843  * @params[in] NRCGI_t *nrcgi
2844  *
2845  * @return void
2846  *
2847  *******************************************************************/
2848 void FreeNrcgi(NRCGI_t *nrcgi)
2849 {
2850    if(nrcgi->pLMN_Identity.buf != NULLP)
2851    {
2852       if(nrcgi->nRCellIdentity.buf != NULLP)
2853       {
2854          CU_FREE(nrcgi->nRCellIdentity.buf, nrcgi->nRCellIdentity.size);
2855       }
2856       CU_FREE(nrcgi->pLMN_Identity.buf, nrcgi->pLMN_Identity.size);
2857    }
2858 }
2859 /*******************************************************************
2860  *
2861  * @brief  Deallocating memory of function BuildAndSendUESetReq
2862  *
2863  * @details
2864  *
2865  *    Function : FreeSplCellList
2866  *
2867  *    Functionality: Deallocating memory for function BuildSplCellList
2868  *
2869  * @params[in] SCell_ToBeSetup_List_t *spCellLst
2870  *
2871  * @return void
2872  *
2873  *
2874  * *****************************************************************/
2875 void FreeSplCellList(SCell_ToBeSetup_List_t *spCellLst)
2876 {
2877    uint8_t  cellidx;
2878    if(spCellLst->list.array != NULLP)
2879    {
2880       for(cellidx=0; cellidx<spCellLst->list.count; cellidx++)
2881       {
2882          if(cellidx==0&&spCellLst->list.array[cellidx]!=NULLP)
2883          {
2884             FreeNrcgi(&spCellLst->list.array[cellidx]->value.choice.SCell_ToBeSetup_Item.sCell_ID);
2885          }
2886          if(spCellLst->list.array[cellidx]!=NULLP)
2887          {
2888             CU_FREE(spCellLst->list.array[cellidx],sizeof(SCell_ToBeSetup_ItemIEs_t));
2889          }
2890       }
2891       CU_FREE(spCellLst->list.array,spCellLst->list.size);
2892    }
2893 }
2894 /*******************************************************************
2895  *
2896  * @brief Deallocating memory of function BuildAndSendUESetReq
2897  *
2898  * @details
2899  *
2900  *    Function : FreeSRBSetup
2901  *
2902  *    Functionality: Deallocating memory for function BuildSRBSetup
2903  *
2904  * @params[in] SRBs_ToBeSetup_List_t *srbSet
2905  *
2906  * @return void
2907  *
2908  *
2909  * ******************************************************************/
2910 void FreeSRBSetup(SRBs_ToBeSetup_List_t *srbSet)
2911 {
2912    uint8_t srbidx;
2913    if(srbSet->list.array != NULLP)
2914    {
2915       for(srbidx=0; srbidx<srbSet->list.count; srbidx++)
2916       {
2917          if(srbSet->list.array[srbidx]!=NULLP)
2918          {
2919             CU_FREE(srbSet->list.array[srbidx],sizeof(SRBs_ToBeSetup_ItemIEs_t));
2920          }
2921       }
2922       CU_FREE(srbSet->list.array,srbSet->list.size);
2923    }
2924 }
2925 /*******************************************************************
2926  *
2927  * @brief Deallocating memory of function BuildAndSendUESetReq
2928  *
2929  * @details
2930  *
2931  *    Function : FreeQOSInfo
2932  *
2933  *    Functionality:  Deallocating memory for function BuildQOSInfo
2934  *
2935  * @params[in] QoSFlowLevelQoSParameters_t *drbQos
2936  *
2937  * @return void
2938  *
2939  * ****************************************************************/
2940 void FreeQOSInfo(QoSFlowLevelQoSParameters_t *drbQos)
2941 {
2942    ProtocolExtensionContainer_4624P74_t *qosIeExt = NULLP;
2943    uint8_t qosCntIdx = 0;
2944
2945    if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI != NULLP)
2946    {
2947       if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow!=NULLP)
2948       {
2949          if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume!=NULLP)
2950          {
2951             CU_FREE(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume,\
2952                   sizeof(MaxDataBurstVolume_t));
2953          }
2954          CU_FREE(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow,\
2955                sizeof(AveragingWindow_t));
2956       }
2957       CU_FREE(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI,\
2958             sizeof(NonDynamic5QIDescriptor_t));
2959    }
2960    if(drbQos->iE_Extensions)
2961    {
2962       qosIeExt = (ProtocolExtensionContainer_4624P74_t *)drbQos->iE_Extensions;
2963       if(qosIeExt->list.array != NULLP)
2964       {
2965          for(qosCntIdx=0; qosCntIdx <  qosIeExt->list.count; qosCntIdx++)
2966          {
2967             if(qosIeExt->list.array[qosCntIdx])
2968             {
2969                CU_FREE(qosIeExt->list.array[qosCntIdx], sizeof(QoSFlowLevelQoSParameters_ExtIEs_t));
2970             }
2971          }
2972          CU_FREE(qosIeExt->list.array, qosIeExt->list.size);
2973       }
2974
2975       CU_FREE(drbQos->iE_Extensions, sizeof(ProtocolExtensionContainer_4624P74_t));
2976    }
2977 }
2978 /*******************************************************************
2979  *
2980  * @brief Deallocating memory of function BuildAndSendUESetReq
2981  *
2982  * @details
2983  *
2984  *    Function : FreeULTnlInfo
2985  *
2986  *    Functionality:  Deallocating memory for function BuildULTnlInfo
2987  *
2988  * @params[in] ULUPTNLInformation_ToBeSetup_List_t *ulInfo
2989  *
2990  * @return void
2991  *
2992
2993  * ****************************************************************/
2994 void FreeULTnlInfo(ULUPTNLInformation_ToBeSetup_List_t *ulInfo)
2995 {
2996    uint8_t ulidx=0;
2997    if(ulInfo->list.array != NULLP)
2998    {
2999       for(ulidx=0; ulidx<ulInfo->list.count; ulidx++)
3000       {
3001          if(ulidx==0&&ulInfo->list.array[ulidx]!=NULLP)
3002          {
3003             if(ulInfo->list.array[ulidx]->uLUPTNLInformation.choice.gTPTunnel!=NULLP)
3004             {
3005                if(ulInfo->list.array[ulidx]->uLUPTNLInformation.choice.gTPTunnel->\
3006                      transportLayerAddress.buf != NULLP)
3007                {
3008                   if(ulInfo->list.array[ulidx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf\
3009                         !=NULLP)
3010                   {
3011                      CU_FREE(ulInfo->list.array[ulidx]->uLUPTNLInformation.choice.gTPTunnel->\
3012                            gTP_TEID.buf,ulInfo->list.array[ulidx]->uLUPTNLInformation.choice.\
3013                            gTPTunnel->gTP_TEID.size);
3014                   }
3015                   CU_FREE(ulInfo->list.array[ulidx]->uLUPTNLInformation.choice.gTPTunnel->\
3016                         transportLayerAddress.buf,ulInfo->list.array[ulidx]->\
3017                         uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.size);
3018                }
3019                CU_FREE(ulInfo->list.array[ulidx]->uLUPTNLInformation.choice.gTPTunnel,\
3020                      sizeof(GTPTunnel_t));
3021             }
3022          }
3023          if(ulInfo->list.array[ulidx]!=NULLP)
3024          {
3025             CU_FREE(ulInfo->list.array[ulidx],sizeof(ULUPTNLInformation_ToBeSetup_Item_t));
3026          }
3027       }
3028       CU_FREE(ulInfo->list.array,ulInfo->list.size);
3029    }
3030 }
3031 /*******************************************************************
3032  *
3033  * @brief Deallocating memory for BuildAndSendUESetReq
3034  *
3035  * @details
3036  *
3037  *    Function : FreeDRBSetup
3038  *
3039  *    Functionality:  Deallocating memory for BuildDRBSetup
3040  *
3041  * @params[in] DRBs_ToBeSetup_List_t *drbSet
3042  *
3043  * @return void
3044  *
3045  * ****************************************************************/
3046 void FreeDRBSetup(DRBs_ToBeSetup_List_t *drbSet)
3047 {
3048    DRBs_ToBeSetup_Item_t *drbSetItem;
3049    ProtocolExtensionContainer_4624P74_t *qosIeExt = NULLP;
3050
3051    uint8_t  flowidx = 0, drbidx = 0, qosCntIdx = 0;
3052
3053    /*BUG: Need to check drbSet->list.array is not Empty to procced with Deletion*/
3054    if(drbSet->list.array != NULLP)
3055    {
3056       for(drbidx=0; drbidx<drbSet->list.count; drbidx++)
3057       {
3058               if(drbSet->list.array[drbidx] != NULLP)
3059               {
3060                  drbSetItem =&drbSet->list.array[drbidx]->value.choice.DRBs_ToBeSetup_Item;
3061                  if(drbSetItem->qoSInformation.choice.choice_extension != NULLP)
3062                  {
3063                     if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
3064                                   qoS_Characteristics.choice.non_Dynamic_5QI !=NULLP)
3065                {
3066                    if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
3067                                           qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow!=NULLP)
3068                             {
3069                                if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
3070                                           qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume!=NULLP)
3071                                {
3072                                        if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sST.buf!=NULLP)
3073                                        {
3074                                           if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD!=NULLP)
3075                                           {
3076                                              if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD->buf!=NULLP)
3077                                              {
3078                                                      if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.\
3079                                                             flows_Mapped_To_DRB_List.list.array != NULLP)
3080                                                      {
3081                                                          for(flowidx=0;flowidx<drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.\
3082                                                                       flows_Mapped_To_DRB_List.list.count; flowidx++)
3083                                                          {
3084                                                              if(flowidx==0&&drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
3085                                                                            DRB_Information.flows_Mapped_To_DRB_List.list.array[flowidx]!=NULLP)
3086                                                              {
3087                                                                      if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
3088                                                                                 DRB_Information.flows_Mapped_To_DRB_List.list.array[flowidx]->qoSFlowLevelQoSParameters.\
3089                                                                                 qoS_Characteristics.choice.non_Dynamic_5QI!=NULLP)
3090                                                                      {
3091                                                                          if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
3092                                                                                    DRB_Information.flows_Mapped_To_DRB_List.list.array[flowidx]->qoSFlowLevelQoSParameters.\
3093                                                                                    qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow!=NULLP)
3094                                                                          {
3095                                                                                  if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
3096                                                                                  DRB_Information.flows_Mapped_To_DRB_List.list.array[flowidx]->qoSFlowLevelQoSParameters.\
3097                                                                                   qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume!=NULLP)
3098                                                                                   {
3099                                                                                       FreeULTnlInfo(&drbSetItem->uLUPTNLInformation_ToBeSetup_List);
3100                                                                                       CU_FREE(drbSetItem->uLConfiguration,sizeof(ULConfiguration_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->maxDataBurstVolume,\
3105                                                                                                    sizeof(MaxDataBurstVolume_t));
3106                                                                                   }
3107                                                          CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
3108                                                                                            DRB_Information.flows_Mapped_To_DRB_List.list.array[flowidx]->qoSFlowLevelQoSParameters.\
3109                                                                                            qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow,sizeof(AveragingWindow_t));
3110                                                                          }
3111                                                                          CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
3112                                                                                        DRB_Information.flows_Mapped_To_DRB_List.list.array[flowidx]->qoSFlowLevelQoSParameters.\
3113                                                                                        qoS_Characteristics.choice.non_Dynamic_5QI,sizeof(NonDynamic5QIDescriptor_t));
3114                                                                      }
3115                                                             }
3116                                                             if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
3117                                                                      DRB_Information.flows_Mapped_To_DRB_List.list.array[flowidx]!=NULLP)
3118                                                             {
3119                                                                     CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
3120                                                                                   DRB_Information.flows_Mapped_To_DRB_List.list.array[flowidx],sizeof(Flows_Mapped_To_DRB_Item_t));
3121                                                             }
3122                                                         }
3123                                                         CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.\
3124                                                                       flows_Mapped_To_DRB_List.list.array,drbSetItem->qoSInformation.choice.choice_extension->value.\
3125                                                                       choice.DRB_Information.flows_Mapped_To_DRB_List.list.size);
3126                                                      }
3127                                                      CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD->buf,\
3128                                                              drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD->size);
3129                                             }
3130                                             CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD,\
3131                                                               sizeof(OCTET_STRING_t));
3132                                        }
3133                                        CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sST.buf,\
3134                                                     drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sST.size);
3135                                     }
3136                                     CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
3137                                             qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume,sizeof(MaxDataBurstVolume_t));
3138                             }
3139                        CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
3140                                          qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow,sizeof(AveragingWindow_t));
3141                          }
3142                          CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
3143                                        qoS_Characteristics.choice.non_Dynamic_5QI, sizeof(NonDynamic5QIDescriptor_t));
3144              }
3145              if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
3146                         iE_Extensions != NULLP)
3147              {
3148                 qosIeExt = (ProtocolExtensionContainer_4624P74_t *)drbSetItem->qoSInformation.choice.\
3149                                     choice_extension->value.choice.DRB_Information.dRB_QoS.iE_Extensions;
3150                  if(qosIeExt->list.array != NULLP)
3151                  {
3152                    for(qosCntIdx=0; qosCntIdx < qosIeExt->list.count; qosCntIdx++)
3153                    {
3154                       if(qosIeExt->list.array[qosCntIdx] != NULLP)
3155                       {
3156                          CU_FREE(qosIeExt->list.array[qosCntIdx], sizeof(QoSFlowLevelQoSParameters_ExtIEs_t));
3157                       }
3158                     }
3159                     CU_FREE(qosIeExt->list.array, qosIeExt->list.size);
3160                   }
3161                   CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
3162                                    iE_Extensions, sizeof(ProtocolExtensionContainer_4624P74_t));
3163               }
3164
3165                   CU_FREE(drbSetItem->qoSInformation.choice.choice_extension,sizeof(QoSInformation_ExtIEs_t));
3166                 }
3167                 CU_FREE(drbSet->list.array[drbidx],sizeof(DRBs_ToBeSetup_ItemIEs_t));
3168               }
3169       }
3170       CU_FREE(drbSet->list.array,drbSet->list.size);
3171    }
3172 }
3173
3174
3175 /*******************************************************************
3176  *
3177  * @brief Free the UE Setup Request
3178  *
3179  * @details
3180  *
3181  *    Function : FreeUeContextSetupReq
3182  *
3183  *    Functionality: Deallocate the memory of BuildUESetReq
3184  *
3185  * @params[in]  F1AP_PDU_t  *f1apMsg
3186  *
3187  * @return void
3188  *
3189  *
3190  * ****************************************************************/
3191 void FreeUeContextSetupReq(F1AP_PDU_t  *f1apMsg)
3192 {
3193    uint8_t idx, ieId;
3194    UEContextSetupRequest_t  *ueSetReq = NULLP;
3195
3196    if(f1apMsg != NULLP)
3197    {
3198       if(f1apMsg->choice.initiatingMessage != NULLP)
3199       {
3200          ueSetReq = &f1apMsg->choice.initiatingMessage->value.choice.UEContextSetupRequest;
3201          if(ueSetReq->protocolIEs.list.array != NULLP)
3202          {
3203             for(idx = 0; idx < ueSetReq->protocolIEs.list.count; idx++)
3204             {
3205                if(ueSetReq->protocolIEs.list.array[idx])
3206                {
3207                   switch(ueSetReq->protocolIEs.list.array[idx]->id)
3208                   {
3209                      case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
3210                         break;
3211                      case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
3212                         break;
3213                      case ProtocolIE_ID_id_SpCell_ID:
3214                         FreeNrcgi(&ueSetReq->protocolIEs.list.array[idx]->value.choice.NRCGI);
3215                         break;
3216                      case ProtocolIE_ID_id_ServCellIndex:
3217                         break;
3218                      case ProtocolIE_ID_id_SpCellULConfigured:
3219                         break;
3220                      case ProtocolIE_ID_id_CUtoDURRCInformation:
3221                         FreeCuToDuInfo(&ueSetReq->protocolIEs.list.array[idx]->value.choice.CUtoDURRCInformation);
3222                         break;
3223                      case ProtocolIE_ID_id_SCell_ToBeSetup_List:
3224                         FreeSplCellList(&ueSetReq->protocolIEs.list.array[idx]->value.choice.SCell_ToBeSetup_List);
3225                         break;
3226                      case ProtocolIE_ID_id_SRBs_ToBeSetup_List:
3227                         FreeSRBSetup(&ueSetReq->protocolIEs.list.array[idx]->value.choice.SRBs_ToBeSetup_List);
3228                         break;
3229                      case ProtocolIE_ID_id_DRBs_ToBeSetup_List:
3230                         FreeDRBSetup(&ueSetReq->protocolIEs.list.array[idx]->value.choice.DRBs_ToBeSetup_List);
3231                         break;
3232                      case ProtocolIE_ID_id_RRCContainer:
3233                         if(ueSetReq->protocolIEs.list.array[idx]->value.choice.RRCContainer.buf != NULLP)
3234                         {
3235                            CU_FREE(ueSetReq->protocolIEs.list.array[idx]->value.choice.RRCContainer.buf, \
3236                                  ueSetReq->protocolIEs.list.array[idx]->value.choice.RRCContainer.size);
3237                         }
3238                         break;
3239                      case ProtocolIE_ID_id_GNB_DU_UE_AMBR_UL:
3240                         CU_FREE(ueSetReq->protocolIEs.list.array[idx]->value.choice.BitRate.buf,\
3241                               ueSetReq->protocolIEs.list.array[idx]->value.choice.BitRate.size);
3242                         break;
3243                      default:
3244                         DU_LOG("\nERROR  -->  F1AP: Invalid event type %ld", ueSetReq->protocolIEs.list.array[idx]->id);
3245                         break;
3246                   }
3247                }
3248                /*BUG: Break is causing to exit the for Loop before complete traversing and freeing of each IE*/
3249             }
3250             for(ieId=0; ieId<idx; ieId++)
3251             {
3252                if(ueSetReq->protocolIEs.list.array[ieId] != NULLP)
3253                {
3254                   CU_FREE(ueSetReq->protocolIEs.list.array[ieId],sizeof(UEContextSetupRequestIEs_t));
3255                }
3256             }
3257             CU_FREE(ueSetReq->protocolIEs.list.array,ueSetReq->protocolIEs.list.size);
3258          }
3259          CU_FREE(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
3260       }
3261       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
3262    }
3263 }
3264
3265 /**Filling cell group info **/
3266 /*******************************************************************
3267  *
3268  * @brief Build Control resource set to add/modify list
3269  *
3270  * @details
3271  *
3272  *    Function : BuildControlRSetToAddModList
3273  *
3274  *    Functionality: Build Control resource set to add/modify list
3275  *
3276  * @params[in]
3277  * struct PDCCH_Config__controlResourceSetToAddModList *controlRSetList
3278  *
3279  * @return ROK     - success
3280  *         RFAILED - failure
3281  *
3282  * ****************************************************************/
3283    uint8_t BuildControlRSetToAddModList
3284 (
3285  struct PDCCH_Config__controlResourceSetToAddModList *controlRSetList
3286  )
3287 {
3288    uint8_t idx;
3289    uint8_t elementCnt;
3290    uint8_t numBytes, bitsUnused;
3291    struct ControlResourceSet *controlRSet;
3292    uint8_t freqDomainResource[FREQ_DOM_RSRC_SIZE] = {0};
3293    uint8_t coreset0EndPrb, coreset1StartPrb, coreset1NumPrb;
3294
3295    elementCnt = 1;
3296    controlRSetList->list.count = elementCnt;
3297    controlRSetList->list.size = \
3298                                 elementCnt * sizeof(struct ControlResourceSet *);
3299
3300    controlRSetList->list.array = NULLP;
3301    CU_ALLOC(controlRSetList->list.array, controlRSetList->list.size);
3302    if(!controlRSetList->list.array)
3303    {
3304       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3305       return RFAILED;
3306    }
3307
3308    for(idx = 0; idx < elementCnt; idx++)
3309    {
3310       controlRSetList->list.array[idx] = NULLP;
3311       CU_ALLOC(controlRSetList->list.array[idx], sizeof(struct ControlResourceSet));
3312       if(!controlRSetList->list.array[idx])
3313       {
3314          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3315          return RFAILED;
3316       }
3317    }
3318
3319    idx=0;
3320    controlRSet = controlRSetList->list.array[idx];
3321    controlRSet->controlResourceSetId = PDCCH_CTRL_RSRC_SET_ONE_ID;
3322
3323    /* Values harcoded according to our design:
3324     * size 6 bytes
3325     * 3 LSBs unsued
3326     * Bit string stored ff0000000000
3327     */
3328    numBytes = 6;
3329    bitsUnused = 3;
3330    controlRSet->frequencyDomainResources.size = numBytes * sizeof(uint8_t);
3331    controlRSet->frequencyDomainResources.buf = NULLP;
3332    CU_ALLOC(controlRSet->frequencyDomainResources.buf, \
3333          controlRSet->frequencyDomainResources.size);
3334    if(!controlRSet->frequencyDomainResources.buf)
3335    {
3336       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3337       return RFAILED;
3338    }
3339
3340    memset(controlRSet->frequencyDomainResources.buf, 0, FREQ_DOM_RSRC_SIZE);
3341    coreset0EndPrb = CORESET0_END_PRB;
3342    coreset1StartPrb = coreset0EndPrb + 6;
3343    coreset1NumPrb = CORESET1_NUM_PRB;
3344    /* calculate the PRBs */
3345    fillCoresetFeqDomAllocMap(((coreset1StartPrb)/6), (coreset1NumPrb/6), freqDomainResource);
3346    memcpy(controlRSet->frequencyDomainResources.buf, freqDomainResource, FREQ_DOM_RSRC_SIZE);
3347    controlRSet->frequencyDomainResources.bits_unused = bitsUnused;
3348
3349    controlRSet->duration = PDCCH_CTRL_RSRC_SET_ONE_DURATION;
3350    controlRSet->cce_REG_MappingType.present = \
3351                                               ControlResourceSet__cce_REG_MappingType_PR_nonInterleaved;
3352
3353    controlRSet->precoderGranularity = PDCCH_CTRL_RSRC_SET_ONE_PRECOD_GRANULARITY;
3354    controlRSet->tci_StatesPDCCH_ToAddList = NULLP;
3355    controlRSet->tci_StatesPDCCH_ToReleaseList = NULLP;
3356    controlRSet->tci_PresentInDCI = NULLP;
3357 #if 0
3358    uint8_t tciStateIdx;
3359
3360    CU_ALLOC(controlRset->tci_StatesPDCCH_ToAddList, \
3361          sizeof(struct ControlResourceSet__tci_StatesPDCCH_ToAddList));
3362    if(!controlRset->tci_StatesPDCCH_ToAddList)
3363    {
3364       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3365       return RFAILED;
3366    }
3367
3368    elementCnt = 1;
3369    controlRset->tci_StatesPDCCH_ToAddList->list.count = elementCnt;
3370    controlRset->tci_StatesPDCCH_ToAddList->list.size = elementCnt * sizeof(TCI_StateId_t *);
3371    CU_ALLOC(controlRset->tci_StatesPDCCH_ToAddList->list.array, \
3372          controlRset->tci_StatesPDCCH_ToAddList->list.size)
3373       if(!controlRset->tci_StatesPDCCH_ToAddList->list.array)
3374       {
3375          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3376          return RFAILED;
3377       }
3378
3379    for(tciStateIdx = 0; tciStateIdx <elementCntl; tciStateIdx++)
3380    {
3381       CU_ALLOC(controlRset->tci_StatesPDCCH_ToAddList->list.array[tciStateIdx], sizeof(TCI_StateId_t));
3382       if(!controlRset->tci_StatesPDCCH_ToAddList->list.array[tciStateIdx])
3383       {
3384          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3385          return RFAILED;
3386       }
3387    }
3388
3389    tciStateIdx = 0;
3390    /* TODO */
3391    *(controlRset->tci_StatesPDCCH_ToAddList->list.array[tciStateIdx]);
3392
3393    CU_ALLOC(controlRset->tci_PresentInDCI, sizeof(long));
3394    if(!controlRset->tci_PresentInDCI)
3395    {
3396       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3397       return RFAILED;
3398    }
3399    /* TODO */
3400    *(controlRset->tci_PresentInDCI);
3401 #endif
3402
3403    controlRSet->pdcch_DMRS_ScramblingID = NULLP;
3404    CU_ALLOC(controlRSet->pdcch_DMRS_ScramblingID, sizeof(long));
3405    if(!controlRSet->pdcch_DMRS_ScramblingID)
3406    {
3407       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3408       return RFAILED;
3409    }
3410    *(controlRSet->pdcch_DMRS_ScramblingID) = SCRAMBLING_ID;
3411
3412    return ROK;
3413 } /* End BuildControlRSetToAddModList */
3414
3415 /*******************************************************************
3416  *
3417  * @brief Build search space to add/modify list
3418  *
3419  * @details
3420  *
3421  *    Function : BuildSearchSpcToAddModList
3422  *
3423  *    Functionality: Build search space to add/modify list
3424  *
3425  * @params[in]
3426  * @return ROK     - success
3427  *         RFAILED - failure
3428  *
3429  * ****************************************************************/
3430    uint8_t BuildSearchSpcToAddModList
3431 (
3432  struct PDCCH_Config__searchSpacesToAddModList *searchSpcList
3433  )
3434 {
3435    uint8_t idx;
3436    uint8_t numBytes;
3437    uint8_t byteIdx;
3438    uint8_t bitsUnused;
3439    uint8_t elementCnt;
3440    struct SearchSpace *searchSpc;
3441
3442    elementCnt = 1;
3443    searchSpcList->list.count = elementCnt;
3444    searchSpcList->list.size = elementCnt * sizeof(struct SearchSpace *);
3445
3446    searchSpcList->list.array = NULLP;
3447    CU_ALLOC(searchSpcList->list.array, searchSpcList->list.size);
3448    if(!searchSpcList->list.array)
3449    {
3450       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3451       return RFAILED;
3452    }
3453
3454    for(idx = 0; idx < elementCnt; idx++)
3455    {
3456       searchSpcList->list.array[idx] = NULLP;
3457       CU_ALLOC(searchSpcList->list.array[idx], sizeof(struct SearchSpace));
3458       if(!searchSpcList->list.array[idx])
3459       {
3460          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3461          return RFAILED;
3462       }
3463    }
3464
3465    idx = 0;
3466    searchSpc = searchSpcList->list.array[idx];
3467
3468    searchSpc->searchSpaceId = PDCCH_SRCH_SPC_TWO_ID;
3469
3470    searchSpc->controlResourceSetId = NULLP;
3471    CU_ALLOC(searchSpc->controlResourceSetId, sizeof(ControlResourceSetId_t));
3472    if(!searchSpc->controlResourceSetId)
3473    {
3474       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3475       return RFAILED;
3476    }
3477    *(searchSpc->controlResourceSetId) = PDCCH_CTRL_RSRC_SET_ONE_ID;
3478
3479    searchSpc->monitoringSlotPeriodicityAndOffset = NULLP;
3480    CU_ALLOC(searchSpc->monitoringSlotPeriodicityAndOffset, \
3481          sizeof(struct SearchSpace__monitoringSlotPeriodicityAndOffset));
3482    if(!searchSpc->monitoringSlotPeriodicityAndOffset)
3483    {
3484       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3485       return RFAILED;
3486    }
3487    searchSpc->monitoringSlotPeriodicityAndOffset->present = \
3488                                                             SearchSpace__monitoringSlotPeriodicityAndOffset_PR_sl1;
3489
3490    searchSpc->duration = NULLP;
3491    searchSpc->monitoringSymbolsWithinSlot = NULLP;
3492    CU_ALLOC(searchSpc->monitoringSymbolsWithinSlot, sizeof(BIT_STRING_t));
3493    if(!searchSpc->monitoringSymbolsWithinSlot)
3494    {
3495       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3496       return RFAILED;
3497    }
3498
3499    /* Values taken from reference logs :
3500     * size 2 bytes
3501     * 2 LSBs unsued
3502     * Bit string stores 8000
3503     */
3504    numBytes = 2;
3505    bitsUnused = 2;
3506
3507    searchSpc->monitoringSymbolsWithinSlot->size = numBytes * sizeof(uint8_t);
3508    searchSpc->monitoringSymbolsWithinSlot->buf = NULLP;
3509    CU_ALLOC(searchSpc->monitoringSymbolsWithinSlot->buf, \
3510          searchSpc->monitoringSymbolsWithinSlot->size);
3511    if(!searchSpc->monitoringSymbolsWithinSlot->buf)
3512    {
3513       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3514       return RFAILED;
3515    }
3516
3517    byteIdx = 0;
3518    searchSpc->monitoringSymbolsWithinSlot->buf[byteIdx++] = \
3519                                                             PDCCH_SYMBOL_WITHIN_SLOT /* setting MSB to 128 i.e. 0x80 */;
3520    searchSpc->monitoringSymbolsWithinSlot->buf[byteIdx++] = 0;
3521    searchSpc->monitoringSymbolsWithinSlot->bits_unused = bitsUnused;
3522
3523    searchSpc->nrofCandidates = NULLP;
3524    CU_ALLOC(searchSpc->nrofCandidates, sizeof(struct SearchSpace__nrofCandidates));
3525    if(!searchSpc->nrofCandidates)
3526    {
3527       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3528       return RFAILED;
3529    }
3530
3531    searchSpc->nrofCandidates->aggregationLevel1 = \
3532                                                   PDCCH_SRCH_SPC_TWO_AGG_LVL1_CANDIDATE;
3533    searchSpc->nrofCandidates->aggregationLevel2 = \
3534                                                   PDCCH_SRCH_SPC_TWO_AGG_LVL2_CANDIDATE;
3535    searchSpc->nrofCandidates->aggregationLevel4 = \
3536                                                   PDCCH_SRCH_SPC_TWO_AGG_LVL4_CANDIDATE;
3537    searchSpc->nrofCandidates->aggregationLevel8 = \
3538                                                   PDCCH_SRCH_SPC_TWO_AGG_LVL8_CANDIDATE;
3539    searchSpc->nrofCandidates->aggregationLevel16 = \
3540                                                    PDCCH_SRCH_SPC_TWO_AGG_LVL16_CANDIDATE;
3541
3542    searchSpc->searchSpaceType = NULLP;
3543    CU_ALLOC(searchSpc->searchSpaceType, sizeof(struct SearchSpace__searchSpaceType));
3544    if(!searchSpc->searchSpaceType)
3545    {
3546       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3547       return RFAILED;
3548    }
3549
3550    searchSpc->searchSpaceType->present = SearchSpace__searchSpaceType_PR_ue_Specific;
3551
3552    searchSpc->searchSpaceType->choice.ue_Specific = NULLP;
3553    CU_ALLOC(searchSpc->searchSpaceType->choice.ue_Specific, \
3554          sizeof(struct SearchSpace__searchSpaceType__ue_Specific));
3555    if(!searchSpc->searchSpaceType->choice.ue_Specific)
3556    {
3557       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3558       return RFAILED;
3559    }
3560    searchSpc->searchSpaceType->choice.ue_Specific->dci_Formats = \
3561                                                                  PDCCH_SRCH_SPC_TWO_UE_SPEC_DCI_FORMAT;
3562
3563    return ROK;
3564 }/* End BuildSearchSpcToAddModList */
3565
3566 /*******************************************************************
3567  *
3568  * @brief Builds BWP DL dedicated PDCCH config
3569  *
3570  * @details
3571  *
3572  *    Function : BuildBWPDlDedPdcchCfg
3573  *
3574  *    Functionality: Builds BWP DL dedicated PDCCH config
3575  *
3576  * @params[in] struct PDCCH_Config *pdcchCfg
3577  *
3578  * @return ROK     - success
3579  *         RFAILED - failure
3580  *
3581  * ****************************************************************/
3582 uint8_t BuildBWPDlDedPdcchCfg(struct PDCCH_Config *pdcchCfg)
3583 {
3584    pdcchCfg->controlResourceSetToAddModList = NULLP;
3585    CU_ALLOC(pdcchCfg->controlResourceSetToAddModList, \
3586          sizeof(struct PDCCH_Config__controlResourceSetToAddModList));
3587    if(!pdcchCfg->controlResourceSetToAddModList)
3588    {
3589       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdcchCfg");
3590       return RFAILED;
3591    }
3592
3593    if(BuildControlRSetToAddModList(pdcchCfg->controlResourceSetToAddModList) != ROK)
3594    {
3595       return RFAILED;
3596    }
3597
3598    pdcchCfg->controlResourceSetToReleaseList = NULLP;
3599
3600    pdcchCfg->searchSpacesToAddModList = NULLP;
3601    CU_ALLOC(pdcchCfg->searchSpacesToAddModList, \
3602          sizeof(struct PDCCH_Config__searchSpacesToAddModList));
3603    if(!pdcchCfg->searchSpacesToAddModList)
3604    {
3605       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdcchCfg");
3606       return RFAILED;
3607    }
3608
3609    if(BuildSearchSpcToAddModList(pdcchCfg->searchSpacesToAddModList) != ROK)
3610    {
3611       return RFAILED;
3612    }
3613
3614    pdcchCfg->searchSpacesToReleaseList = NULLP;
3615    pdcchCfg->downlinkPreemption = NULLP;
3616    pdcchCfg->tpc_PUSCH = NULLP;
3617    pdcchCfg->tpc_PUCCH = NULLP;
3618    pdcchCfg->tpc_SRS = NULLP;
3619
3620    return ROK;
3621 }
3622
3623 /*******************************************************************
3624  *
3625  * @brief Builds DMRS DL PDSCH Mapping type A
3626  *
3627  * @details
3628  *
3629  *    Function : BuildDMRSDLPdschMapTypeA
3630  *
3631  *    Functionality: Builds DMRS DL PDSCH Mapping type A
3632  *
3633  * @params[in]
3634  * struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA *dmrsDlCfg
3635  * @return ROK     - success
3636  *         RFAILED - failure
3637  *
3638  * ****************************************************************/
3639    uint8_t BuildDMRSDLPdschMapTypeA
3640 (
3641  struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA *dmrsDlCfg
3642  )
3643 {
3644    dmrsDlCfg->present = PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA_PR_setup;
3645    dmrsDlCfg->choice.setup = NULLP;
3646    CU_ALLOC(dmrsDlCfg->choice.setup, sizeof(struct DMRS_DownlinkConfig));
3647    if(!dmrsDlCfg->choice.setup)
3648    {
3649       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
3650       return RFAILED;
3651    }
3652
3653    dmrsDlCfg->choice.setup->dmrs_Type = NULLP;
3654    dmrsDlCfg->choice.setup->dmrs_AdditionalPosition = NULLP;
3655    CU_ALLOC(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition, sizeof(long));
3656    if(!dmrsDlCfg->choice.setup->dmrs_AdditionalPosition)
3657    {
3658       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSDLPdschMapTypeA");
3659       return RFAILED;
3660    }
3661    *(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition) = DMRS_ADDITIONAL_POS;
3662
3663    dmrsDlCfg->choice.setup->maxLength = NULLP;
3664    dmrsDlCfg->choice.setup->scramblingID0 = NULLP;
3665    dmrsDlCfg->choice.setup->scramblingID1 = NULLP;
3666    dmrsDlCfg->choice.setup->phaseTrackingRS = NULLP;
3667
3668    return ROK;
3669 }
3670
3671 /*******************************************************************
3672  *
3673  * @brief Builds TCI states to add/modify list
3674  *
3675  * @details
3676  *
3677  *    Function : BuildTCIStatesToAddModList
3678  *
3679  *    Functionality:Builds TCI states to add/modify list
3680  *
3681  * @params[in]
3682  * struct PDSCH_Config__tci_StatesToAddModList *tciStatesList
3683  *
3684  * @return ROK     - success
3685  *         RFAILED - failure
3686  *
3687  * ****************************************************************/
3688 uint8_t BuildTCIStatesToAddModList(struct PDSCH_Config__tci_StatesToAddModList *tciStatesList)
3689 {
3690    return ROK;
3691 }
3692
3693 /*******************************************************************
3694  *
3695  * @brief Builds PDSCH time domain allocation list
3696  *
3697  * @details
3698  *
3699  *    Function : BuildPdschTimeDomAllocList
3700  *
3701  *    Functionality: Builds PDSCH time domain allocation list
3702  *
3703  * @params[in]
3704  * struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList
3705  *
3706  * @return ROK     - success
3707  *         RFAILED - failure
3708  *
3709  * ****************************************************************/
3710    uint8_t BuildPdschTimeDomAllocList
3711 (
3712  struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList
3713  )
3714 {
3715    uint8_t idx;
3716    uint8_t elementCnt;
3717    struct PDSCH_TimeDomainResourceAllocation *timeDomAlloc;
3718
3719    timeDomAllocList->present = \
3720                                PDSCH_Config__pdsch_TimeDomainAllocationList_PR_setup;
3721
3722    timeDomAllocList->choice.setup = NULLP;
3723    CU_ALLOC(timeDomAllocList->choice.setup, \
3724          sizeof(struct PDSCH_TimeDomainResourceAllocationList));
3725    if(!timeDomAllocList->choice.setup)
3726    {
3727       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
3728       return RFAILED;
3729    }
3730
3731    elementCnt = 2;
3732    timeDomAllocList->choice.setup->list.count = elementCnt;
3733    timeDomAllocList->choice.setup->list.size = \
3734                                                elementCnt * sizeof(struct PDSCH_TimeDomainResourceAllocation *);
3735
3736    timeDomAllocList->choice.setup->list.array = NULLP;
3737    CU_ALLOC(timeDomAllocList->choice.setup->list.array, \
3738          timeDomAllocList->choice.setup->list.size);
3739    if(!timeDomAllocList->choice.setup->list.array)
3740    {
3741       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
3742       return RFAILED;
3743    }
3744
3745    for(idx = 0; idx < elementCnt; idx++)
3746    {
3747       timeDomAllocList->choice.setup->list.array[idx] = NULLP;
3748       CU_ALLOC(timeDomAllocList->choice.setup->list.array[idx], \
3749             sizeof(struct PDSCH_TimeDomainResourceAllocation));
3750       if(!timeDomAllocList->choice.setup->list.array[idx])
3751       {
3752          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
3753          return RFAILED;
3754       }
3755    }
3756
3757    idx = 0;
3758    timeDomAlloc = timeDomAllocList->choice.setup->list.array[idx];
3759    CU_ALLOC(timeDomAlloc->k0, sizeof(long));
3760    if(!timeDomAlloc->k0)
3761    {
3762        DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
3763        return RFAILED;
3764    }
3765    *(timeDomAlloc->k0) = 0;
3766    timeDomAlloc->mappingType = PDSCH_MAPPING_TYPE_A;
3767    timeDomAlloc->startSymbolAndLength = 66;
3768
3769    idx++;
3770    timeDomAlloc = timeDomAllocList->choice.setup->list.array[idx];
3771    CU_ALLOC(timeDomAlloc->k0, sizeof(long));
3772    if(!timeDomAlloc->k0)
3773    {
3774       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
3775       return RFAILED;
3776    }
3777    *(timeDomAlloc->k0) = 1;
3778    timeDomAlloc->mappingType = PDSCH_MAPPING_TYPE_A;
3779    timeDomAlloc->startSymbolAndLength = 66;
3780
3781    return ROK;
3782 }
3783
3784 /*******************************************************************
3785  *
3786  * @brief Builds PDSCH PRB Bundling type
3787  *
3788  * @details
3789  *
3790  *    Function : BuildPdschPrbBundlingType
3791  *
3792  *    Functionality: Builds PDSCH PRB Bundling type
3793  *
3794  * @params[in]
3795  * struct PDSCH_Config__prb_BundlingType *prbBndlType
3796  *
3797  * @return ROK     - success
3798  *         RFAILED - failure
3799  *
3800  * ****************************************************************/
3801    uint8_t BuildPdschPrbBundlingType
3802 (
3803  struct PDSCH_Config__prb_BundlingType *prbBndlType
3804  )
3805 {
3806    prbBndlType->present = PDSCH_Config__prb_BundlingType_PR_staticBundling;
3807
3808    prbBndlType->choice.staticBundling = NULLP;
3809    CU_ALLOC(prbBndlType->choice.staticBundling, \
3810          sizeof(struct PDSCH_Config__prb_BundlingType__staticBundling));
3811    if(!prbBndlType->choice.staticBundling)
3812    {
3813       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschPrbBundlingType");
3814       return RFAILED;
3815    }
3816    prbBndlType->choice.staticBundling->bundleSize = NULLP;
3817
3818    return ROK;
3819 }
3820
3821 /*******************************************************************
3822  *
3823  * @brief Builds BWP DL dedicated PDSCH config
3824  *
3825  * @details
3826  *
3827  *    Function : BuildBWPDlDedPdschCfg
3828  *
3829  *    Functionality: Builds BWP DL dedicated PDSCH config
3830  *
3831  * @params[in] struct PDSCH_Config *pdschCfg
3832  *
3833  * @return ROK     - success
3834  *         RFAILED - failure
3835  *
3836  * ****************************************************************/
3837 uint8_t BuildBWPDlDedPdschCfg(struct PDSCH_Config *pdschCfg)
3838 {
3839    pdschCfg->dataScramblingIdentityPDSCH = NULLP;
3840
3841    pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA = NULLP;
3842    CU_ALLOC(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA, \
3843          sizeof(struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA));
3844    if(!pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA)
3845    {
3846       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
3847       return RFAILED;
3848    }
3849
3850    if(BuildDMRSDLPdschMapTypeA(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA) != ROK)
3851    {
3852       return RFAILED;
3853    }
3854
3855    pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeB = NULLP;
3856    pdschCfg->tci_StatesToAddModList = NULLP;
3857    pdschCfg->tci_StatesToReleaseList = NULLP;
3858    pdschCfg->vrb_ToPRB_Interleaver = NULLP;
3859 #if 0
3860    CU_ALLOC(pdschCfg->tci_StatesToAddModList, sizeof(struct PDSCH_Config__tci_StatesToAddModList));
3861    if(!pdschCfg->tci_StatesToAddModList)
3862    {
3863       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
3864       return RFAILED;
3865    }
3866    if(BuildTCIStatesToAddModList(pdschCfg->tci_StatesToAddModList) != ROK)
3867    {
3868       return RFAILED;
3869    }
3870 #endif
3871
3872    pdschCfg->resourceAllocation = RES_ALLOC_TYPE;
3873
3874    pdschCfg->pdsch_TimeDomainAllocationList = NULLP;
3875    CU_ALLOC(pdschCfg->pdsch_TimeDomainAllocationList, \
3876          sizeof(struct PDSCH_Config__pdsch_TimeDomainAllocationList));
3877    if(!pdschCfg->pdsch_TimeDomainAllocationList)
3878    {
3879       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
3880       return RFAILED;
3881    }
3882    if(BuildPdschTimeDomAllocList(pdschCfg->pdsch_TimeDomainAllocationList) != ROK)
3883    {
3884       return RFAILED;
3885    }
3886    pdschCfg->pdsch_AggregationFactor = NULLP;
3887    pdschCfg->rateMatchPatternToAddModList = NULLP;
3888    pdschCfg->rateMatchPatternToReleaseList = NULLP;
3889    pdschCfg->rateMatchPatternGroup1 = NULLP;
3890    pdschCfg->rateMatchPatternGroup2 = NULLP;
3891    pdschCfg->rbg_Size = PDSCH_RBG_SIZE;
3892    pdschCfg->mcs_Table = NULLP;
3893
3894    pdschCfg->maxNrofCodeWordsScheduledByDCI = NULLP;
3895    CU_ALLOC(pdschCfg->maxNrofCodeWordsScheduledByDCI, sizeof(long));
3896    if(!pdschCfg->maxNrofCodeWordsScheduledByDCI)
3897    {
3898       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
3899       return RFAILED;
3900    }
3901    *(pdschCfg->maxNrofCodeWordsScheduledByDCI) = PDSCH_MAX_CODEWORD_SCH_BY_DCI;
3902
3903    if(BuildPdschPrbBundlingType(&pdschCfg->prb_BundlingType) != ROK)
3904    {
3905       return RFAILED;
3906    }
3907
3908    pdschCfg->zp_CSI_RS_ResourceToAddModList = NULLP;
3909    pdschCfg->zp_CSI_RS_ResourceToReleaseList = NULLP;
3910    pdschCfg->aperiodic_ZP_CSI_RS_ResourceSetsToAddModList = NULLP;
3911    pdschCfg->aperiodic_ZP_CSI_RS_ResourceSetsToReleaseList = NULLP;
3912    pdschCfg->sp_ZP_CSI_RS_ResourceSetsToAddModList = NULLP;
3913    pdschCfg->sp_ZP_CSI_RS_ResourceSetsToReleaseList = NULLP;
3914    pdschCfg->p_ZP_CSI_RS_ResourceSet = NULLP;
3915
3916    return ROK;
3917 }
3918
3919 /*******************************************************************
3920  *
3921  * @brief Builds intitial DL BWP
3922  * @details
3923  *
3924  *    Function : BuildInitialDlBWP
3925  *
3926  *    Functionality: Builds intitial DL BWP in spCellCfgDed
3927  *
3928  * @params[in] BWP_DownlinkDedicated_t *dlBwp
3929  *
3930  * @return ROK     - success
3931  *         RFAILED - failure
3932  *
3933  * ****************************************************************/
3934 uint8_t BuildInitialDlBWP(BWP_DownlinkDedicated_t *dlBwp)
3935 {
3936    dlBwp->pdcch_Config = NULLP;
3937    CU_ALLOC(dlBwp->pdcch_Config, sizeof(struct BWP_DownlinkDedicated__pdcch_Config));
3938    if(!dlBwp->pdcch_Config)
3939    {
3940       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failure in BuildInitialDlBWP");
3941       return RFAILED;
3942    }
3943    dlBwp->pdcch_Config->present = BWP_DownlinkDedicated__pdcch_Config_PR_setup;
3944
3945    dlBwp->pdcch_Config->choice.setup = NULLP;
3946    CU_ALLOC(dlBwp->pdcch_Config->choice.setup, sizeof(struct PDCCH_Config));
3947    if(!dlBwp->pdcch_Config->choice.setup)
3948    {
3949       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failure in BuildInitialDlBWP");
3950       return RFAILED;
3951    }
3952    if(BuildBWPDlDedPdcchCfg(dlBwp->pdcch_Config->choice.setup) != ROK)
3953    {
3954       return RFAILED;
3955    }
3956
3957    dlBwp->pdsch_Config = NULLP;
3958    CU_ALLOC(dlBwp->pdsch_Config, sizeof(struct BWP_DownlinkDedicated__pdsch_Config));
3959    if(!dlBwp->pdsch_Config)
3960    {
3961       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failure in BuildInitialDlBWP");
3962       return RFAILED;
3963    }
3964    dlBwp->pdsch_Config->present = BWP_DownlinkDedicated__pdsch_Config_PR_setup;
3965
3966    dlBwp->pdsch_Config->choice.setup = NULLP;
3967    CU_ALLOC(dlBwp->pdsch_Config->choice.setup, sizeof(struct PDSCH_Config));
3968    if(!dlBwp->pdsch_Config->choice.setup)
3969    {
3970       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failure in BuildInitialDlBWP");
3971       return RFAILED;
3972    }
3973
3974    if(BuildBWPDlDedPdschCfg(dlBwp->pdsch_Config->choice.setup) != ROK)
3975    {
3976       return RFAILED;
3977    }
3978
3979    dlBwp->sps_Config = NULLP;
3980    dlBwp->radioLinkMonitoringConfig = NULLP;
3981    return ROK;
3982 }
3983
3984 /*******************************************************************
3985  *
3986  * @brief Builds DMRS UL Pusch Mapping type A
3987  *
3988  * @details
3989  *
3990  *    Function : BuildDMRSULPuschMapTypeA
3991  *
3992  *    Functionality: Builds DMRS UL Pusch Mapping type A
3993  *
3994  * @params[in]
3995  *    struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA *dmrsUlCfg
3996  * @return ROK     - success
3997  *         RFAILED - failure
3998  *
3999  * ****************************************************************/
4000    uint8_t BuildDMRSULPuschMapTypeA
4001 (
4002  struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA *dmrsUlCfg
4003  )
4004 {
4005    dmrsUlCfg->present = PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA_PR_setup;
4006    dmrsUlCfg->choice.setup= NULLP;
4007    CU_ALLOC(dmrsUlCfg->choice.setup, sizeof(DMRS_UplinkConfig_t));
4008    if(!dmrsUlCfg->choice.setup)
4009    {
4010       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
4011       return RFAILED;
4012    }
4013
4014    dmrsUlCfg->choice.setup->dmrs_Type = NULLP;
4015    dmrsUlCfg->choice.setup->dmrs_AdditionalPosition = NULLP;
4016    CU_ALLOC(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition, sizeof(long));
4017    if(!dmrsUlCfg->choice.setup->dmrs_AdditionalPosition)
4018    {
4019       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
4020       return RFAILED;
4021    }
4022    *(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition) = DMRS_ADDITIONAL_POS;
4023
4024    dmrsUlCfg->choice.setup->phaseTrackingRS = NULLP;
4025    dmrsUlCfg->choice.setup->maxLength = NULLP;
4026    dmrsUlCfg->choice.setup->transformPrecodingDisabled = NULLP;
4027    CU_ALLOC(dmrsUlCfg->choice.setup->transformPrecodingDisabled, \
4028          sizeof(struct DMRS_UplinkConfig__transformPrecodingDisabled));
4029    if(!dmrsUlCfg->choice.setup->transformPrecodingDisabled)
4030    {
4031       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
4032       return RFAILED;
4033    }
4034
4035    dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0 = NULLP;
4036    CU_ALLOC(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0,\
4037          sizeof(long));
4038    if(!dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0)
4039    {
4040       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
4041       return RFAILED;
4042    }
4043    *(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0) = SCRAMBLING_ID;
4044
4045    dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID1 = NULLP;
4046    dmrsUlCfg->choice.setup->transformPrecodingEnabled = NULLP;
4047    return ROK;
4048 }
4049
4050 /*******************************************************************
4051  *
4052  * @brief Build PUSCH time domain allocation list
4053  *
4054  * @details
4055  *
4056  *    Function : BuildPuschTimeDomAllocList
4057  *
4058  *    Functionality: Build PUSCH time domain allocation list
4059  *
4060  * @params[in]
4061  * struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList
4062  *
4063  * @return ROK     - success
4064  *         RFAILED - failure
4065  *
4066  * ****************************************************************/
4067    uint8_t BuildPuschTimeDomAllocList
4068 (
4069  struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList
4070  )
4071 {
4072    uint8_t idx;
4073    uint8_t elementCnt;
4074    PUSCH_TimeDomainResourceAllocation_t  *timeDomAlloc;
4075
4076    timeDomAllocList->present = PUSCH_Config__pusch_TimeDomainAllocationList_PR_setup;
4077    timeDomAllocList->choice.setup = NULLP;
4078    CU_ALLOC(timeDomAllocList->choice.setup, \
4079          sizeof(struct PUSCH_TimeDomainResourceAllocationList));
4080    if(!timeDomAllocList->choice.setup)
4081    {
4082       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
4083       return RFAILED;
4084    }
4085
4086    elementCnt = 2;
4087    timeDomAllocList->choice.setup->list.count = elementCnt;
4088    timeDomAllocList->choice.setup->list.size = \
4089                                                elementCnt * sizeof(PUSCH_TimeDomainResourceAllocation_t *);
4090    timeDomAllocList->choice.setup->list.array = NULLP;
4091    CU_ALLOC(timeDomAllocList->choice.setup->list.array, \
4092          timeDomAllocList->choice.setup->list.size);
4093    if(!timeDomAllocList->choice.setup->list.array)
4094    {
4095       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
4096       return RFAILED;
4097    }
4098
4099    for(idx = 0; idx < elementCnt; idx++)
4100    {
4101       timeDomAllocList->choice.setup->list.array[idx] = NULLP;
4102       CU_ALLOC(timeDomAllocList->choice.setup->list.array[idx],\
4103             sizeof(PUSCH_TimeDomainResourceAllocation_t));
4104       if(!timeDomAllocList->choice.setup->list.array[idx])
4105       {
4106          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
4107          return RFAILED;
4108       }
4109    }
4110
4111    idx = 0;
4112    timeDomAlloc = timeDomAllocList->choice.setup->list.array[idx];
4113    CU_ALLOC(timeDomAlloc->k2, sizeof(long));
4114    if(!timeDomAlloc->k2)
4115    {
4116       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
4117       return RFAILED;
4118    }
4119    *(timeDomAlloc->k2) = PUSCH_K2_CFG1;
4120    timeDomAlloc->mappingType = PUSCH_MAPPING_TYPE_A;
4121    timeDomAlloc->startSymbolAndLength = 66;
4122
4123    idx++;
4124    timeDomAlloc = timeDomAllocList->choice.setup->list.array[idx];
4125    CU_ALLOC(timeDomAlloc->k2, sizeof(long));
4126    if(!timeDomAlloc->k2)
4127    {
4128        DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
4129        return RFAILED;
4130    }
4131    *(timeDomAlloc->k2) = PUSCH_K2_CFG2;
4132    timeDomAlloc->mappingType = PUSCH_MAPPING_TYPE_A;
4133    timeDomAlloc->startSymbolAndLength = 66;
4134
4135    return ROK;
4136 }
4137
4138 /*******************************************************************
4139  *
4140  * @brief Builds BWP UL dedicated PUSCH Config
4141  *
4142  * @details
4143  *
4144  *    Function : BuildBWPUlDedPuschCfg
4145  *
4146  *    Functionality:
4147  *      Builds BWP UL dedicated PUSCH Config
4148  *
4149  * @params[in] : PUSCH_Config_t *puschCfg
4150  *
4151  * @return ROK     - success
4152  *         RFAILED - failure
4153  *
4154  * ****************************************************************/
4155 uint8_t BuildBWPUlDedPuschCfg(PUSCH_Config_t *puschCfg)
4156 {
4157    puschCfg->dataScramblingIdentityPUSCH = NULLP;
4158    CU_ALLOC(puschCfg->dataScramblingIdentityPUSCH, sizeof(long));
4159    if(!puschCfg->dataScramblingIdentityPUSCH)
4160    {
4161       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
4162       return RFAILED;
4163    }
4164    *(puschCfg->dataScramblingIdentityPUSCH) = SCRAMBLING_ID;
4165
4166    puschCfg->txConfig = NULLP;
4167    puschCfg->dmrs_UplinkForPUSCH_MappingTypeA = NULLP;
4168    CU_ALLOC(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA, \
4169          sizeof(struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA));
4170    if(!puschCfg->dmrs_UplinkForPUSCH_MappingTypeA)
4171    {
4172       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
4173       return RFAILED;
4174    }
4175
4176    if(BuildDMRSULPuschMapTypeA(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA) != ROK)
4177    {
4178       return RFAILED;
4179    }
4180
4181    puschCfg->dmrs_UplinkForPUSCH_MappingTypeB = NULLP;
4182    puschCfg->pusch_PowerControl = NULLP;
4183    puschCfg->frequencyHopping = NULLP;
4184    puschCfg->frequencyHoppingOffsetLists = NULLP;
4185    puschCfg->resourceAllocation = RES_ALLOC_TYPE;
4186
4187    puschCfg->pusch_TimeDomainAllocationList = NULLP;
4188    CU_ALLOC(puschCfg->pusch_TimeDomainAllocationList, \
4189          sizeof(struct PUSCH_Config__pusch_TimeDomainAllocationList));
4190    if(!puschCfg->pusch_TimeDomainAllocationList)
4191    {
4192       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
4193       return RFAILED;
4194    }
4195
4196    if(BuildPuschTimeDomAllocList(puschCfg->pusch_TimeDomainAllocationList) != ROK)
4197    {
4198       return RFAILED;
4199    }
4200
4201    puschCfg->pusch_AggregationFactor = NULLP;
4202    puschCfg->mcs_Table = NULLP;
4203    puschCfg->mcs_TableTransformPrecoder = NULLP;
4204    puschCfg->transformPrecoder = NULLP;
4205    CU_ALLOC(puschCfg->transformPrecoder, sizeof(long));
4206    if(!puschCfg->transformPrecoder)
4207    {
4208       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
4209       return RFAILED;
4210    }
4211    *(puschCfg->transformPrecoder) = PUSCH_TRANSFORM_PRECODER;
4212
4213    puschCfg->codebookSubset = NULLP;
4214    puschCfg->maxRank = NULLP;
4215    puschCfg->rbg_Size = NULLP;
4216    puschCfg->uci_OnPUSCH = NULLP;
4217    puschCfg->tp_pi2BPSK = NULLP;
4218
4219    return ROK;
4220 }
4221
4222 /*******************************************************************
4223  *
4224  * @brief Builds BWP UL dedicated PUCCH Config
4225  *
4226  * @details
4227  *
4228  *    Function : BuildBWPUlDedPucchCfg
4229  *
4230  *    Functionality:
4231  *      Builds BWP UL dedicated PUCCH Config
4232  *
4233  * @params[in] : PUCCH_Config_t *pucchCfg
4234  *
4235  * @return ROK     - success
4236  *         RFAILED - failure
4237  *
4238  * ****************************************************************/
4239 uint8_t BuildBWPUlDedPucchCfg(PUCCH_Config_t *pucchCfg)
4240 {
4241    uint8_t arrIdx, elementCnt;
4242    uint8_t rsrcIdx, rsrcSetIdx;
4243    PUCCH_ResourceSet_t *rsrcSet = NULLP;
4244    PUCCH_Resource_t *rsrc = NULLP;
4245
4246    //RESOURCE SET
4247    elementCnt = 1;
4248    CU_ALLOC(pucchCfg->resourceSetToAddModList, sizeof(struct PUCCH_Config__resourceSetToAddModList));
4249    pucchCfg->resourceSetToAddModList->list.count = elementCnt;
4250    pucchCfg->resourceSetToAddModList->list.size = elementCnt * sizeof(PUCCH_ResourceSet_t *);
4251    CU_ALLOC(pucchCfg->resourceSetToAddModList->list.array, pucchCfg->resourceSetToAddModList->list.size);
4252    for(rsrcSetIdx=0; rsrcSetIdx < pucchCfg->resourceSetToAddModList->list.count; rsrcSetIdx++)
4253    {
4254       CU_ALLOC(pucchCfg->resourceSetToAddModList->list.array[rsrcSetIdx], sizeof(PUCCH_ResourceSet_t));
4255    }
4256    rsrcSetIdx = 0;
4257    rsrcSet = pucchCfg->resourceSetToAddModList->list.array[rsrcSetIdx];
4258    rsrcSet->pucch_ResourceSetId = 1;
4259    elementCnt = 1;
4260    rsrcSet->resourceList.list.count = elementCnt;
4261    rsrcSet->resourceList.list.size = elementCnt * sizeof(PUCCH_ResourceId_t *);
4262    CU_ALLOC(rsrcSet->resourceList.list.array, rsrcSet->resourceList.list.size);
4263    for(rsrcIdx=0; rsrcIdx < rsrcSet->resourceList.list.count; rsrcIdx++)
4264    {
4265       CU_ALLOC(rsrcSet->resourceList.list.array[rsrcIdx], sizeof(PUCCH_ResourceId_t));
4266    }
4267    rsrcIdx = 0;
4268    *(rsrcSet->resourceList.list.array[rsrcIdx]) = 1;
4269
4270    //RESOURCE
4271    elementCnt = 1;
4272    CU_ALLOC(pucchCfg->resourceToAddModList, sizeof(struct PUCCH_Config__resourceToAddModList));
4273    pucchCfg->resourceToAddModList->list.count = elementCnt;
4274    pucchCfg->resourceToAddModList->list.size = elementCnt * sizeof(PUCCH_Resource_t *);
4275    CU_ALLOC(pucchCfg->resourceToAddModList->list.array, pucchCfg->resourceToAddModList->list.size);
4276    for(rsrcIdx=0; rsrcIdx < pucchCfg->resourceToAddModList->list.count; rsrcIdx++)
4277    {
4278       CU_ALLOC(pucchCfg->resourceToAddModList->list.array[rsrcIdx], sizeof(PUCCH_Resource_t));
4279    }
4280    rsrcIdx = 0;
4281    rsrc = pucchCfg->resourceToAddModList->list.array[rsrcIdx];
4282    rsrc->pucch_ResourceId = 1;
4283    rsrc->startingPRB = 0;
4284    rsrc->format.present = PUCCH_Resource__format_PR_format1;
4285    CU_ALLOC(rsrc->format.choice.format1, sizeof(PUCCH_format1_t));
4286    rsrc->format.choice.format1->initialCyclicShift = 0;
4287    rsrc->format.choice.format1->nrofSymbols = 4;
4288    rsrc->format.choice.format1->startingSymbolIndex = 0;
4289    rsrc->format.choice.format1->timeDomainOCC = 0;
4290
4291    //PUCCH Format 1
4292    CU_ALLOC(pucchCfg->format1, sizeof(struct PUCCH_Config__format1));
4293    pucchCfg->format1->present = PUCCH_Config__format1_PR_setup;
4294    CU_ALLOC(pucchCfg->format1->choice.setup, sizeof(PUCCH_FormatConfig_t));
4295    CU_ALLOC(pucchCfg->format1->choice.setup->nrofSlots, sizeof(long));
4296    *(pucchCfg->format1->choice.setup->nrofSlots) = PUCCH_FormatConfig__nrofSlots_n4;
4297
4298    //DL DATA TO UL ACK
4299    CU_ALLOC(pucchCfg->dl_DataToUL_ACK, sizeof(struct PUCCH_Config__dl_DataToUL_ACK));
4300    if(pucchCfg->dl_DataToUL_ACK == NULLP)
4301    {
4302       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
4303       return RFAILED;
4304    }
4305
4306    elementCnt = 2;
4307    pucchCfg->dl_DataToUL_ACK->list.count = elementCnt;
4308    pucchCfg->dl_DataToUL_ACK->list.size = elementCnt * sizeof(long *);
4309    CU_ALLOC(pucchCfg->dl_DataToUL_ACK->list.array, pucchCfg->dl_DataToUL_ACK->list.size);
4310    if(pucchCfg->dl_DataToUL_ACK->list.array == NULLP)
4311    {
4312       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
4313       return RFAILED;
4314    }
4315
4316    for(arrIdx = 0; arrIdx <  pucchCfg->dl_DataToUL_ACK->list.count; arrIdx++)
4317    {
4318       CU_ALLOC(pucchCfg->dl_DataToUL_ACK->list.array[arrIdx], sizeof(long));
4319       if(pucchCfg->dl_DataToUL_ACK->list.array[arrIdx] == NULLP)
4320       {
4321           DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
4322           return RFAILED;
4323       }
4324    }
4325
4326    arrIdx = 0;
4327    *(pucchCfg->dl_DataToUL_ACK->list.array[arrIdx++]) = 4;
4328    *(pucchCfg->dl_DataToUL_ACK->list.array[arrIdx]) = 5;
4329
4330    return ROK;
4331 }
4332
4333 /*******************************************************************
4334  *
4335  * @brief Fills SRS resource to add/modify list
4336  *
4337  * @details
4338  *
4339  *    Function : BuildSrsRsrcAddModList
4340  *
4341  *    Functionality: Fills SRS resource to add/modify list
4342  *
4343  * @params[in]
4344  * @return ROK     - success
4345  *         RFAILED - failure
4346  *
4347  * ****************************************************************/
4348 uint8_t BuildSrsRsrcAddModList(struct SRS_Config__srs_ResourceToAddModList *resourceList)
4349 {
4350    uint8_t   elementCnt;
4351    uint8_t   rsrcIdx;
4352
4353    elementCnt = 1;
4354    resourceList->list.count = elementCnt;
4355    resourceList->list.size = elementCnt * sizeof(SRS_Resource_t *);
4356    resourceList->list.array = NULLP;
4357    CU_ALLOC(resourceList->list.array, resourceList->list.size);
4358    if(!resourceList->list.array)
4359    {
4360       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed in BuildSrsRsrcAddModList");
4361       return RFAILED;
4362    }
4363
4364    for(rsrcIdx = 0; rsrcIdx < resourceList->list.count; rsrcIdx++)
4365    {
4366       CU_ALLOC(resourceList->list.array[rsrcIdx], sizeof(SRS_Resource_t));
4367       if(!resourceList->list.array[rsrcIdx])
4368       {
4369          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed in BuildSrsRsrcAddModList");
4370          return RFAILED;
4371       }
4372    }
4373
4374    rsrcIdx = 0;
4375    resourceList->list.array[rsrcIdx]->srs_ResourceId = SRS_RSRC_ID;
4376    resourceList->list.array[rsrcIdx]->nrofSRS_Ports = SRS_Resource__nrofSRS_Ports_port1;
4377    resourceList->list.array[rsrcIdx]->transmissionComb.present = SRS_Resource__transmissionComb_PR_n2;
4378
4379    resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2 = NULLP;
4380    CU_ALLOC(resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2, \
4381          sizeof(struct SRS_Resource__transmissionComb__n2));
4382    if(!resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2)
4383    {
4384       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed in BuildSrsRsrcAddModList");
4385       return RFAILED;
4386    }
4387    resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2->combOffset_n2\
4388       = SRS_COMB_OFFSET_N2;
4389    resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2->cyclicShift_n2\
4390       = SRS_CYCLIC_SHIFT_N2;
4391
4392    resourceList->list.array[rsrcIdx]->resourceMapping.startPosition = PUSCH_START_SYMBOL;
4393    resourceList->list.array[rsrcIdx]->resourceMapping.nrofSymbols =  \
4394                                                                      SRS_Resource__resourceMapping__nrofSymbols_n1;
4395    resourceList->list.array[rsrcIdx]->resourceMapping.repetitionFactor = \
4396                                                                          SRS_Resource__resourceMapping__repetitionFactor_n1;
4397
4398    resourceList->list.array[rsrcIdx]->freqDomainPosition = SRS_FREQ_DOM_POS;
4399    resourceList->list.array[rsrcIdx]->freqDomainShift = SRS_FREQ_DOM_SHIFT;
4400    resourceList->list.array[rsrcIdx]->freqHopping.c_SRS = C_SRS;
4401    resourceList->list.array[rsrcIdx]->freqHopping.b_SRS = B_SRS;
4402    resourceList->list.array[rsrcIdx]->freqHopping.b_hop = B_HOP;
4403    resourceList->list.array[rsrcIdx]->groupOrSequenceHopping = \
4404                                                                SRS_Resource__groupOrSequenceHopping_neither;
4405
4406    /* Setting resource type to aperiodic for intergration purposes */
4407    resourceList->list.array[rsrcIdx]->resourceType.present = \
4408                                                              SRS_Resource__resourceType_PR_aperiodic;
4409    resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic = NULLP;
4410    CU_ALLOC(resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic,
4411          sizeof(struct SRS_Resource__resourceType__aperiodic));
4412    if(!resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic)
4413    {
4414       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed in BuildSrsRsrcAddModList");
4415       return RFAILED;
4416    }
4417    resourceList->list.array[rsrcIdx]->sequenceId = SRS_SEQ_ID;
4418
4419    return ROK;
4420 }
4421
4422 /*******************************************************************
4423  *
4424  * @brief Build SRS resource set Add/mod list
4425  *
4426  * @details
4427  *
4428  *    Function : BuildSrsRsrcSetAddModList
4429  *
4430  *    Functionality: Build SRS resource set Add/mod list
4431  *
4432  * @params[in]
4433  * @return ROK     - success
4434  *         RFAILED - failure
4435  *
4436  * ****************************************************************/
4437    uint8_t BuildSrsRsrcSetAddModList
4438 (
4439  struct SRS_Config__srs_ResourceSetToAddModList *rsrcSetList
4440  )
4441 {
4442    uint8_t  elementCnt;
4443    uint8_t  rSetIdx;
4444    uint8_t  rsrcIdx;
4445    struct SRS_ResourceSet__srs_ResourceIdList *rsrcIdList;
4446
4447    elementCnt = 1;
4448    rsrcSetList->list.count = elementCnt;
4449    rsrcSetList->list.size = elementCnt * sizeof(SRS_ResourceSet_t *);
4450    rsrcSetList->list.array = NULLP;
4451    CU_ALLOC(rsrcSetList->list.array, rsrcSetList->list.size);
4452    if(!rsrcSetList->list.array)
4453    {
4454       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed in BuildSrsRsrcSetAddModList");
4455       return RFAILED;
4456    }
4457
4458    for(rSetIdx = 0; rSetIdx < rsrcSetList->list.count; rSetIdx++)
4459    {
4460       CU_ALLOC(rsrcSetList->list.array[rSetIdx], sizeof(SRS_ResourceSet_t));
4461       if(!rsrcSetList->list.array[rSetIdx])
4462       {
4463          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed in BuildSrsRsrcSetAddModList");
4464          return RFAILED;
4465       }
4466    }
4467
4468    rSetIdx = 0;
4469    rsrcSetList->list.array[rSetIdx]->srs_ResourceSetId = SRS_RSET_ID;
4470
4471    /* Fill Resource Id list in resource set */
4472    rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList = NULLP;
4473    CU_ALLOC(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList,\
4474          sizeof(struct SRS_ResourceSet__srs_ResourceIdList));
4475    if(!rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList)
4476    {
4477       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
4478       return RFAILED;
4479    }
4480
4481    elementCnt = 1;
4482    rsrcIdList = rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList;
4483    rsrcIdList->list.count = elementCnt;
4484    rsrcIdList->list.size = elementCnt * sizeof(SRS_ResourceId_t *);
4485    rsrcIdList->list.array = NULLP;
4486    CU_ALLOC(rsrcIdList->list.array, rsrcIdList->list.size);
4487    if(!rsrcIdList->list.array)
4488    {
4489       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed in BuildSrsRsrcSetAddModList");
4490       return RFAILED;
4491    }
4492
4493    for(rsrcIdx = 0; rsrcIdx < rsrcIdList->list.count; rsrcIdx++)
4494    {
4495       CU_ALLOC(rsrcIdList->list.array[rsrcIdx], sizeof(SRS_ResourceId_t));
4496       if(!rsrcIdList->list.array[rsrcIdx])
4497       {
4498          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed in BuildSrsRsrcSetAddModList");
4499          return RFAILED;
4500       }
4501    }
4502
4503    rsrcIdx = 0;
4504    *rsrcIdList->list.array[rsrcIdx] = SRS_RSRC_ID;
4505
4506    /* Fill resource type */
4507    rsrcSetList->list.array[rSetIdx]->resourceType.present = \
4508                                                             SRS_ResourceSet__resourceType_PR_aperiodic;
4509
4510    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic = NULLP;
4511    CU_ALLOC(rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic, \
4512          sizeof(struct SRS_ResourceSet__resourceType__aperiodic));
4513    if(!rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic)
4514    {
4515       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed in BuildSrsRsrcSetAddModList");
4516       return RFAILED;
4517    }
4518    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic->aperiodicSRS_ResourceTrigger \
4519       = APERIODIC_SRS_RESRC_TRIGGER;
4520
4521    /* TODO : Fill values for below IEs as expected by Viavi */
4522    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic->csi_RS = NULLP;
4523    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic->slotOffset = NULLP;
4524
4525
4526    rsrcSetList->list.array[rSetIdx]->usage = SRS_ResourceSet__usage_codebook;
4527    rsrcSetList->list.array[rSetIdx]->alpha = NULLP;
4528    rsrcSetList->list.array[rSetIdx]->p0 = NULLP;
4529    rsrcSetList->list.array[rSetIdx]->pathlossReferenceRS = NULLP;
4530    rsrcSetList->list.array[rSetIdx]->srs_PowerControlAdjustmentStates = NULLP;
4531
4532    return ROK;
4533 }
4534
4535 /*******************************************************************
4536  *
4537  * @brief Builds BWP UL dedicated SRS Config
4538  *
4539  * @details
4540  *
4541  *    Function : BuildBWPUlDedSrsCfg
4542  *
4543  *    Functionality: Builds BWP UL dedicated SRS Config
4544  *
4545  * @params[in] SRS Config
4546  * @return ROK     - success
4547  *         RFAILED - failure
4548  *
4549  * ****************************************************************/
4550 uint8_t BuildBWPUlDedSrsCfg(SRS_Config_t *srsCfg)
4551 {
4552    srsCfg->srs_ResourceSetToReleaseList = NULLP;
4553    srsCfg->srs_ResourceSetToAddModList = NULLP;
4554    CU_ALLOC(srsCfg->srs_ResourceSetToAddModList, \
4555          sizeof(struct SRS_Config__srs_ResourceSetToAddModList));
4556    if(!srsCfg->srs_ResourceSetToAddModList)
4557    {
4558       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed in BuildBWPUlDedSrsCfg");
4559       return RFAILED;
4560    }
4561    if(BuildSrsRsrcSetAddModList(srsCfg->srs_ResourceSetToAddModList) != ROK)
4562    {
4563       return RFAILED;
4564    }
4565
4566    srsCfg->srs_ResourceToReleaseList = NULLP;
4567
4568    /* Resource to Add/Modify list */
4569    srsCfg->srs_ResourceToAddModList = NULLP;
4570    CU_ALLOC(srsCfg->srs_ResourceToAddModList, \
4571          sizeof(struct SRS_Config__srs_ResourceToAddModList));
4572    if(!srsCfg->srs_ResourceToAddModList)
4573    {
4574       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed in BuildBWPUlDedSrsCfg");
4575       return RFAILED;
4576    }
4577
4578    if(BuildSrsRsrcAddModList(srsCfg->srs_ResourceToAddModList) != ROK)
4579    {
4580       return RFAILED;
4581    }
4582
4583    srsCfg->tpc_Accumulation = NULLP;
4584
4585    return ROK;
4586 }
4587
4588 /*******************************************************************
4589  *
4590  * @brief Builds inital UL BWP
4591  *
4592  * @details
4593  *
4594  *    Function : BuildInitialUlBWP
4595  *
4596  *    Functionality: Builds initial UL BWP
4597  *
4598  * @params[in] BWP_UplinkDedicated_t *ulBwp
4599  * @return ROK     - success
4600  *         RFAILED - failure
4601  *
4602  * ****************************************************************/
4603 uint8_t BuildInitialUlBWP(BWP_UplinkDedicated_t *ulBwp)
4604 {
4605    ulBwp->pucch_Config = NULLP;
4606    ulBwp->pucch_Config = NULLP;
4607    CU_ALLOC(ulBwp->pucch_Config, sizeof(struct BWP_UplinkDedicated__pucch_Config));
4608    if(!ulBwp->pucch_Config)
4609    {
4610       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
4611       return RFAILED;
4612    }
4613
4614    ulBwp->pucch_Config->present = BWP_UplinkDedicated__pucch_Config_PR_setup;
4615    ulBwp->pucch_Config->choice.setup = NULLP;
4616    CU_ALLOC(ulBwp->pucch_Config->choice.setup, sizeof(PUCCH_Config_t));
4617    if(!ulBwp->pucch_Config->choice.setup)
4618    {
4619       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
4620       return RFAILED;
4621    }
4622
4623    if(BuildBWPUlDedPucchCfg(ulBwp->pucch_Config->choice.setup) != ROK)
4624    {
4625       return RFAILED;
4626    }
4627
4628    /* Fill BWP UL dedicated PUSCH config */
4629    ulBwp->pusch_Config = NULLP;
4630    CU_ALLOC(ulBwp->pusch_Config, sizeof(struct BWP_UplinkDedicated__pusch_Config));
4631    if(!ulBwp->pusch_Config)
4632    {
4633       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
4634       return RFAILED;
4635    }
4636
4637    ulBwp->pusch_Config->present = BWP_UplinkDedicated__pusch_Config_PR_setup;
4638    ulBwp->pusch_Config->choice.setup = NULLP;
4639    CU_ALLOC(ulBwp->pusch_Config->choice.setup, sizeof(PUSCH_Config_t));
4640    if(!ulBwp->pusch_Config->choice.setup)
4641    {
4642       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
4643       return RFAILED;
4644    }
4645
4646    if(BuildBWPUlDedPuschCfg(ulBwp->pusch_Config->choice.setup) != ROK)
4647    {
4648       return RFAILED;
4649    }
4650
4651    ulBwp->configuredGrantConfig = NULLP;
4652
4653    /* Fill BPW UL dedicated SRS config */
4654    ulBwp->srs_Config = NULLP;
4655    CU_ALLOC(ulBwp->srs_Config, sizeof(struct BWP_UplinkDedicated__srs_Config));
4656    if(!ulBwp->srs_Config)
4657    {
4658       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
4659       return RFAILED;
4660    }
4661
4662    ulBwp->srs_Config->present = BWP_UplinkDedicated__srs_Config_PR_setup;
4663    ulBwp->srs_Config->choice.setup = NULLP;
4664    CU_ALLOC(ulBwp->srs_Config->choice.setup, sizeof(SRS_Config_t));
4665    if(!ulBwp->srs_Config->choice.setup)
4666    {
4667       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
4668       return RFAILED;
4669    }
4670
4671    if(BuildBWPUlDedSrsCfg(ulBwp->srs_Config->choice.setup) != ROK)
4672    {
4673       return RFAILED;
4674    }
4675
4676    ulBwp->beamFailureRecoveryConfig = NULLP;
4677
4678    return ROK;
4679 }
4680
4681 /*******************************************************************
4682  *
4683  * @brief Builds Pusch Serving cell Config
4684  *
4685  * @details
4686  *
4687  *    Function : BuildPuschSrvCellCfg
4688  *
4689  *    Functionality: Builds Pusch Serving cell Config
4690  *
4691  * @params[in] struct UplinkConfig__pusch_ServingCellConfig *puschCfg
4692  *
4693  * @return ROK     - success
4694  *         RFAILED - failure
4695  *
4696  * ****************************************************************/
4697 uint8_t BuildPuschSrvCellCfg(struct UplinkConfig__pusch_ServingCellConfig *puschCfg)
4698 {
4699    puschCfg->present = UplinkConfig__pusch_ServingCellConfig_PR_setup;
4700    puschCfg->choice.setup = NULLP;
4701    CU_ALLOC(puschCfg->choice.setup, sizeof(struct PUSCH_ServingCellConfig));
4702    if(!puschCfg->choice.setup)
4703    {
4704       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
4705       return RFAILED;
4706    }
4707
4708    puschCfg->choice.setup->codeBlockGroupTransmission = NULLP;
4709    puschCfg->choice.setup->rateMatching = NULLP;
4710    puschCfg->choice.setup->xOverhead = NULLP;
4711    puschCfg->choice.setup->ext1 = NULLP;
4712    CU_ALLOC(puschCfg->choice.setup->ext1, sizeof(struct PUSCH_ServingCellConfig__ext1));
4713    if(!puschCfg->choice.setup->ext1)
4714    {
4715       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
4716       return RFAILED;
4717    }
4718
4719    puschCfg->choice.setup->ext1->maxMIMO_Layers = NULLP;
4720    CU_ALLOC(puschCfg->choice.setup->ext1->maxMIMO_Layers, sizeof(long));
4721    if(!puschCfg->choice.setup->ext1->maxMIMO_Layers)
4722    {
4723       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
4724       return RFAILED;
4725    }
4726    *(puschCfg->choice.setup->ext1->maxMIMO_Layers) = PUSCH_MAX_MIMO_LAYERS;
4727
4728    puschCfg->choice.setup->ext1->processingType2Enabled= NULLP;
4729    CU_ALLOC(puschCfg->choice.setup->ext1->processingType2Enabled,sizeof(BOOLEAN_t));
4730    if(!puschCfg->choice.setup->ext1->processingType2Enabled)
4731    {
4732       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
4733       return RFAILED;
4734    }
4735    *(puschCfg->choice.setup->ext1->processingType2Enabled) = PUSCH_PROCESS_TYPE2_ENABLED;
4736    return ROK;
4737 }
4738
4739 /*******************************************************************
4740  *
4741  * @brief Builds UL config
4742  * @details
4743  *
4744  *    Function : BuildUlCfg
4745  *
4746  *    Functionality: Builds UL config in spCellCfgDed
4747  *
4748  * @params[in] UplinkConfig_t *ulCfg
4749  *
4750  * @return ROK     - success
4751  *         RFAILED - failure
4752  *
4753  * ****************************************************************/
4754 uint8_t BuildUlCfg(UplinkConfig_t *ulCfg)
4755 {
4756    ulCfg->initialUplinkBWP = NULLP;
4757    CU_ALLOC(ulCfg->initialUplinkBWP, sizeof(BWP_UplinkDedicated_t));
4758    if(!ulCfg->initialUplinkBWP)
4759    {
4760       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failed in BuildUlCfg");
4761       return RFAILED;
4762    }
4763
4764    if(BuildInitialUlBWP(ulCfg->initialUplinkBWP) != ROK)
4765    {
4766       return RFAILED;
4767    }
4768
4769    ulCfg->uplinkBWP_ToReleaseList = NULLP;
4770    ulCfg->uplinkBWP_ToAddModList = NULLP;
4771    ulCfg->firstActiveUplinkBWP_Id = NULLP;
4772    CU_ALLOC(ulCfg->firstActiveUplinkBWP_Id, sizeof(BWP_Id_t));
4773    if(!ulCfg->firstActiveUplinkBWP_Id)
4774    {
4775       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failed in BuildUlCfg");
4776       return RFAILED;
4777    }
4778    *(ulCfg->firstActiveUplinkBWP_Id) = ACTIVE_UL_BWP_ID;
4779
4780    ulCfg->pusch_ServingCellConfig = NULLP;
4781    CU_ALLOC(ulCfg->pusch_ServingCellConfig, \
4782          sizeof(struct UplinkConfig__pusch_ServingCellConfig));
4783    if(!ulCfg->pusch_ServingCellConfig)
4784    {
4785       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failed in BuildUlCfg");
4786       return RFAILED;
4787    }
4788
4789    if(BuildPuschSrvCellCfg(ulCfg->pusch_ServingCellConfig) != ROK)
4790    {
4791       return RFAILED;
4792    }
4793
4794    ulCfg->carrierSwitching = NULLP;
4795    ulCfg->ext1 = NULLP;
4796    return ROK;
4797 }
4798
4799 /*******************************************************************
4800  *
4801  * @brief Builds PDSCH serving cell config
4802  * @details
4803  *
4804  *    Function : BuildPdschSrvCellCfg
4805  *
4806  *    Functionality: Builds PDSCH serving cell config in spCellCfgDed
4807  *
4808  * @params[in] struct ServingCellConfig__pdsch_ServingCellConfig *pdschCfg
4809  *
4810  * @return ROK     - success
4811  *         RFAILED - failure
4812  *
4813  * ****************************************************************/
4814 uint8_t BuildPdschSrvCellCfg(struct ServingCellConfig__pdsch_ServingCellConfig *pdschCfg)
4815 {
4816    pdschCfg->present =  ServingCellConfig__pdsch_ServingCellConfig_PR_setup;
4817    pdschCfg->choice.setup = NULLP;
4818    CU_ALLOC(pdschCfg->choice.setup, sizeof( struct PDSCH_ServingCellConfig));
4819    if(!pdschCfg->choice.setup)
4820    {
4821       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschSrvCellCfg");
4822       return RFAILED;
4823    }
4824
4825    pdschCfg->choice.setup->codeBlockGroupTransmission = NULLP;
4826    pdschCfg->choice.setup->xOverhead = NULLP;
4827    pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH = NULLP;
4828    CU_ALLOC(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH, sizeof(long));
4829    if(!pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH)
4830    {
4831       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschSrvCellCfg");
4832       return RFAILED;
4833    }
4834    *(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH)= PDSCH_NUM_HARQ_PROC;
4835    pdschCfg->choice.setup->pucch_Cell = NULLP;
4836    pdschCfg->choice.setup->ext1 = NULLP;
4837
4838    return ROK;
4839 }
4840
4841 /*******************************************************************
4842  *
4843  * @brief Builds CSI Meas config
4844  * @details
4845  *
4846  *    Function : BuildCsiMeasCfg
4847  *
4848  *    Functionality: Builds CSI Meas config in spCellCfgDed
4849  *
4850  * @params[in] struct ServingCellConfig__csi_MeasConfig *csiMeasCfg
4851  *
4852  * @return ROK     - success
4853  *         RFAILED - failure
4854  *
4855  * ****************************************************************/
4856 uint8_t BuildCsiMeasCfg(struct ServingCellConfig__csi_MeasConfig *csiMeasCfg)
4857 {
4858
4859    return ROK;
4860 }
4861
4862 /*******************************************************************
4863  *
4864  * @brief Builds Spcell config dedicated
4865  * @details
4866  *
4867  *    Function : BuildSpCellCfgDed
4868  *
4869  *    Functionality: Builds sp cell config dedicated in spCellCfg
4870  *
4871  * @params[in] ServingCellConfig_t srvCellCfg
4872  *
4873  * @return ROK     - success
4874  *         RFAILED - failure
4875  *
4876  * ****************************************************************/
4877 uint8_t BuildSpCellCfgDed(ServingCellConfig_t *srvCellCfg)
4878 {
4879    srvCellCfg->tdd_UL_DL_ConfigurationDedicated = NULLP;
4880
4881    srvCellCfg->initialDownlinkBWP = NULLP;
4882    CU_ALLOC(srvCellCfg->initialDownlinkBWP, sizeof(BWP_DownlinkDedicated_t));
4883    if(!srvCellCfg->initialDownlinkBWP)
4884    {
4885       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
4886       return RFAILED;
4887    }
4888
4889    if(BuildInitialDlBWP(srvCellCfg->initialDownlinkBWP) != ROK)
4890    {
4891       DU_LOG("\nERROR  -->  F1AP : BuildInitialDlBWP failed");
4892       return RFAILED;
4893    }
4894    srvCellCfg->downlinkBWP_ToReleaseList = NULLP;
4895    srvCellCfg->downlinkBWP_ToAddModList = NULLP;
4896
4897    srvCellCfg->firstActiveDownlinkBWP_Id = NULLP;
4898    CU_ALLOC(srvCellCfg->firstActiveDownlinkBWP_Id, sizeof(long));
4899    if(!srvCellCfg->firstActiveDownlinkBWP_Id)
4900    {
4901       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
4902       return RFAILED;
4903    }
4904    *(srvCellCfg->firstActiveDownlinkBWP_Id) = ACTIVE_DL_BWP_ID;
4905
4906    srvCellCfg->bwp_InactivityTimer = NULLP;
4907
4908    srvCellCfg->defaultDownlinkBWP_Id = NULLP;
4909    CU_ALLOC(srvCellCfg->defaultDownlinkBWP_Id, sizeof(long));
4910    if(!srvCellCfg->defaultDownlinkBWP_Id)
4911    {
4912       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
4913       return RFAILED;
4914    }
4915    *(srvCellCfg->defaultDownlinkBWP_Id) = ACTIVE_DL_BWP_ID;
4916
4917    srvCellCfg->uplinkConfig = NULLP;
4918    CU_ALLOC(srvCellCfg->uplinkConfig, sizeof(UplinkConfig_t));
4919    if(!srvCellCfg->uplinkConfig)
4920    {
4921       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
4922       return RFAILED;
4923    }
4924
4925    if(BuildUlCfg(srvCellCfg->uplinkConfig) != ROK)
4926    {
4927       DU_LOG("\nERROR  -->  F1AP : BuildUlCfg failed");
4928       return RFAILED;
4929    }
4930    srvCellCfg->supplementaryUplink = NULLP;
4931    srvCellCfg->pdcch_ServingCellConfig = NULLP;
4932
4933    srvCellCfg->pdsch_ServingCellConfig = NULLP;
4934    CU_ALLOC(srvCellCfg->pdsch_ServingCellConfig, sizeof(struct  ServingCellConfig__pdsch_ServingCellConfig));
4935    if(!srvCellCfg->pdsch_ServingCellConfig)
4936    {
4937       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
4938       return RFAILED;
4939    }
4940
4941    if(BuildPdschSrvCellCfg(srvCellCfg->pdsch_ServingCellConfig) != ROK)
4942    {
4943       DU_LOG("\nERROR  -->  F1AP : BuildPdschSrvCellCfg failed");
4944       return RFAILED;
4945    }
4946
4947    srvCellCfg->csi_MeasConfig = NULLP;
4948 #if 0
4949    CU_ALLOC(srvCellCfg->csi_MeasConfig, sizeof(struct   ServingCellConfig__csi_MeasConfig))
4950       if(!srvCellCfg->csi_MeasConfig)
4951       {
4952          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
4953          return RFAILED;
4954       }
4955
4956    if(BuildCsiMeasCfg(srvCellCfg->csi_MeasConfig) != ROK)
4957    {
4958       DU_LOG("\nF1AP : BuildCsiMeasCfg failed");
4959       return RFAILED;
4960    }
4961 #endif
4962    srvCellCfg->sCellDeactivationTimer = NULLP;
4963    srvCellCfg->crossCarrierSchedulingConfig = NULLP;
4964    srvCellCfg->tag_Id = TAG_ID;
4965    srvCellCfg->dummy = NULLP;
4966    srvCellCfg->pathlossReferenceLinking = NULLP;
4967    srvCellCfg->servingCellMO = NULLP;
4968    srvCellCfg->ext1 = NULLP;
4969
4970    return ROK;
4971 }
4972 /*******************************************************************
4973  *
4974  * @brief Builds Spcell config
4975  *
4976  * @details
4977  *
4978  *    Function : BuildSpCellCfg
4979  *
4980  *    Functionality: Builds sp cell config in DuToCuRrcContainer
4981  *
4982  * @params[in] SpCellConfig_t spCellCfg
4983  *
4984  * @return ROK     - success
4985  *         RFAILED - failure
4986  *
4987  * ****************************************************************/
4988 uint8_t BuildSpCellCfg(SpCellConfig_t *spCellCfg)
4989 {
4990
4991    spCellCfg->servCellIndex = NULLP;
4992    CU_ALLOC(spCellCfg->servCellIndex, sizeof(long));
4993    if(!spCellCfg->servCellIndex)
4994    {
4995       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfg");
4996       return RFAILED;
4997    }
4998    *(spCellCfg->servCellIndex) = SERV_CELL_IDX;
4999
5000    spCellCfg->reconfigurationWithSync = NULLP;
5001    spCellCfg->rlf_TimersAndConstants = NULLP;
5002    spCellCfg->rlmInSyncOutOfSyncThreshold = NULLP;
5003    CU_ALLOC(spCellCfg->rlmInSyncOutOfSyncThreshold, sizeof(long));
5004    if(!spCellCfg->rlmInSyncOutOfSyncThreshold)
5005    {
5006       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfg");
5007       return RFAILED;
5008    }
5009    *(spCellCfg->rlmInSyncOutOfSyncThreshold) = RLM_SYNC_OUT_SYNC_THRESHOLD;
5010
5011    spCellCfg->spCellConfigDedicated = NULLP;
5012    CU_ALLOC(spCellCfg->spCellConfigDedicated, sizeof(ServingCellConfig_t));
5013    if(!spCellCfg->spCellConfigDedicated)
5014    {
5015       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfg");
5016       return RFAILED;
5017    }
5018    if(BuildSpCellCfgDed(spCellCfg->spCellConfigDedicated) != ROK)
5019    {
5020       DU_LOG("\nERROR  -->  F1AP : BuildSpCellCfgDed failed");
5021       return RFAILED;
5022    }
5023    return ROK;
5024 }
5025 /*******************************************************************
5026  *
5027  * @brief Builds Phy cell group config
5028  *
5029  * @details
5030  *
5031  *    Function : BuildPhyCellGrpCfg
5032  *
5033  *    Functionality: Builds Phy cell group config in DuToCuRrcContainer
5034  *
5035  * @params[in] PhysicalCellGroupConfig_t *phyCellGrpCfg
5036  *
5037  * @return ROK     - success
5038  *         RFAILED - failure
5039  *
5040  * ****************************************************************/
5041 uint8_t BuildPhyCellGrpCfg(PhysicalCellGroupConfig_t *phyCellGrpCfg)
5042 {
5043    phyCellGrpCfg->harq_ACK_SpatialBundlingPUCCH = NULLP;
5044    phyCellGrpCfg->harq_ACK_SpatialBundlingPUSCH = NULLP;
5045
5046    phyCellGrpCfg->p_NR_FR1 = NULLP;
5047    CU_ALLOC(phyCellGrpCfg->p_NR_FR1, sizeof(long));
5048    if(!phyCellGrpCfg->p_NR_FR1)
5049    {
5050       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildPhyCellGrpCfg");
5051       return RFAILED;
5052    }
5053    *(phyCellGrpCfg->p_NR_FR1)             = P_NR_FR1;
5054    phyCellGrpCfg->pdsch_HARQ_ACK_Codebook = PDSCH_HARQ_ACK_CODEBOOK;
5055    phyCellGrpCfg->tpc_SRS_RNTI = NULLP;
5056    phyCellGrpCfg->tpc_PUCCH_RNTI = NULLP;
5057    phyCellGrpCfg->tpc_PUSCH_RNTI = NULLP;
5058    phyCellGrpCfg->sp_CSI_RNTI = NULLP;
5059    phyCellGrpCfg->cs_RNTI = NULLP;
5060    phyCellGrpCfg->ext1 = NULLP;
5061    phyCellGrpCfg->ext2 = NULLP;
5062
5063    return ROK;
5064 }
5065
5066 /*******************************************************************
5067  *
5068  * @brief Builds tag config
5069  *
5070  * @details
5071  *
5072  *    Function : BuildTagConfig
5073  *
5074  *    Functionality: Builds tag config in MacCellGroupConfig
5075  *
5076  * @params[in] TAG_Config *tag_Config
5077  *
5078  * @return ROK     - success
5079  *         RFAILED - failure
5080  *
5081  * ****************************************************************/
5082 uint8_t BuildTagConfig(struct TAG_Config *tagConfig)
5083 {
5084    struct TAG_Config__tag_ToAddModList *tagList;
5085    uint8_t                     idx, elementCnt;
5086
5087    tagConfig->tag_ToReleaseList = NULLP;
5088    tagConfig->tag_ToAddModList = NULLP;
5089    CU_ALLOC(tagConfig->tag_ToAddModList, sizeof(struct TAG_Config__tag_ToAddModList));
5090    if(!tagConfig->tag_ToAddModList)
5091    {
5092       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildTagConfig");
5093       return RFAILED;
5094    }
5095
5096    elementCnt = 1; //ODU_VALUE_ONE;
5097    tagList = tagConfig->tag_ToAddModList;
5098    tagList->list.count = elementCnt;
5099    tagList->list.size  =  elementCnt * sizeof(struct TAG *);
5100
5101    tagList->list.array = NULLP;
5102    CU_ALLOC(tagList->list.array, tagList->list.size);
5103    if(!tagList->list.array)
5104    {
5105       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildTagConfig");
5106       return RFAILED;
5107    }
5108
5109    for(idx=0; idx<tagList->list.count; idx++)
5110    {
5111       tagList->list.array[idx] = NULLP;
5112       CU_ALLOC(tagList->list.array[idx], sizeof(struct TAG));
5113       if(!tagList->list.array[idx])
5114       {
5115          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildTagConfig");
5116          return RFAILED;
5117       }
5118    }
5119
5120    idx = 0;
5121    tagList->list.array[idx]->tag_Id = TAG_ID;
5122    tagList->list.array[idx]->timeAlignmentTimer = TIME_ALIGNMENT_TMR;
5123
5124    return ROK;
5125 }
5126
5127 /*******************************************************************
5128  *
5129  * @brief Builds PHR Config
5130  *
5131  * @details
5132  *
5133  *    Function : BuildPhrConfig
5134  *
5135  *    Functionality: Builds phrConfig in MacCellGroupConfig
5136  *
5137  * @params[in] PHR Config *
5138  *
5139  * @return ROK     - success
5140  *         RFAILED - failure
5141  *
5142  * ****************************************************************/
5143 uint8_t BuildPhrConfig(struct MAC_CellGroupConfig__phr_Config *phrConfig)
5144 {
5145
5146    phrConfig->present = MAC_CellGroupConfig__phr_Config_PR_setup;
5147    phrConfig->choice.setup = NULLP;
5148    CU_ALLOC(phrConfig->choice.setup, sizeof(struct PHR_Config));
5149    if(!phrConfig->choice.setup)
5150    {
5151       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildPhrConfig");
5152       return RFAILED;
5153    }
5154
5155    phrConfig->choice.setup->phr_PeriodicTimer        = PHR_PERIODIC_TMR;
5156    phrConfig->choice.setup->phr_ProhibitTimer        = PHR_PROHIBHIT_TMR;
5157    phrConfig->choice.setup->phr_Tx_PowerFactorChange = PHR_PWR_FACTOR_CHANGE;
5158    phrConfig->choice.setup->multiplePHR              = false;
5159    phrConfig->choice.setup->dummy                    = false;
5160    phrConfig->choice.setup->phr_Type2OtherCell       = false;
5161    phrConfig->choice.setup->phr_ModeOtherCG          = PHR_MODE_OTHER_CG;
5162
5163    return ROK;
5164 }
5165
5166 /*******************************************************************
5167  *
5168  * @brief Builds BSR Config
5169  *
5170  * @details
5171  *
5172  *    Function : BuildBsrConfig
5173  *
5174  *    Functionality: Builds BuildBsrConfig in MacCellGroupConfig
5175  *
5176  * @params[in] BSR_Config *bsrConfig
5177  *
5178  * @return ROK     - success
5179  *         RFAILED - failure
5180  *
5181  * ****************************************************************/
5182 uint8_t BuildBsrConfig(struct BSR_Config *bsrConfig)
5183 {
5184    bsrConfig->periodicBSR_Timer = PERIODIC_BSR_TMR;
5185    bsrConfig->retxBSR_Timer     = RETX_BSR_TMR;
5186    bsrConfig->logicalChannelSR_DelayTimer = NULLP;
5187
5188    return ROK;
5189 }
5190
5191 /*******************************************************************
5192  *
5193  * @brief Builds scheduling request config
5194  *
5195  * @details
5196  *
5197  *    Function : BuildSchedulingReqConfig
5198  *
5199  *    Functionality: Builds BuildSchedulingReqConfig in MacCellGroupConfig
5200  *
5201  * @params[in] SchedulingRequestConfig *schedulingRequestConfig
5202  *
5203  * @return ROK     - success
5204  *         RFAILED - failure
5205  *
5206  * ****************************************************************/
5207 uint8_t BuildSchedulingReqConfig(struct SchedulingRequestConfig *schedulingRequestConfig)
5208 {
5209    struct SchedulingRequestConfig__schedulingRequestToAddModList *schReqList;
5210    uint8_t                     idx, elementCnt;
5211
5212    schedulingRequestConfig->schedulingRequestToAddModList = NULLP;
5213    CU_ALLOC(schedulingRequestConfig->schedulingRequestToAddModList,
5214          sizeof(struct SchedulingRequestConfig__schedulingRequestToAddModList));
5215    if(!schedulingRequestConfig->schedulingRequestToAddModList)
5216    {
5217       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSchedulingReqConfig");
5218       return RFAILED;
5219    }
5220
5221    elementCnt = 1; //ODU_VALUE_ONE;
5222    schReqList = schedulingRequestConfig->schedulingRequestToAddModList;
5223    schReqList->list.count = elementCnt;
5224    schReqList->list.size  = elementCnt * sizeof(struct SchedulingRequestToAddMod *);
5225
5226    schReqList->list.array = NULLP;
5227    CU_ALLOC(schReqList->list.array, schReqList->list.size);
5228    if(!schReqList->list.array)
5229    {
5230       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSchedulingReqConfig");
5231       return RFAILED;
5232    }
5233
5234    for(idx=0;idx<schReqList->list.count; idx++)
5235    {
5236       schReqList->list.array[idx] = NULLP;
5237       CU_ALLOC(schReqList->list.array[idx], sizeof(struct SchedulingRequestToAddMod));
5238       if(!schReqList->list.array[idx])
5239       {
5240          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSchedulingReqConfig");
5241          return RFAILED;
5242       }
5243    }
5244
5245    idx = 0;
5246    schReqList->list.array[idx]->schedulingRequestId = SCH_REQ_ID;
5247
5248    schReqList->list.array[idx]->sr_ProhibitTimer = NULLP;
5249    CU_ALLOC(schReqList->list.array[idx]->sr_ProhibitTimer, sizeof(long));
5250    if(!schReqList->list.array[idx]->sr_ProhibitTimer)
5251    {
5252       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSchedulingReqConfig");
5253       return RFAILED;
5254    }
5255    *(schReqList->list.array[idx]->sr_ProhibitTimer) = SR_PROHIBIT_TMR;
5256    schReqList->list.array[idx]->sr_TransMax = SR_TRANS_MAX;
5257    schedulingRequestConfig->schedulingRequestToReleaseList = NULLP;
5258
5259    return ROK;
5260 }
5261 /*******************************************************************
5262  *
5263  * @brief Builds Mac cell group config
5264  *
5265  * @details
5266  *
5267  *    Function : BuildMacCellGrpCfg
5268  *
5269  *    Functionality: Builds Mac cell group config in DuToCuRrcContainer
5270  *
5271  * @params[in] MAC_CellGroupConfig_t *macCellGrpCfg
5272  *
5273  * @return ROK     - success
5274  *         RFAILED - failure
5275  *
5276  * ****************************************************************/
5277 uint8_t BuildMacCellGrpCfg(MAC_CellGroupConfig_t *macCellGrpCfg)
5278 {
5279    macCellGrpCfg->drx_Config = NULLP;
5280    macCellGrpCfg->schedulingRequestConfig = NULLP;
5281    CU_ALLOC(macCellGrpCfg->schedulingRequestConfig, sizeof(struct SchedulingRequestConfig));
5282    if(!macCellGrpCfg->schedulingRequestConfig)
5283    {
5284       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacCellGrpCfg");
5285       return RFAILED;
5286    }
5287
5288    if(BuildSchedulingReqConfig(macCellGrpCfg->schedulingRequestConfig) != ROK)
5289    {
5290       DU_LOG("\nERROR  -->  F1AP : BuildSchedulingReqConfig failed");
5291       return RFAILED;
5292    }
5293
5294    macCellGrpCfg->bsr_Config = NULLP;
5295    CU_ALLOC(macCellGrpCfg->bsr_Config, sizeof(struct BSR_Config));
5296    if(!macCellGrpCfg->bsr_Config)
5297    {
5298       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacCellGrpCfg");
5299       return RFAILED;
5300    }
5301
5302    if(BuildBsrConfig(macCellGrpCfg->bsr_Config) != ROK)
5303    {
5304       DU_LOG("\nERROR  -->  F1AP : BuildBsrConfig failed");
5305       return RFAILED;
5306    }
5307
5308    macCellGrpCfg->tag_Config = NULLP;
5309    CU_ALLOC(macCellGrpCfg->tag_Config, sizeof(struct TAG_Config));
5310    if(!macCellGrpCfg->tag_Config)
5311    {
5312       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacCellGrpCfg");
5313       return RFAILED;
5314    }
5315
5316    if(BuildTagConfig(macCellGrpCfg->tag_Config) != ROK)
5317    {
5318       DU_LOG("\nERROR  -->  F1AP : BuildTagConfig failed");
5319       return RFAILED;
5320    }
5321
5322    macCellGrpCfg->phr_Config = NULLP;
5323    CU_ALLOC(macCellGrpCfg->phr_Config, sizeof(struct MAC_CellGroupConfig__phr_Config));
5324    if(!macCellGrpCfg->phr_Config)
5325    {
5326       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacCellGrpCfg");
5327       return RFAILED;
5328    }
5329
5330    if(BuildPhrConfig(macCellGrpCfg->phr_Config) != ROK)
5331    {
5332       DU_LOG("\nERROR  -->  F1AP : BuildPhrConfig failed");
5333       return RFAILED;
5334    }
5335
5336    macCellGrpCfg->skipUplinkTxDynamic = false;
5337    macCellGrpCfg->ext1 = NULLP;
5338
5339    return ROK;
5340 }
5341 /*******************************************************************
5342  *
5343  * @brief Frees memeory allocated for SearchSpcToAddModList
5344  *
5345  * @details
5346  *
5347  *    Function : FreeSearchSpcToAddModList
5348  *
5349  *    Functionality: Deallocating memory of SearchSpcToAddModList
5350  *
5351  * @params[in] struct PDCCH_Config__searchSpacesToAddModList *searchSpcList
5352  *
5353  * @return void
5354  *
5355  4221 * ****************************************************************/
5356 void FreeSearchSpcToAddModList(struct PDCCH_Config__searchSpacesToAddModList *searchSpcList)
5357 {
5358    uint8_t idx1=0;
5359    uint8_t idx2=0;
5360    struct  SearchSpace *searchSpc=NULLP;
5361
5362    if(searchSpcList->list.array)
5363    {
5364       if(searchSpcList->list.array[idx2])
5365       {
5366          searchSpc = searchSpcList->list.array[idx2];
5367          if(searchSpc->controlResourceSetId)
5368          {
5369             if(searchSpc->monitoringSlotPeriodicityAndOffset)
5370             {
5371                if(searchSpc->monitoringSymbolsWithinSlot)
5372                {
5373                   if(searchSpc->monitoringSymbolsWithinSlot->buf)
5374                   {
5375                      if(searchSpc->nrofCandidates)
5376                      {
5377                         if(searchSpc->searchSpaceType)
5378                         {
5379                            CU_FREE(searchSpc->searchSpaceType->choice.ue_Specific,\
5380                                  sizeof(struct SearchSpace__searchSpaceType__ue_Specific));
5381                            CU_FREE(searchSpc->searchSpaceType, sizeof(struct
5382                                     SearchSpace__searchSpaceType));
5383                         }
5384                         CU_FREE(searchSpc->nrofCandidates,
5385                               sizeof(struct SearchSpace__nrofCandidates));
5386                      }
5387                      CU_FREE(searchSpc->monitoringSymbolsWithinSlot->buf, \
5388                            searchSpc->monitoringSymbolsWithinSlot->size);
5389                   }
5390                   CU_FREE(searchSpc->monitoringSymbolsWithinSlot,
5391                         sizeof(BIT_STRING_t));
5392                }
5393                CU_FREE(searchSpc->monitoringSlotPeriodicityAndOffset, \
5394                      sizeof(struct SearchSpace__monitoringSlotPeriodicityAndOffset));
5395             }
5396             CU_FREE(searchSpc->controlResourceSetId,
5397                   sizeof(ControlResourceSetId_t));
5398          }
5399       }
5400       for(idx1 = 0; idx1 < searchSpcList->list.count; idx1++)
5401       {
5402          CU_FREE(searchSpcList->list.array[idx1],
5403                sizeof(struct SearchSpace));
5404       }
5405       CU_FREE(searchSpcList->list.array,searchSpcList->list.size);
5406    }
5407 }
5408 /*******************************************************************
5409  *
5410  * @brief Frees memory allocated for PdschTimeDomAllocList
5411  *
5412  * @details
5413  *
5414  *    Function : FreePdschTimeDomAllocList
5415  *
5416  *    Functionality: Deallocating memory of PdschTimeDomAllocList
5417  *
5418  * @params[in] struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList
5419  *
5420  * @return void
5421  *
5422  4221 * ****************************************************************/
5423 void FreePdschTimeDomAllocList( struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList)
5424 {
5425    uint8_t idx1=0;
5426
5427    if(timeDomAllocList->choice.setup)
5428    {
5429       if(timeDomAllocList->choice.setup->list.array)
5430       {
5431          for(idx1 = 0; idx1 <timeDomAllocList->choice.setup->list.count ; idx1++)
5432          {
5433             CU_FREE(timeDomAllocList->choice.setup->list.array[idx1],
5434                   sizeof(struct PDSCH_TimeDomainResourceAllocation));
5435          }
5436          CU_FREE(timeDomAllocList->choice.setup->list.array, \
5437                timeDomAllocList->choice.setup->list.size);
5438       }
5439       CU_FREE(timeDomAllocList->choice.setup,\
5440             sizeof(struct PDSCH_TimeDomainResourceAllocationList));
5441    }
5442 }
5443 /*******************************************************************
5444  *
5445  * @brief Frees memory allocated for PuschTimeDomAllocList
5446  *
5447  *@details
5448  *
5449  *    Function : FreePuschTimeDomAllocList
5450  *
5451  *    Functionality: Deallocating memory of PuschTimeDomAllocList
5452  *
5453  * @params[in] PUSCH_Config_t *puschCfg
5454  *
5455  * @return void
5456  *
5457  ***********************************************************************/
5458 void FreePuschTimeDomAllocList(PUSCH_Config_t *puschCfg)
5459 {
5460    uint8_t idx1=0;
5461    uint8_t idx2=0;
5462    struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList_t=NULLP;
5463
5464    if(puschCfg->pusch_TimeDomainAllocationList)
5465    {
5466       timeDomAllocList_t=puschCfg->pusch_TimeDomainAllocationList;
5467       if(timeDomAllocList_t->choice.setup)
5468       {
5469          if(timeDomAllocList_t->choice.setup->list.array)
5470          {
5471             CU_FREE(timeDomAllocList_t->choice.setup->list.array[idx2]->k2, sizeof(long));
5472             for(idx1 = 0; idx1<timeDomAllocList_t->choice.setup->list.count; idx1++)
5473             {
5474                CU_FREE(timeDomAllocList_t->choice.setup->list.array[idx1],\
5475                      sizeof(PUSCH_TimeDomainResourceAllocation_t));
5476             }
5477             CU_FREE(timeDomAllocList_t->choice.setup->list.array, \
5478                   timeDomAllocList_t->choice.setup->list.size);
5479          }
5480          CU_FREE(timeDomAllocList_t->choice.setup, \
5481                sizeof(struct PUSCH_TimeDomainResourceAllocationList));
5482       }
5483       CU_FREE(puschCfg->transformPrecoder, sizeof(long));
5484       CU_FREE(puschCfg->pusch_TimeDomainAllocationList, \
5485             sizeof(struct PUSCH_Config__pusch_TimeDomainAllocationList));
5486    }
5487
5488 }
5489
5490 /*******************************************************************
5491  *
5492  * @brief Frees memory allocated for Dedicated PUCCH config
5493  *
5494  * @details
5495  *
5496  *    Function : FreeBWPUlDedPucchCfg
5497  *
5498  *    Functionality: Deallocating memory of Dedicated PUCCH cfg
5499  *
5500  * @params[in] BWP_UplinkDedicated__pucch_Config *ulBwpPucchCfg
5501  *
5502  * @return void
5503  *
5504  * ****************************************************************/
5505 void FreeBWPUlDedPucchCfg(struct BWP_UplinkDedicated__pucch_Config *ulBwpPucchCfg)
5506 {
5507    uint8_t arrIdx, rsrcIdx, rsrcSetIdx;
5508    PUCCH_Config_t *pucchCfg = NULLP;
5509    PUCCH_ResourceSet_t *rsrcSet = NULLP;
5510    PUCCH_Resource_t *rsrc = NULLP;
5511
5512    if(ulBwpPucchCfg)
5513    {
5514       if(ulBwpPucchCfg->choice.setup)
5515       {
5516          pucchCfg = ulBwpPucchCfg->choice.setup;
5517
5518          //Free resource set list
5519          if(pucchCfg->resourceSetToAddModList)
5520          {
5521             if(pucchCfg->resourceSetToAddModList->list.array)
5522             {
5523                for(rsrcSetIdx=0; rsrcSetIdx < pucchCfg->resourceSetToAddModList->list.count; rsrcSetIdx++)
5524                {
5525                   rsrcSet = pucchCfg->resourceSetToAddModList->list.array[rsrcSetIdx];
5526                   if(rsrcSet->resourceList.list.array)
5527                   {
5528                      for(rsrcIdx=0; rsrcIdx < rsrcSet->resourceList.list.count; rsrcIdx++)
5529                      {
5530                         CU_FREE(rsrcSet->resourceList.list.array[rsrcIdx], sizeof(PUCCH_ResourceId_t));
5531                      }
5532                      CU_FREE(rsrcSet->resourceList.list.array, rsrcSet->resourceList.list.size);
5533                   }
5534                   CU_FREE(pucchCfg->resourceSetToAddModList->list.array[rsrcSetIdx], sizeof(PUCCH_ResourceSet_t));
5535                }
5536                CU_FREE(pucchCfg->resourceSetToAddModList->list.array, pucchCfg->resourceSetToAddModList->list.size);
5537             }
5538             CU_FREE(pucchCfg->resourceSetToAddModList, sizeof(struct PUCCH_Config__resourceSetToAddModList));
5539          }
5540
5541          //Free resource list
5542          if(pucchCfg->resourceToAddModList)
5543          {
5544             if(pucchCfg->resourceToAddModList->list.array)
5545             {
5546                for(rsrcIdx=0; rsrcIdx < pucchCfg->resourceToAddModList->list.count; rsrcIdx++)
5547                {
5548                   rsrc = pucchCfg->resourceToAddModList->list.array[rsrcIdx];
5549                   CU_FREE(rsrc->format.choice.format1, sizeof(PUCCH_format1_t));
5550                   CU_FREE(pucchCfg->resourceToAddModList->list.array[rsrcIdx], sizeof(PUCCH_Resource_t));
5551                }
5552                CU_FREE(pucchCfg->resourceToAddModList->list.array, pucchCfg->resourceToAddModList->list.size);
5553             }
5554             CU_FREE(pucchCfg->resourceToAddModList, sizeof(struct PUCCH_Config__resourceToAddModList));
5555          }
5556
5557          //PUCCH Format 1
5558          if(pucchCfg->format1)
5559          {
5560             if(pucchCfg->format1->choice.setup)
5561             {
5562                CU_FREE(pucchCfg->format1->choice.setup->nrofSlots, sizeof(long));
5563                CU_FREE(pucchCfg->format1->choice.setup, sizeof(PUCCH_FormatConfig_t));
5564             }
5565             CU_FREE(pucchCfg->format1, sizeof(struct PUCCH_Config__format1));
5566          }
5567
5568          //DL DATA TO UL ACK
5569          if(pucchCfg->dl_DataToUL_ACK)
5570          {
5571             if(pucchCfg->dl_DataToUL_ACK->list.array)
5572             {
5573                for(arrIdx = 0; arrIdx <  pucchCfg->dl_DataToUL_ACK->list.count; arrIdx++)
5574                {
5575                   CU_FREE(pucchCfg->dl_DataToUL_ACK->list.array[arrIdx], sizeof(long));
5576                }
5577                CU_FREE(pucchCfg->dl_DataToUL_ACK->list.array, pucchCfg->dl_DataToUL_ACK->list.size);
5578             }
5579             CU_FREE(pucchCfg->dl_DataToUL_ACK, sizeof(struct PUCCH_Config__dl_DataToUL_ACK));
5580          }
5581
5582          CU_FREE(ulBwpPucchCfg->choice.setup, sizeof(PUCCH_Config_t));
5583       }
5584       CU_FREE(ulBwpPucchCfg, sizeof(struct BWP_UplinkDedicated__pucch_Config));
5585    }
5586 }
5587
5588 /*******************************************************************
5589  *
5590  * @brief Frees memory allocated for InitialUlBWP
5591  *
5592  * @details
5593  *
5594  *    Function : FreeInitialUlBWP
5595  *
5596  *    Functionality: Deallocating memory of InitialUlBWP
5597  *
5598  * @params[in] BWP_UplinkDedicated_t *ulBwp
5599  *
5600  * @return void
5601  *
5602  * ****************************************************************/
5603 void FreeInitialUlBWP(BWP_UplinkDedicated_t *ulBwp)
5604 {
5605    uint8_t  rSetIdx, rsrcIdx;
5606    SRS_Config_t   *srsCfg = NULLP;
5607    PUSCH_Config_t *puschCfg = NULLP;
5608    struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA *dmrsUlCfg = NULLP;
5609    struct SRS_Config__srs_ResourceSetToAddModList *rsrcSetList = NULLP;
5610    struct SRS_ResourceSet__srs_ResourceIdList *rsrcIdList = NULLP;
5611    struct SRS_Config__srs_ResourceToAddModList *resourceList = NULLP;
5612
5613    FreeBWPUlDedPucchCfg(ulBwp->pucch_Config);
5614
5615    if(ulBwp->pusch_Config)
5616    {
5617       if(ulBwp->pusch_Config->choice.setup)
5618       {
5619          puschCfg=ulBwp->pusch_Config->choice.setup;
5620          if(puschCfg->dataScramblingIdentityPUSCH)
5621          {
5622             if(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA)
5623             {
5624                FreePuschTimeDomAllocList(puschCfg);
5625                dmrsUlCfg=puschCfg->dmrs_UplinkForPUSCH_MappingTypeA;
5626                if(dmrsUlCfg->choice.setup)
5627                {
5628                   if(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition)
5629                   {
5630                      if(dmrsUlCfg->choice.setup->transformPrecodingDisabled)
5631                      {
5632                         CU_FREE(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0,\
5633                               sizeof(long));
5634                         CU_FREE(dmrsUlCfg->choice.setup->transformPrecodingDisabled,
5635                               sizeof(struct DMRS_UplinkConfig__transformPrecodingDisabled));
5636                      }
5637                      CU_FREE(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition,
5638                            sizeof(long));
5639                   }
5640                   CU_FREE(dmrsUlCfg->choice.setup,sizeof(DMRS_UplinkConfig_t));
5641                }
5642                CU_FREE(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA, \
5643                      sizeof(struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA));
5644             }
5645             CU_FREE(puschCfg->dataScramblingIdentityPUSCH, sizeof(long));
5646          }
5647          CU_FREE(ulBwp->pusch_Config->choice.setup, sizeof(PUSCH_Config_t));
5648       }
5649       CU_FREE(ulBwp->pusch_Config, sizeof(struct BWP_UplinkDedicated__pusch_Config));
5650
5651       /* Free SRS-Config */
5652       if(ulBwp->srs_Config)
5653       {
5654          if(ulBwp->srs_Config->choice.setup)
5655          {
5656             srsCfg = ulBwp->srs_Config->choice.setup;
5657
5658             /* Free Resource Set to add/mod list */
5659             if(srsCfg->srs_ResourceSetToAddModList)
5660             {
5661                rsrcSetList = srsCfg->srs_ResourceSetToAddModList;
5662                if(rsrcSetList->list.array)
5663                {
5664                   rSetIdx = 0;
5665
5666                   /* Free SRS resource Id list in this SRS resource set */
5667                   if(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList)
5668                   {
5669                      rsrcIdList = rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList;
5670
5671                      if(rsrcIdList->list.array)
5672                      {
5673                         for(rsrcIdx = 0; rsrcIdx < rsrcIdList->list.count; rsrcIdx++)
5674                         {
5675                            CU_FREE(rsrcIdList->list.array[rsrcIdx], sizeof(SRS_ResourceId_t));
5676                         }
5677                         CU_FREE(rsrcIdList->list.array, rsrcIdList->list.size);
5678                      }
5679                      CU_FREE(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList,\
5680                            sizeof(struct SRS_ResourceSet__srs_ResourceIdList));
5681                   }
5682
5683                   /* Free resource type info for this SRS resource set */
5684                   CU_FREE(rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic, \
5685                         sizeof(struct SRS_ResourceSet__resourceType__aperiodic));
5686
5687                   /* Free memory for each resource set */
5688                   for(rSetIdx = 0; rSetIdx < rsrcSetList->list.count; rSetIdx++)
5689                   {
5690                      CU_FREE(rsrcSetList->list.array[rSetIdx], sizeof(SRS_ResourceSet_t));
5691                   }
5692                   CU_FREE(rsrcSetList->list.array, rsrcSetList->list.size);
5693                }
5694                CU_FREE(srsCfg->srs_ResourceSetToAddModList, \
5695                      sizeof(struct SRS_Config__srs_ResourceSetToAddModList));
5696             }
5697
5698             /* Free resource to add/modd list */
5699             if(srsCfg->srs_ResourceToAddModList)
5700             {
5701                resourceList = srsCfg->srs_ResourceToAddModList;
5702                if(resourceList->list.array)
5703                {
5704                   rsrcIdx = 0;
5705                   CU_FREE(resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2,\
5706                         sizeof(struct SRS_Resource__transmissionComb__n2));
5707                   CU_FREE(resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic,\
5708                         sizeof(struct SRS_Resource__resourceType__aperiodic));
5709
5710                   for(rsrcIdx = 0; rsrcIdx < resourceList->list.count; rsrcIdx++)
5711                   {
5712                      CU_FREE(resourceList->list.array[rsrcIdx], sizeof(SRS_Resource_t));
5713                   }
5714                   CU_FREE(resourceList->list.array, resourceList->list.size);
5715                }
5716                CU_FREE(srsCfg->srs_ResourceToAddModList, \
5717                      sizeof(struct SRS_Config__srs_ResourceToAddModList));
5718             }
5719
5720             CU_FREE(ulBwp->srs_Config->choice.setup, sizeof(SRS_Config_t));
5721          }
5722          CU_FREE(ulBwp->srs_Config, sizeof(struct BWP_UplinkDedicated__srs_Config));
5723       }
5724    }
5725 }
5726 /*******************************************************************
5727  *
5728  * @brief Frees memory allocated for initialUplinkBWP
5729  *
5730  * @details
5731  *
5732  *    Function : FreeinitialUplinkBWP
5733  *
5734  *    Functionality: Deallocating memory of initialUplinkBWP
5735  *
5736  * @params[in] UplinkConfig_t *ulCfg
5737  *
5738  * @return void
5739  *
5740  *
5741  * ****************************************************************/
5742 void FreeinitialUplinkBWP(UplinkConfig_t *ulCfg)
5743 {
5744    BWP_UplinkDedicated_t *ulBwp=NULLP;
5745    struct UplinkConfig__pusch_ServingCellConfig *puschCfg=NULLP;
5746
5747    if(ulCfg->initialUplinkBWP)
5748    {
5749       ulBwp=ulCfg->initialUplinkBWP;
5750       if(ulCfg->firstActiveUplinkBWP_Id)
5751       {
5752          if(ulCfg->pusch_ServingCellConfig)
5753          {
5754             puschCfg=ulCfg->pusch_ServingCellConfig;
5755             if(puschCfg->choice.setup)
5756             {
5757                if(puschCfg->choice.setup->ext1)
5758                {
5759                   CU_FREE(puschCfg->choice.setup->ext1->\
5760                         processingType2Enabled,sizeof(BOOLEAN_t));
5761                   CU_FREE(puschCfg->choice.setup->ext1->\
5762                         maxMIMO_Layers,sizeof(long));
5763                   CU_FREE(puschCfg->choice.setup->ext1, \
5764                         sizeof(struct PUSCH_ServingCellConfig__ext1));
5765                }
5766                CU_FREE(puschCfg->choice.setup, sizeof(struct PUSCH_ServingCellConfig));
5767             }
5768             CU_FREE(ulCfg->pusch_ServingCellConfig, sizeof(struct UplinkConfig__pusch_ServingCellConfig));
5769          }
5770          CU_FREE(ulCfg->firstActiveUplinkBWP_Id, sizeof(BWP_Id_t));
5771       }
5772       FreeInitialUlBWP(ulBwp);
5773       CU_FREE(ulCfg->initialUplinkBWP, sizeof(BWP_UplinkDedicated_t));
5774    }
5775 }
5776 /*******************************************************************
5777  *
5778  * @brief Frees emmory allocated for BWPDlDedPdschCfg
5779  *
5780  * @details
5781  *
5782  *    Function : FreeBWPDlDedPdschCfg
5783  *
5784  *    Functionality: Deallocating memory of BWPDlDedPdschCfg
5785  *
5786  * @params[in] BWP_DownlinkDedicated_t *dlBwp
5787  *
5788  * @return void
5789  *
5790  *
5791  * ****************************************************************/
5792 void FreeBWPDlDedPdschCfg(BWP_DownlinkDedicated_t *dlBwp)
5793 {
5794    struct PDSCH_Config *pdschCfg=NULLP;
5795    struct PDSCH_Config__prb_BundlingType *prbBndlType=NULLP;
5796    struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList=NULLP;
5797    struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA *dmrsDlCfg=NULLP;
5798
5799    if(dlBwp->pdsch_Config->choice.setup)
5800    {
5801       pdschCfg=dlBwp->pdsch_Config->choice.setup;
5802       if(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA)
5803       {
5804          if(pdschCfg->pdsch_TimeDomainAllocationList)
5805          {
5806             timeDomAllocList=pdschCfg->pdsch_TimeDomainAllocationList;
5807             if(pdschCfg->maxNrofCodeWordsScheduledByDCI)
5808             {
5809                prbBndlType=&pdschCfg->prb_BundlingType;
5810                CU_FREE(prbBndlType->choice.staticBundling,\
5811                      sizeof(struct PDSCH_Config__prb_BundlingType__staticBundling));
5812                CU_FREE(pdschCfg->maxNrofCodeWordsScheduledByDCI, sizeof(long));
5813             }
5814             FreePdschTimeDomAllocList(timeDomAllocList);
5815             CU_FREE(pdschCfg->pdsch_TimeDomainAllocationList, \
5816                   sizeof(struct PDSCH_Config__pdsch_TimeDomainAllocationList));
5817          }
5818          dmrsDlCfg=pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA;
5819          if(dmrsDlCfg->choice.setup)
5820          {
5821             CU_FREE(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition,
5822                   sizeof(long));
5823             CU_FREE(dmrsDlCfg->choice.setup, sizeof(struct DMRS_DownlinkConfig));
5824          }
5825          CU_FREE(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA, \
5826                sizeof(struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA));
5827       }
5828       CU_FREE(dlBwp->pdsch_Config->choice.setup, sizeof(struct PDSCH_Config));
5829    }
5830 }
5831 /*******************************************************************
5832  *
5833  * @brief Frees emmory allocated for BWPDlDedPdcchCfg
5834  *
5835  * @details
5836  *
5837  *    Function : FreeBWPDlDedPdcchCfg
5838  *
5839  *    Functionality: Deallocating memory of BWPDlDedPdcchCfg
5840  *
5841  * @params[in] BWP_DownlinkDedicated_t *dlBwp
5842  *
5843  * @return void
5844  *
5845  *
5846  * ****************************************************************/
5847 void FreeBWPDlDedPdcchCfg(BWP_DownlinkDedicated_t *dlBwp)
5848 {
5849    uint8_t idx1=0;
5850    uint8_t idx2=0;
5851    struct PDCCH_Config *pdcchCfg=NULLP;
5852    struct ControlResourceSet *controlRSet=NULLP;
5853    struct PDCCH_Config__controlResourceSetToAddModList *controlRSetList=NULLP;
5854
5855    if(dlBwp->pdcch_Config->choice.setup)
5856    {
5857       pdcchCfg=dlBwp->pdcch_Config->choice.setup;
5858       if(pdcchCfg->controlResourceSetToAddModList)
5859       {
5860          controlRSetList = pdcchCfg->controlResourceSetToAddModList;
5861          if(controlRSetList->list.array)
5862          {
5863             controlRSet = controlRSetList->list.array[idx2];
5864             if(controlRSet)
5865             {
5866                if(controlRSet->frequencyDomainResources.buf)
5867                {
5868                   if(controlRSet->pdcch_DMRS_ScramblingID)
5869                   {
5870                      if(pdcchCfg->searchSpacesToAddModList)
5871                      {
5872                         FreeSearchSpcToAddModList(pdcchCfg->searchSpacesToAddModList);
5873                         CU_FREE(pdcchCfg->searchSpacesToAddModList, \
5874                               sizeof(struct PDCCH_Config__searchSpacesToAddModList));
5875                      }
5876                      CU_FREE(controlRSet->pdcch_DMRS_ScramblingID, sizeof(long));
5877                   }
5878                   CU_FREE(controlRSet->frequencyDomainResources.buf, \
5879                         controlRSet->frequencyDomainResources.size);
5880                }
5881             }
5882             for(idx1 = 0; idx1 <controlRSetList->list.count; idx1++)
5883             {
5884                CU_FREE(controlRSetList->list.array[idx1], sizeof(struct ControlResourceSet));
5885             }
5886             CU_FREE(controlRSetList->list.array, controlRSetList->list.size);
5887          }
5888          CU_FREE(pdcchCfg->controlResourceSetToAddModList, \
5889                sizeof(struct PDCCH_Config__controlResourceSetToAddModList));
5890       }
5891       CU_FREE(dlBwp->pdcch_Config->choice.setup, sizeof(struct PDCCH_Config));
5892    }
5893 }
5894 /*******************************************************************
5895  *
5896  * @brief Builds RLC Config
5897  *
5898  * @details
5899  *
5900  *    Function : BuildRlcConfig
5901  *
5902  *    Functionality: Builds RLC Config in BuildRlcBearerToAddModList
5903  *
5904  * @params[in] RLC_Config *rlcConfig
5905  *
5906  * @return ROK     - success
5907  *         RFAILED - failure
5908  *
5909  * ****************************************************************/
5910 uint8_t BuildRlcConfig(RlcLcCfg rlcLcCfgDb, struct RLC_Config *rlcConfig)
5911 {
5912    rlcConfig->present = rlcLcCfgDb.rlcMode;
5913
5914    switch(rlcConfig->present)
5915    {
5916       case RLC_Config_PR_am:
5917          {
5918             rlcConfig->choice.am = NULLP;
5919             CU_ALLOC(rlcConfig->choice.am, sizeof(struct RLC_Config__am));
5920             if(!rlcConfig->choice.am)
5921             {
5922                DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfig");
5923                return RFAILED;
5924             }
5925
5926             /* UL */
5927             rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength = NULLP;
5928             CU_ALLOC(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
5929             if(!rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength)
5930             {
5931                DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfig");
5932                return RFAILED;
5933             }
5934             *(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength) = rlcLcCfgDb.u.amCfg.ulAmCfg.snLenUl;
5935             rlcConfig->choice.am->ul_AM_RLC.t_PollRetransmit  = rlcLcCfgDb.u.amCfg.ulAmCfg.pollRetxTmr;
5936             rlcConfig->choice.am->ul_AM_RLC.pollPDU           = rlcLcCfgDb.u.amCfg.ulAmCfg.pollPdu;
5937             rlcConfig->choice.am->ul_AM_RLC.pollByte          = rlcLcCfgDb.u.amCfg.ulAmCfg.pollByte;
5938             rlcConfig->choice.am->ul_AM_RLC.maxRetxThreshold  = rlcLcCfgDb.u.amCfg.ulAmCfg.maxRetxTh;
5939
5940             /* DL */
5941             rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength = NULLP;
5942             CU_ALLOC(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
5943             if(!rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength)
5944             {
5945                DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfig");
5946                return RFAILED;
5947             }
5948             *(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength) = rlcLcCfgDb.u.amCfg.dlAmCfg.snLenDl;
5949             rlcConfig->choice.am->dl_AM_RLC.t_Reassembly      = rlcLcCfgDb.u.amCfg.dlAmCfg.reAssemTmr;
5950             rlcConfig->choice.am->dl_AM_RLC.t_StatusProhibit  = rlcLcCfgDb.u.amCfg.dlAmCfg.statProhTmr;
5951
5952             break;
5953          }
5954
5955       case RLC_Config_PR_um_Bi_Directional:
5956          {
5957             rlcConfig->choice.um_Bi_Directional = NULLP;
5958             CU_ALLOC(rlcConfig->choice.um_Bi_Directional, sizeof(struct RLC_Config__um_Bi_Directional));
5959             if(!rlcConfig->choice.um_Bi_Directional)
5960             {
5961                DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfig");
5962                return RFAILED;
5963             }
5964
5965             /* UL */
5966             rlcConfig->choice.um_Bi_Directional->ul_UM_RLC.sn_FieldLength = NULLP;
5967             CU_ALLOC(rlcConfig->choice.um_Bi_Directional->ul_UM_RLC.sn_FieldLength, sizeof(SN_FieldLengthUM_t));
5968             if(!rlcConfig->choice.um_Bi_Directional->ul_UM_RLC.sn_FieldLength)
5969             {
5970                DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfig");
5971                return RFAILED;
5972             }
5973             *(rlcConfig->choice.um_Bi_Directional->ul_UM_RLC.sn_FieldLength) = rlcLcCfgDb.u.umBiDirCfg.ulUmCfg.snLenUlUm;
5974
5975             /* DL */
5976             rlcConfig->choice.um_Bi_Directional->dl_UM_RLC.sn_FieldLength = NULLP;
5977             CU_ALLOC(rlcConfig->choice.um_Bi_Directional->dl_UM_RLC.sn_FieldLength, sizeof(SN_FieldLengthUM_t));
5978             if(!rlcConfig->choice.um_Bi_Directional->dl_UM_RLC.sn_FieldLength)
5979             {
5980                DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfig");
5981                return RFAILED;
5982             }
5983             *(rlcConfig->choice.um_Bi_Directional->dl_UM_RLC.sn_FieldLength) = rlcLcCfgDb.u.umBiDirCfg.dlUmCfg.snLenDlUm;
5984             rlcConfig->choice.um_Bi_Directional->dl_UM_RLC.t_Reassembly = rlcLcCfgDb.u.umBiDirCfg.dlUmCfg.reAssemTmr;
5985             break;
5986          }
5987    }
5988    return ROK;
5989 }
5990
5991 /*******************************************************************
5992  *
5993  * @brief Builds MAC LC Config
5994  *
5995  * @details
5996  *
5997  *    Function : BuildMacLCConfig
5998  *
5999  *    Functionality: Builds MAC LC Config in BuildRlcBearerToAddModList
6000  *
6001  * @params[in] struct LogicalChannelConfig macLcConfig
6002  *
6003  * @return ROK     - success
6004  *         RFAILED - failure
6005  *
6006  * ****************************************************************/
6007 uint8_t BuildMacLCConfig(MacLcCfg macLcCfgDb, struct LogicalChannelConfig *macLcConfig)
6008 {
6009
6010    macLcConfig->ul_SpecificParameters = NULLP;
6011    CU_ALLOC(macLcConfig->ul_SpecificParameters, sizeof(struct LogicalChannelConfig__ul_SpecificParameters));
6012    if(!macLcConfig->ul_SpecificParameters)
6013    {
6014       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacLCConfig");
6015       return RFAILED;
6016    }
6017
6018    macLcConfig->ul_SpecificParameters->priority = macLcCfgDb.priority;
6019    macLcConfig->ul_SpecificParameters->prioritisedBitRate =     macLcCfgDb.pbr;
6020    macLcConfig->ul_SpecificParameters->bucketSizeDuration =     macLcCfgDb.bsd;
6021    macLcConfig->ul_SpecificParameters->allowedServingCells = NULLP;
6022    macLcConfig->ul_SpecificParameters->allowedSCS_List = NULLP;
6023    macLcConfig->ul_SpecificParameters->maxPUSCH_Duration = NULLP;
6024    macLcConfig->ul_SpecificParameters->configuredGrantType1Allowed = NULLP;
6025
6026    macLcConfig->ul_SpecificParameters->logicalChannelGroup = NULLP;
6027    CU_ALLOC(macLcConfig->ul_SpecificParameters->logicalChannelGroup,    sizeof(long));
6028    if(!macLcConfig->ul_SpecificParameters->logicalChannelGroup)
6029    {
6030       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacLCConfig");
6031       return RFAILED;
6032    }
6033    *(macLcConfig->ul_SpecificParameters->logicalChannelGroup) = macLcCfgDb.lcGroup;
6034
6035    macLcConfig->ul_SpecificParameters->schedulingRequestID = NULLP;
6036    CU_ALLOC(macLcConfig->ul_SpecificParameters->schedulingRequestID,    sizeof(SchedulingRequestId_t));
6037    if(!macLcConfig->ul_SpecificParameters->schedulingRequestID)
6038    {
6039       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacLCConfig");
6040       return RFAILED;
6041    }
6042    *(macLcConfig->ul_SpecificParameters->schedulingRequestID) = macLcCfgDb.schReqId;
6043
6044    macLcConfig->ul_SpecificParameters->logicalChannelSR_Mask = false;
6045    macLcConfig->ul_SpecificParameters->logicalChannelSR_DelayTimerApplied = false;
6046    macLcConfig->ul_SpecificParameters->bitRateQueryProhibitTimer = NULLP;
6047
6048    return ROK;
6049 }
6050 /*******************************************************************
6051  *
6052  * @brief Builds RLC Bearer to Add/Mod list
6053  *
6054  * @details
6055  *
6056  *    Function :BuildRlcBearerToAddModList
6057  *
6058  *    Functionality: Builds RLC Bearer to Add/Mod list in DuToCuRrcContainer
6059  *
6060  * @params[in] rlc_BearerToAddModList
6061  *
6062  * @return ROK     - success
6063  *         RFAILED - failure
6064  *
6065  * ****************************************************************/
6066 uint8_t BuildRlcBearerToAddModList(CuUeCb *ueCb, struct CellGroupConfigRrc__rlc_BearerToAddModList *rlcBearerList, bool updateAllRbCfg)
6067 {
6068    uint8_t idx, srbIdx = 0, drbIdx = 0, elementCnt=0;
6069
6070    if(updateAllRbCfg)
6071       elementCnt = ueCb->numSrb + ueCb->numDrb;
6072    else
6073    {
6074       for(srbIdx = 0; srbIdx< ueCb->numSrb; srbIdx++)
6075       {
6076          if(ueCb->srbList[srbIdx].cfgSentToUe == false)
6077             elementCnt++;
6078       }
6079
6080       for(drbIdx = 0; drbIdx< ueCb->numDrb; drbIdx++)
6081       {
6082          if(ueCb->drbList[drbIdx].cfgSentToUe == false)
6083             elementCnt++;
6084       }
6085    }
6086
6087    if(!elementCnt)
6088    {
6089       DU_LOG("INFO  --> F1AP : No  RLC Bearer available to add or modify");
6090       return ROK;
6091    }
6092    CU_ALLOC(rlcBearerList, sizeof(struct CellGroupConfigRrc__rlc_BearerToAddModList));
6093    if(!rlcBearerList)
6094    {
6095       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in CellGrpConfig");
6096       return RFAILED;
6097    }
6098    rlcBearerList->list.count = elementCnt;
6099    rlcBearerList->list.size  = elementCnt * sizeof(struct RLC_BearerConfig *);
6100
6101    rlcBearerList->list.array = NULLP;
6102    CU_ALLOC(rlcBearerList->list.array, rlcBearerList->list.size);
6103    if(!rlcBearerList->list.array)
6104    {
6105       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
6106       return RFAILED;
6107    }
6108
6109    for(idx=0; idx<rlcBearerList->list.count; idx++)
6110    {
6111       rlcBearerList->list.array[idx] = NULLP;
6112       CU_ALLOC(rlcBearerList->list.array[idx], sizeof(struct RLC_BearerConfig));
6113       if(!rlcBearerList->list.array[idx])
6114       {
6115          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
6116          return RFAILED;
6117       }
6118    }
6119
6120    idx = 0;
6121
6122    for(srbIdx=0; srbIdx < ueCb->numSrb; srbIdx++)
6123    {
6124       if(!updateAllRbCfg && ueCb->srbList[srbIdx].cfgSentToUe)
6125          continue;
6126
6127       rlcBearerList->list.array[idx]->logicalChannelIdentity = ueCb->srbList[srbIdx].lcId;
6128
6129       CU_ALLOC(rlcBearerList->list.array[idx]->servedRadioBearer, sizeof(struct RLC_BearerConfig__servedRadioBearer));
6130       if(!rlcBearerList->list.array[idx]->servedRadioBearer)
6131       {
6132          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
6133          return RFAILED;
6134       }
6135
6136       rlcBearerList->list.array[idx]->servedRadioBearer->present = RLC_BearerConfig__servedRadioBearer_PR_srb_Identity;
6137       rlcBearerList->list.array[idx]->servedRadioBearer->choice.srb_Identity = ueCb->srbList[srbIdx].srbId;
6138
6139       rlcBearerList->list.array[idx]->reestablishRLC = NULLP;
6140       rlcBearerList->list.array[idx]->rlc_Config = NULLP;
6141       CU_ALLOC(rlcBearerList->list.array[idx]->rlc_Config, sizeof(struct RLC_Config));
6142       if(!rlcBearerList->list.array[idx]->rlc_Config)
6143       {
6144          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
6145          return RFAILED;
6146       }
6147
6148       if(BuildRlcConfig(ueCb->srbList[srbIdx].rlcLcCfg, rlcBearerList->list.array[idx]->rlc_Config) != ROK)
6149       {
6150          DU_LOG("\nERROR  -->  F1AP : BuildRlcConfig failed");
6151          return RFAILED;
6152       }
6153
6154       rlcBearerList->list.array[idx]->mac_LogicalChannelConfig = NULLP;
6155       CU_ALLOC(rlcBearerList->list.array[idx]->mac_LogicalChannelConfig, sizeof(struct LogicalChannelConfig));
6156       if(!rlcBearerList->list.array[idx]->mac_LogicalChannelConfig)
6157       {
6158          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
6159          return RFAILED;
6160       }
6161
6162       if(BuildMacLCConfig(ueCb->srbList[srbIdx].macLcCfg, rlcBearerList->list.array[idx]->mac_LogicalChannelConfig) != ROK)
6163       {
6164          DU_LOG("\nERROR  -->  F1AP : BuildMacLCConfig failed");
6165          return RFAILED;
6166       }
6167       idx++;
6168    }
6169
6170    for(drbIdx=0; drbIdx < ueCb->numDrb; drbIdx++)
6171    {
6172       if(!updateAllRbCfg && ueCb->drbList[drbIdx].cfgSentToUe)
6173          continue;
6174
6175       rlcBearerList->list.array[idx]->logicalChannelIdentity = ueCb->drbList[drbIdx].lcId;
6176
6177       CU_ALLOC(rlcBearerList->list.array[idx]->servedRadioBearer, sizeof(struct RLC_BearerConfig__servedRadioBearer));
6178       if(!rlcBearerList->list.array[idx]->servedRadioBearer)
6179       {
6180          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
6181          return RFAILED;
6182       }
6183
6184       rlcBearerList->list.array[idx]->servedRadioBearer->present = RLC_BearerConfig__servedRadioBearer_PR_drb_Identity;
6185       rlcBearerList->list.array[idx]->servedRadioBearer->choice.drb_Identity = ueCb->drbList[drbIdx].drbId;
6186
6187       rlcBearerList->list.array[idx]->reestablishRLC = NULLP;
6188       rlcBearerList->list.array[idx]->rlc_Config = NULLP;
6189       CU_ALLOC(rlcBearerList->list.array[idx]->rlc_Config, sizeof(struct RLC_Config));
6190       if(!rlcBearerList->list.array[idx]->rlc_Config)
6191       {
6192          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
6193          return RFAILED;
6194       }
6195
6196       if(BuildRlcConfig(ueCb->drbList[drbIdx].rlcLcCfg, rlcBearerList->list.array[idx]->rlc_Config) != ROK)
6197       {
6198          DU_LOG("\nERROR  -->  F1AP : BuildRlcConfig failed");
6199          return RFAILED;
6200       }
6201
6202       rlcBearerList->list.array[idx]->mac_LogicalChannelConfig = NULLP;
6203       CU_ALLOC(rlcBearerList->list.array[idx]->mac_LogicalChannelConfig, sizeof(struct LogicalChannelConfig));
6204       if(!rlcBearerList->list.array[idx]->mac_LogicalChannelConfig)
6205       {
6206          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
6207          return RFAILED;
6208       }
6209
6210       if(BuildMacLCConfig(ueCb->drbList[drbIdx].macLcCfg, rlcBearerList->list.array[idx]->mac_LogicalChannelConfig) != ROK)
6211       {
6212          DU_LOG("\nERROR  -->  F1AP : BuildMacLCConfig failed");
6213          return RFAILED;
6214       }
6215       idx++;
6216    }
6217    return ROK;
6218 }
6219
6220 /*******************************************************************
6221  *
6222  * @brief Free memory allocated for CellGroupConfig
6223  *
6224  * @details
6225  *
6226  *    Function : FreeMemCellGrpCfg
6227  *
6228  *    Functionality: Deallocating memory of CellGroupConfig
6229  *
6230  * @params[in] pointer to CellGroupConfigRrc_t
6231  *
6232  * @return ROK     - success
6233  *         RFAILED - failure
6234  *
6235  ******************************************************************/
6236 uint8_t FreeMemCellGrpCfg(CellGroupConfigRrc_t *cellGrpCfg)
6237 {
6238    uint8_t idx=0;
6239    SpCellConfig_t *spCellCfg=NULLP;
6240    ServingCellConfig_t *srvCellCfg=NULLP;
6241    BWP_DownlinkDedicated_t *dlBwp=NULLP;
6242    MAC_CellGroupConfig_t *macCellGrpCfg=NULLP;
6243    PhysicalCellGroupConfig_t *phyCellGrpCfg=NULLP;
6244    struct CellGroupConfigRrc__rlc_BearerToAddModList *rlcBearerList=NULLP;
6245    struct RLC_Config *rlcConfig=NULLP;
6246    struct LogicalChannelConfig *macLcConfig=NULLP;
6247    struct SchedulingRequestConfig *schedulingRequestConfig=NULLP;
6248    struct SchedulingRequestConfig__schedulingRequestToAddModList *schReqList=NULLP;
6249    struct TAG_Config *tagConfig=NULLP;
6250    struct TAG_Config__tag_ToAddModList *tagList=NULLP;
6251    struct MAC_CellGroupConfig__phr_Config *phrConfig=NULLP;
6252    struct ServingCellConfig__pdsch_ServingCellConfig *pdschCfg=NULLP;
6253
6254    rlcBearerList = cellGrpCfg->rlc_BearerToAddModList;
6255    if(rlcBearerList)
6256    {
6257       if(rlcBearerList->list.array)
6258       {
6259          for(idx=0; idx<rlcBearerList->list.count; idx++)
6260          {
6261             if(rlcBearerList->list.array[idx])
6262             {
6263                rlcConfig   = rlcBearerList->list.array[idx]->rlc_Config;
6264                macLcConfig = rlcBearerList->list.array[idx]->mac_LogicalChannelConfig;
6265                if(rlcConfig)
6266                {
6267                   if(rlcConfig->choice.am)
6268                   {
6269                      CU_FREE(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
6270                      CU_FREE(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
6271                      CU_FREE(rlcConfig->choice.am, sizeof(struct RLC_Config__am));
6272                   }
6273                   CU_FREE(rlcConfig, sizeof(struct RLC_Config));
6274                }
6275                CU_FREE(rlcBearerList->list.array[idx]->servedRadioBearer, sizeof(struct RLC_BearerConfig__servedRadioBearer));
6276                if(macLcConfig)
6277                {
6278                   if(macLcConfig->ul_SpecificParameters)
6279                   {
6280                      CU_FREE(macLcConfig->ul_SpecificParameters->schedulingRequestID,   sizeof(SchedulingRequestId_t));
6281                      CU_FREE(macLcConfig->ul_SpecificParameters->logicalChannelGroup,   sizeof(long));
6282                      CU_FREE(macLcConfig->ul_SpecificParameters, sizeof(struct LogicalChannelConfig__ul_SpecificParameters));
6283                   }
6284                   CU_FREE(rlcBearerList->list.array[idx]->mac_LogicalChannelConfig, sizeof(struct LogicalChannelConfig));
6285                }
6286                CU_FREE(rlcBearerList->list.array[idx], sizeof(struct RLC_BearerConfig));
6287             }
6288          }
6289          CU_FREE(rlcBearerList->list.array, rlcBearerList->list.size);
6290       }
6291       CU_FREE(cellGrpCfg->rlc_BearerToAddModList, sizeof(struct CellGroupConfigRrc__rlc_BearerToAddModList));
6292    }
6293
6294    macCellGrpCfg = cellGrpCfg->mac_CellGroupConfig;
6295    if(macCellGrpCfg)
6296    {
6297       schedulingRequestConfig = macCellGrpCfg->schedulingRequestConfig;
6298       if(schedulingRequestConfig)
6299       {
6300          schReqList = schedulingRequestConfig->schedulingRequestToAddModList;
6301          if(schReqList)
6302          {
6303             if(schReqList->list.array)
6304             {
6305                for(idx=0;idx<schReqList->list.count; idx++)
6306                {
6307                   if(schReqList->list.array[idx])
6308                   {
6309                      CU_FREE(schReqList->list.array[idx]->sr_ProhibitTimer, sizeof(long));
6310                      CU_FREE(schReqList->list.array[idx], sizeof(struct SchedulingRequestToAddMod));
6311                   }
6312                }
6313                CU_FREE(schReqList->list.array, schReqList->list.size);
6314             }
6315             CU_FREE(schedulingRequestConfig->schedulingRequestToAddModList,\
6316                   sizeof(struct SchedulingRequestConfig__schedulingRequestToAddModList));    }
6317             CU_FREE(macCellGrpCfg->schedulingRequestConfig, sizeof(struct SchedulingRequestConfig));
6318       }
6319       if(macCellGrpCfg->bsr_Config)
6320       {
6321          CU_FREE(macCellGrpCfg->bsr_Config, sizeof(struct BSR_Config));
6322       }
6323       tagConfig = macCellGrpCfg->tag_Config;
6324       if(tagConfig)
6325       {
6326          tagList = tagConfig->tag_ToAddModList;
6327          if(tagList)
6328          {
6329             if(tagList->list.array)
6330             {
6331                for(idx=0; idx<tagList->list.count; idx++)
6332                {
6333                   CU_FREE(tagList->list.array[idx], sizeof(struct TAG));
6334                }
6335                CU_FREE(tagList->list.array, tagList->list.size);
6336             }
6337             CU_FREE(tagConfig->tag_ToAddModList, sizeof(struct TAG_Config__tag_ToAddModList));
6338          }
6339          CU_FREE(tagConfig, sizeof(struct TAG_Config));
6340       }
6341
6342       phrConfig = macCellGrpCfg->phr_Config;
6343       if(phrConfig)
6344       {
6345          CU_FREE(phrConfig->choice.setup, sizeof(struct PHR_Config));
6346          CU_FREE(phrConfig, sizeof(struct MAC_CellGroupConfig__phr_Config));
6347       }
6348
6349       CU_FREE(macCellGrpCfg, sizeof(MAC_CellGroupConfig_t));
6350    }
6351
6352    phyCellGrpCfg = cellGrpCfg->physicalCellGroupConfig;
6353    if(phyCellGrpCfg)
6354    {
6355       CU_FREE(phyCellGrpCfg->p_NR_FR1, sizeof(long));
6356       CU_FREE(phyCellGrpCfg, sizeof(PhysicalCellGroupConfig_t));
6357    }
6358
6359    spCellCfg = cellGrpCfg->spCellConfig;
6360    if(spCellCfg)
6361    {
6362       if(spCellCfg->servCellIndex)
6363       {
6364          if(spCellCfg->rlmInSyncOutOfSyncThreshold)
6365          {
6366             if(spCellCfg->spCellConfigDedicated)
6367             {
6368                srvCellCfg = spCellCfg->spCellConfigDedicated;
6369                if(srvCellCfg->initialDownlinkBWP)
6370                {
6371                   dlBwp = srvCellCfg->initialDownlinkBWP;
6372                   if(srvCellCfg->firstActiveDownlinkBWP_Id)
6373                   {
6374                      if(srvCellCfg->defaultDownlinkBWP_Id)
6375                      {
6376                         if(srvCellCfg->uplinkConfig)
6377                         {
6378                            if(srvCellCfg->pdsch_ServingCellConfig)
6379                            {
6380                               pdschCfg= srvCellCfg->pdsch_ServingCellConfig;
6381                               if(pdschCfg->choice.setup)
6382                               {
6383                                  CU_FREE(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH,sizeof(long));
6384                                  CU_FREE(pdschCfg->choice.setup, sizeof( struct PDSCH_ServingCellConfig));
6385                               }
6386                               CU_FREE(srvCellCfg->pdsch_ServingCellConfig, sizeof(struct
6387                                        ServingCellConfig__pdsch_ServingCellConfig));
6388                            }
6389                            FreeinitialUplinkBWP(srvCellCfg->uplinkConfig);
6390                            CU_FREE(srvCellCfg->uplinkConfig, sizeof(UplinkConfig_t));
6391                         }
6392                         CU_FREE(srvCellCfg->defaultDownlinkBWP_Id, sizeof(long));
6393                      }
6394                      CU_FREE(srvCellCfg->firstActiveDownlinkBWP_Id, sizeof(long));
6395                   }
6396                   if(dlBwp->pdcch_Config)
6397                   {
6398                      if(dlBwp->pdsch_Config)
6399                      {
6400                         FreeBWPDlDedPdschCfg(dlBwp);
6401                         CU_FREE(dlBwp->pdsch_Config, sizeof(struct BWP_DownlinkDedicated__pdsch_Config));
6402                      }
6403                      FreeBWPDlDedPdcchCfg(dlBwp);
6404                      CU_FREE(dlBwp->pdcch_Config, sizeof(struct BWP_DownlinkDedicated__pdcch_Config));
6405                   }
6406                   CU_FREE(srvCellCfg->initialDownlinkBWP, sizeof(BWP_DownlinkDedicated_t));
6407                }
6408                CU_FREE(spCellCfg->spCellConfigDedicated, sizeof(ServingCellConfig_t));
6409             }
6410             CU_FREE(spCellCfg->rlmInSyncOutOfSyncThreshold, sizeof(long));
6411          }
6412          CU_FREE(spCellCfg->servCellIndex, sizeof(long));
6413       }
6414       CU_FREE(spCellCfg,sizeof(SpCellConfig_t));
6415    }
6416    return ROK;
6417 }
6418
6419 /*******************************************************************
6420  *
6421  * @brief Fills CellGroupConfig
6422  *
6423  * @details
6424  *
6425  *    Function : fillCellGrpCfg
6426  *
6427  *    Functionality: Fills CellGroupConfig
6428  *
6429  * @params[in] pointer to CellGroupConfigRrc_t
6430  *
6431  * @return ROK     - success
6432  *         RFAILED - failure
6433  *
6434  ******************************************************************/
6435
6436 uint8_t fillCellGrpCfg(CuUeCb *ueCb, OCTET_STRING_t *cellGrp, bool updateAllRbCfg)
6437 {
6438    uint8_t               ret = RFAILED;
6439    CellGroupConfigRrc_t  cellGrpCfg;
6440    asn_enc_rval_t        encRetVal;
6441
6442    while(true)
6443    {
6444       cellGrpCfg.cellGroupId = CELL_GRP_ID;
6445
6446       cellGrpCfg.rlc_BearerToAddModList = NULLP;
6447
6448       if(BuildRlcBearerToAddModList(ueCb, cellGrpCfg.rlc_BearerToAddModList, updateAllRbCfg) != ROK)
6449       {
6450          DU_LOG("\nERROR  -->  F1AP : fillCellGrpCfg failed");
6451          break;
6452       }
6453
6454       cellGrpCfg.rlc_BearerToReleaseList = NULLP;
6455       cellGrpCfg.mac_CellGroupConfig = NULLP;
6456       CU_ALLOC(cellGrpCfg.mac_CellGroupConfig, sizeof(MAC_CellGroupConfig_t));
6457       if(!cellGrpCfg.mac_CellGroupConfig)
6458       {
6459          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in fillCellGrpCfg");
6460          break;
6461       }
6462       if(BuildMacCellGrpCfg(cellGrpCfg.mac_CellGroupConfig) != ROK)
6463       {
6464          DU_LOG("\nERROR  -->  F1AP : BuildMacCellGrpCfg failed");
6465          break;
6466       }
6467
6468       cellGrpCfg.physicalCellGroupConfig = NULLP;
6469       CU_ALLOC(cellGrpCfg.physicalCellGroupConfig, sizeof(PhysicalCellGroupConfig_t));
6470       if(!cellGrpCfg.physicalCellGroupConfig)
6471       {
6472          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildDuToCuRrcContainer");
6473          break;
6474       }
6475       if(BuildPhyCellGrpCfg(cellGrpCfg.physicalCellGroupConfig) != ROK)
6476       {
6477          DU_LOG("\nERROR  -->  F1AP : BuildPhyCellGrpCfg failed");
6478          break;
6479       }
6480
6481       cellGrpCfg.spCellConfig = NULLP;
6482       CU_ALLOC(cellGrpCfg.spCellConfig, sizeof(SpCellConfig_t));
6483       if(!cellGrpCfg.spCellConfig)
6484       {
6485          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildDuToCuRrcContainer");
6486          break;
6487       }
6488       if(BuildSpCellCfg(cellGrpCfg.spCellConfig) != ROK)
6489       {
6490          DU_LOG("\nERROR  -->  F1AP : BuildSpCellCfg failed");
6491          break;
6492       }
6493
6494       cellGrpCfg.sCellToAddModList = NULLP;
6495       cellGrpCfg.sCellToReleaseList = NULLP;
6496       cellGrpCfg.ext1 = NULLP;
6497
6498       /* encode cellGrpCfg into duToCuRrcContainer */
6499       xer_fprint(stdout, &asn_DEF_CellGroupConfigRrc, &cellGrpCfg);
6500       cmMemset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
6501       encBufSize = 0;
6502       encRetVal = aper_encode(&asn_DEF_CellGroupConfigRrc, 0, &cellGrpCfg, PrepFinalEncBuf, encBuf);
6503       /* Encode results */
6504       if(encRetVal.encoded == ENCODE_FAIL)
6505       {
6506          DU_LOG( "\nERROR  -->  F1AP : Could not encode DuToCuRrcContainer (at %s)\n",\
6507                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
6508          break;
6509       }
6510       else
6511       {
6512          DU_LOG("\nDEBUG  -->  F1AP : Created APER encodedbuffer for DuToCuRrcContainer\n");
6513          for(int i=0; i< encBufSize; i++)
6514          {
6515             DU_LOG("%x",encBuf[i]);
6516          }
6517       }
6518
6519       cellGrp->size = encBufSize;
6520       CU_ALLOC(cellGrp->buf, cellGrp->size);
6521       if(!cellGrp->buf)
6522       {
6523          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDuToCuRrcContainer");
6524          break;
6525       }
6526       memcpy(cellGrp->buf, encBuf, cellGrp->size);
6527       ret = ROK;
6528       break;
6529    }
6530    FreeMemCellGrpCfg(&cellGrpCfg);
6531    return ret;
6532 }
6533
6534 /*******************************************************************
6535  *
6536  * @brief Free UE Capability RAT container
6537  *
6538  * @details
6539  *
6540  *    Function : freeUeCapRatCont
6541  *
6542  *    Functionality:
6543  *       Free UE Capability RAT conatiner
6544  *
6545  * @params[in]
6546  * @return ROK     - success
6547  *         RFAILED - failure
6548  *
6549  * ****************************************************************/
6550 void freeUeCapRatCont(UE_NR_Capability_t *ueNrCap)
6551 {
6552    uint8_t idx;
6553    FeatureSets_t *featureSets;
6554
6555    if(ueNrCap->rf_Parameters.supportedBandListNR.list.array)
6556    {
6557       for(idx = 0; idx < ueNrCap->rf_Parameters.supportedBandListNR.list.count; idx++)
6558       {
6559          if(ueNrCap->rf_Parameters.supportedBandListNR.list.array[idx])
6560             CU_FREE(ueNrCap->rf_Parameters.supportedBandListNR.list.array[idx], sizeof(struct BandNR));
6561       }
6562       CU_FREE(ueNrCap->rf_Parameters.supportedBandListNR.list.array, ueNrCap->rf_Parameters.supportedBandListNR.list.size);
6563    }
6564
6565    if(ueNrCap->featureSets)
6566    {
6567       featureSets = ueNrCap->featureSets;
6568       if(featureSets->featureSetsDownlinkPerCC)
6569       {
6570          if(featureSets->featureSetsDownlinkPerCC->list.array)
6571          {
6572             for(idx = 0; idx < featureSets->featureSetsDownlinkPerCC->list.count; idx++)
6573             {
6574                   if(featureSets->featureSetsDownlinkPerCC->list.array[idx]->supportedModulationOrderDL)
6575                      CU_FREE(featureSets->featureSetsDownlinkPerCC->list.array[idx]->supportedModulationOrderDL, \
6576                         sizeof(ModulationOrder_t));
6577                   CU_FREE(featureSets->featureSetsDownlinkPerCC->list.array[idx], sizeof(struct FeatureSetDownlinkPerCC));
6578             }
6579             CU_FREE(featureSets->featureSetsDownlinkPerCC->list.array, featureSets->featureSetsDownlinkPerCC->list.size);
6580          }
6581          CU_FREE(featureSets->featureSetsDownlinkPerCC, sizeof(struct FeatureSets__featureSetsDownlinkPerCC));
6582       }
6583
6584       if(featureSets->featureSetsUplinkPerCC)
6585       {
6586          if(featureSets->featureSetsUplinkPerCC->list.array)
6587          {
6588             for(idx = 0; idx < featureSets->featureSetsUplinkPerCC->list.count; idx++)
6589             {
6590                if(featureSets->featureSetsUplinkPerCC->list.array[idx])
6591                {
6592                   if(featureSets->featureSetsUplinkPerCC->list.array[idx]->supportedModulationOrderUL)
6593                      CU_FREE(featureSets->featureSetsUplinkPerCC->list.array[idx]->supportedModulationOrderUL,\
6594                          sizeof(ModulationOrder_t));
6595                   CU_FREE(featureSets->featureSetsUplinkPerCC->list.array[idx], sizeof(struct FeatureSetUplinkPerCC));
6596                }
6597             }
6598             CU_FREE(featureSets->featureSetsUplinkPerCC->list.array,  featureSets->featureSetsUplinkPerCC->list.size);
6599          }
6600          CU_FREE(featureSets->featureSetsUplinkPerCC, sizeof(struct FeatureSets__featureSetsUplinkPerCC));
6601       }
6602       CU_FREE(ueNrCap->featureSets, sizeof(struct FeatureSets));
6603    }
6604 }
6605
6606 /*******************************************************************
6607  *
6608  * @brief Free UE capability RAT container list
6609  *
6610  * @details
6611  *
6612  *    Function : freeUeCapRatContList
6613  *
6614  *    Functionality: Free UE capability RAT container list
6615  *
6616  * @params[in]
6617  * @return ROK     - success
6618  *         RFAILED - failure
6619  *
6620  * ****************************************************************/
6621 void freeUeCapRatContList(UE_CapabilityRAT_ContainerListRRC_t *ueCapablityList)
6622 {
6623    uint8_t idx;
6624    if(ueCapablityList->list.array)
6625    {
6626       for(idx = 0; idx < ueCapablityList->list.count; idx++)
6627       {
6628          if(ueCapablityList->list.array[idx])
6629             CU_FREE(ueCapablityList->list.array[idx], sizeof(UE_CapabilityRAT_Container_t));
6630       }
6631       CU_FREE(ueCapablityList->list.array, ueCapablityList->list.size);
6632    }
6633 }
6634
6635 /*******************************************************************
6636  *
6637  * @brief Free Handover preparation information
6638  *
6639  * @details
6640  *
6641  *    Function : freeHOPreparationInfo
6642  *
6643  *    Functionality: Free Handover preparation information
6644  *
6645  * @params[in]
6646  * @return ROK     - success
6647  *         RFAILED - failure
6648  *
6649  * ****************************************************************/
6650 void freeHOPreparationInfo(HandoverPreparationInformationRrc_t *hoPrep)
6651 {
6652    HandoverPreparationInformationRrc_IEs_t *hoPrepInfoIe;
6653
6654    if(hoPrep->criticalExtensions.choice.c1)
6655    {
6656       if(hoPrep->criticalExtensions.choice.c1->choice.handoverPreparationInformation)
6657       {
6658          hoPrepInfoIe = hoPrep->criticalExtensions.choice.c1->choice.handoverPreparationInformation;
6659          freeUeCapRatContList(&hoPrepInfoIe->ue_CapabilityRAT_List);
6660          CU_FREE(hoPrep->criticalExtensions.choice.c1->choice.handoverPreparationInformation , \
6661                sizeof(HandoverPreparationInformationRrc_IEs_t));
6662       }
6663       CU_FREE(hoPrep->criticalExtensions.choice.c1, sizeof(struct HandoverPreparationInformationRrc__criticalExtensions__c1));
6664    }
6665 }
6666
6667 /*******************************************************************
6668  *
6669  * @brief Fill feature sets
6670  *
6671  * @details
6672  *
6673  *    Function : fillFeatureSets
6674  *
6675  *    Functionality: Fill feature sets
6676  *
6677  * @params[in]
6678  * @return ROK     - success
6679  *         RFAILED - failure
6680  *
6681  * ****************************************************************/
6682 uint8_t fillFeatureSets(FeatureSets_t *featureSets)
6683 {
6684    uint8_t idx, elementCnt;
6685
6686    featureSets->featureSetsDownlink = NULLP;
6687    CU_ALLOC(featureSets->featureSetsDownlinkPerCC, sizeof(struct FeatureSets__featureSetsDownlinkPerCC));
6688    if(!featureSets->featureSetsDownlinkPerCC)
6689    {
6690       DU_LOG("\nERROR  --> F1AP : Memory allocation failed in fillFeatureSets");
6691       return RFAILED;
6692    }
6693
6694    elementCnt = 1;
6695    featureSets->featureSetsDownlinkPerCC->list.count = elementCnt;
6696    featureSets->featureSetsDownlinkPerCC->list.size = elementCnt * sizeof(struct FeatureSetDownlinkPerCC *);
6697    CU_ALLOC(featureSets->featureSetsDownlinkPerCC->list.array, featureSets->featureSetsDownlinkPerCC->list.size);
6698    if(!featureSets->featureSetsDownlinkPerCC->list.array)
6699    {
6700       DU_LOG("\nERROR  --> F1AP : Memory allocation failed in fillFeatureSets");
6701       return RFAILED;
6702    }
6703
6704    for(idx = 0; idx < elementCnt; idx++)
6705    {
6706       CU_ALLOC(featureSets->featureSetsDownlinkPerCC->list.array[idx], sizeof(struct FeatureSetDownlinkPerCC));
6707       if(!featureSets->featureSetsDownlinkPerCC->list.array[idx])
6708       {
6709          DU_LOG("\nERROR  --> F1AP : Memory allocation failed in fillFeatureSets");
6710          return RFAILED;
6711       }
6712    }
6713
6714    idx = 0;
6715    featureSets->featureSetsDownlinkPerCC->list.array[idx]->supportedSubcarrierSpacingDL = SubcarrierSpacing_kHz15;
6716    featureSets->featureSetsDownlinkPerCC->list.array[idx]->supportedBandwidthDL.present = SupportedBandwidth_PR_fr1;
6717    featureSets->featureSetsDownlinkPerCC->list.array[idx]->supportedBandwidthDL.choice.fr1 = SupportedBandwidth__fr1_mhz20;
6718    featureSets->featureSetsDownlinkPerCC->list.array[idx]->channelBW_90mhz = NULLP;
6719    featureSets->featureSetsDownlinkPerCC->list.array[idx]->maxNumberMIMO_LayersPDSCH = NULLP;
6720
6721    CU_ALLOC(featureSets->featureSetsDownlinkPerCC->list.array[idx]->supportedModulationOrderDL, sizeof(ModulationOrder_t));
6722    if(!featureSets->featureSetsDownlinkPerCC->list.array[idx]->supportedModulationOrderDL)
6723    {
6724       DU_LOG("\nERROR  --> F1AP : Memory allocation failed in fillFeatureSets");
6725       return RFAILED;
6726    }
6727    *(featureSets->featureSetsDownlinkPerCC->list.array[idx]->supportedModulationOrderDL) = ModulationOrder_qam64;
6728
6729    featureSets->featureSetsUplink = NULLP;
6730    CU_ALLOC(featureSets->featureSetsUplinkPerCC, sizeof(struct FeatureSets__featureSetsUplinkPerCC));
6731    if(!featureSets->featureSetsUplinkPerCC)
6732    {
6733       DU_LOG("\nERROR  --> F1AP : Memory allocation failed in fillFeatureSets");
6734       return RFAILED;
6735    }
6736
6737    elementCnt = 1;
6738    featureSets->featureSetsUplinkPerCC->list.count = elementCnt;
6739    featureSets->featureSetsUplinkPerCC->list.size = elementCnt * sizeof(struct FeatureSetUplinkPerCC *);
6740    CU_ALLOC(featureSets->featureSetsUplinkPerCC->list.array, featureSets->featureSetsUplinkPerCC->list.size);
6741    if(!featureSets->featureSetsUplinkPerCC->list.array)
6742    {
6743       DU_LOG("\nERROR  --> F1AP : Memory allocation failed in fillFeatureSets");
6744       return RFAILED;
6745    }
6746
6747    for(idx = 0; idx < elementCnt; idx++)
6748    {
6749       CU_ALLOC(featureSets->featureSetsUplinkPerCC->list.array[idx], sizeof(struct FeatureSetUplinkPerCC));
6750       if(!featureSets->featureSetsUplinkPerCC->list.array[idx])
6751       {
6752          DU_LOG("\nERROR  --> F1AP : Memory allocation failed in fillFeatureSets");
6753          return RFAILED;
6754       }
6755    }
6756
6757    idx = 0;
6758    featureSets->featureSetsUplinkPerCC->list.array[idx]->supportedSubcarrierSpacingUL = SubcarrierSpacing_kHz15;
6759    featureSets->featureSetsUplinkPerCC->list.array[idx]->supportedBandwidthUL.present = SupportedBandwidth_PR_fr1;
6760    featureSets->featureSetsUplinkPerCC->list.array[idx]->supportedBandwidthUL.choice.fr1 = SupportedBandwidth__fr1_mhz20;
6761    featureSets->featureSetsUplinkPerCC->list.array[idx]->channelBW_90mhz = NULLP;
6762    featureSets->featureSetsUplinkPerCC->list.array[idx]->mimo_CB_PUSCH = NULLP;
6763    featureSets->featureSetsUplinkPerCC->list.array[idx]->maxNumberMIMO_LayersNonCB_PUSCH = NULLP;
6764
6765    CU_ALLOC(featureSets->featureSetsUplinkPerCC->list.array[idx]->supportedModulationOrderUL, sizeof(ModulationOrder_t));
6766    if(!featureSets->featureSetsUplinkPerCC->list.array[idx]->supportedModulationOrderUL)
6767    {
6768       DU_LOG("\nERROR  --> F1AP : Memory allocation failed in fillFeatureSets");
6769       return RFAILED;
6770    }
6771    *(featureSets->featureSetsUplinkPerCC->list.array[idx]->supportedModulationOrderUL) = ModulationOrder_qam16;
6772
6773    return ROK;
6774 }
6775
6776 /*******************************************************************
6777  *
6778  * @brief Fill UE capability RAT container
6779  *
6780  * @details
6781  *
6782  *    Function : fillUeCapRatCont
6783  *
6784  *    Functionality: Fill UE capability RAT container
6785  *
6786  * @params[in] UE Capability RAT container buffer
6787  * @return ROK     - success
6788  *         RFAILED - failure
6789  *
6790  * ****************************************************************/
6791 uint8_t fillUeCapRatCont(OCTET_STRING_t *ueCapRatContBuf)
6792 {
6793    uint8_t             ret = ROK;
6794    uint8_t             idx, elementCnt;
6795    asn_enc_rval_t      encRetVal;
6796    UE_NR_Capability_t  ueNrCap;
6797
6798    while(true)
6799    {
6800       ueNrCap.accessStratumRelease = AccessStratumRelease_rel15;
6801
6802       /* Filling PDCP parameters */
6803       ueNrCap.pdcp_Parameters.supportedROHC_Profiles.profile0x0000 = false;
6804       ueNrCap.pdcp_Parameters.supportedROHC_Profiles.profile0x0001 = false;
6805       ueNrCap.pdcp_Parameters.supportedROHC_Profiles.profile0x0002 = false;
6806       ueNrCap.pdcp_Parameters.supportedROHC_Profiles.profile0x0003 = false;
6807       ueNrCap.pdcp_Parameters.supportedROHC_Profiles.profile0x0004 = false;
6808       ueNrCap.pdcp_Parameters.supportedROHC_Profiles.profile0x0006 = false;
6809       ueNrCap.pdcp_Parameters.supportedROHC_Profiles.profile0x0101 = false;
6810       ueNrCap.pdcp_Parameters.supportedROHC_Profiles.profile0x0102 = false;
6811       ueNrCap.pdcp_Parameters.supportedROHC_Profiles.profile0x0103 = false;
6812       ueNrCap.pdcp_Parameters.supportedROHC_Profiles.profile0x0104 = false;
6813       ueNrCap.pdcp_Parameters.maxNumberROHC_ContextSessions = PDCP_Parameters__maxNumberROHC_ContextSessions_cs2;
6814       ueNrCap.pdcp_Parameters.uplinkOnlyROHC_Profiles = NULLP;
6815       ueNrCap.pdcp_Parameters.continueROHC_Context = NULLP;
6816       ueNrCap.pdcp_Parameters.outOfOrderDelivery = NULLP;
6817       ueNrCap.pdcp_Parameters.shortSN = NULLP;
6818       ueNrCap.pdcp_Parameters.pdcp_DuplicationSRB = NULLP;
6819       ueNrCap.pdcp_Parameters.pdcp_DuplicationMCG_OrSCG_DRB = NULLP;
6820
6821       ueNrCap.rlc_Parameters = NULLP;
6822       ueNrCap.mac_Parameters = NULLP;
6823
6824       /* Filling PHY parameters */
6825       ueNrCap.phy_Parameters.phy_ParametersCommon = NULLP;
6826       ueNrCap.phy_Parameters.phy_ParametersXDD_Diff = NULLP;
6827       ueNrCap.phy_Parameters.phy_ParametersFRX_Diff = NULLP;
6828       ueNrCap.phy_Parameters.phy_ParametersFR1 = NULLP;
6829       ueNrCap.phy_Parameters.phy_ParametersFR2 = NULLP;
6830
6831       /* Filling RF parameters */
6832       elementCnt = 1;
6833       ueNrCap.rf_Parameters.supportedBandListNR.list.count = elementCnt;
6834       ueNrCap.rf_Parameters.supportedBandListNR.list.size = elementCnt * sizeof(struct BandNR *);
6835       CU_ALLOC(ueNrCap.rf_Parameters.supportedBandListNR.list.array, ueNrCap.rf_Parameters.supportedBandListNR.list.size);
6836       if(!ueNrCap.rf_Parameters.supportedBandListNR.list.array)
6837       {
6838          DU_LOG("\nERROR  --> F1AP : Memory allocation failed in fillUeCapRatCont");
6839          ret = RFAILED;
6840          break;
6841       }
6842
6843       for(idx = 0; idx < elementCnt; idx++)
6844       {
6845          CU_ALLOC(ueNrCap.rf_Parameters.supportedBandListNR.list.array[idx], sizeof(struct BandNR));
6846          if(!ueNrCap.rf_Parameters.supportedBandListNR.list.array[idx])
6847          {
6848             ret = RFAILED;
6849             break;
6850          }
6851       }
6852       if(ret == RFAILED)
6853          break;
6854
6855       idx = 0;
6856       ueNrCap.rf_Parameters.supportedBandListNR.list.array[idx]->bandNR = 1;
6857       ueNrCap.rf_Parameters.supportedBandCombinationList = NULLP;
6858       ueNrCap.rf_Parameters.appliedFreqBandListFilter = NULLP;
6859
6860       ueNrCap.measAndMobParameters = NULLP;
6861       ueNrCap.fdd_Add_UE_NR_Capabilities = NULLP;
6862       ueNrCap.tdd_Add_UE_NR_Capabilities = NULLP;
6863       ueNrCap.fr1_Add_UE_NR_Capabilities = NULLP;
6864       ueNrCap.fr2_Add_UE_NR_Capabilities = NULLP;
6865       ueNrCap.featureSets = NULLP;
6866
6867       CU_ALLOC(ueNrCap.featureSets, sizeof(struct FeatureSets));
6868       if(!ueNrCap.featureSets)
6869       {
6870          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in fillUeCapRatCont");
6871          ret = RFAILED;
6872          break;
6873       }
6874
6875       if(fillFeatureSets(ueNrCap.featureSets) != ROK)
6876       {
6877          DU_LOG("\nERROR  -->  fillDLFeatureSets() failed ");
6878          ret = RFAILED;
6879          break;
6880       }
6881
6882       ueNrCap.featureSetCombinations = NULLP;
6883       ueNrCap.lateNonCriticalExtension = NULLP;
6884       ueNrCap.nonCriticalExtension = NULLP;
6885
6886       /* encode UE Capability RAT Container List into duToCuRrcContainer */
6887       xer_fprint(stdout, &asn_DEF_UE_NR_Capability, &ueNrCap);
6888       cmMemset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
6889       encBufSize = 0;
6890       encRetVal = aper_encode(&asn_DEF_UE_NR_Capability, 0, &ueNrCap, PrepFinalEncBuf, encBuf);
6891
6892       /* Encode results */
6893       if(encRetVal.encoded == ENCODE_FAIL)
6894       {
6895          DU_LOG( "\nERROR  -->  F1AP : Could not encode UE Capability RAT Container (at %s)\n",\
6896             encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
6897          break;
6898       }
6899       else
6900       {
6901          DU_LOG("\nDEBUG  -->  F1AP : Created APER encodedbuffer for UE Capability RAT Container\n");
6902          for(int i=0; i< encBufSize; i++)
6903          {
6904             DU_LOG("%x",encBuf[i]);
6905          }
6906       }
6907
6908       ueCapRatContBuf->size = encBufSize;
6909       CU_ALLOC(ueCapRatContBuf->buf, ueCapRatContBuf->size);
6910       if(!ueCapRatContBuf->buf)
6911       {
6912          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in fillUeCapabilityContainer");
6913          break;
6914       }
6915       memcpy(ueCapRatContBuf->buf, encBuf, ueCapRatContBuf->size);
6916       ret = ROK;
6917       break;
6918    }
6919    freeUeCapRatCont(&ueNrCap);
6920    return ROK;
6921 }
6922
6923 /*******************************************************************
6924  *
6925  * @brief Fill UE Capability RAT container list
6926  *
6927  * @details
6928  *
6929  *    Function : fillUeCapRatContList
6930  *
6931  *    Functionality: Fill UE Capability RAT container list
6932
6933  *
6934  * @params[in] UE capability RAT container list
6935  * @return ROK     - success
6936  *         RFAILED - failure
6937  *
6938  * ****************************************************************/
6939 uint8_t fillUeCapRatContList(UE_CapabilityRAT_ContainerListRRC_t  *ueCapablityList)
6940 {
6941     uint8_t          ret = RFAILED;
6942     uint8_t          idx, elementCnt;
6943
6944     while(true)
6945     {
6946        elementCnt = 1;
6947        ueCapablityList->list.count = elementCnt;
6948        ueCapablityList->list.size = elementCnt * sizeof(UE_CapabilityRAT_Container_t *);
6949
6950        CU_ALLOC(ueCapablityList->list.array, ueCapablityList->list.size);
6951        if(!ueCapablityList->list.array)
6952        {
6953           DU_LOG("\nERROR  -->  Memory allocation failed in fillUeCapRatContList");
6954           ret = RFAILED;
6955           break;
6956        }
6957
6958        for(idx=0; idx<elementCnt; idx++)
6959        {
6960           CU_ALLOC(ueCapablityList->list.array[idx], sizeof(UE_CapabilityRAT_Container_t));
6961           if(ueCapablityList->list.array[idx] == NULLP)
6962           {
6963              DU_LOG("\nERROR  -->  Memory allocation failed in fillUeCapRatContList");
6964              ret = RFAILED;
6965              break;
6966           }
6967        }
6968        idx = 0;
6969        ueCapablityList->list.array[idx]->rat_Type = RAT_Type_nr;
6970        if(fillUeCapRatCont(&ueCapablityList->list.array[idx]->ue_CapabilityRAT_Container) != ROK)
6971        {
6972           DU_LOG("\nERROR  -->  F1AP : Failed to fill UE capability RAT Conatiner");
6973           ret = RFAILED;
6974           break;
6975        }
6976
6977        ret = ROK;
6978        break;
6979     }
6980     return ret;
6981 }
6982
6983 /*******************************************************************
6984  *
6985  * @brief Fill UE Capability RAT container list octet string
6986  *
6987  * @details
6988  *
6989  *    Function : fillUeCapRatContListBuf
6990  *
6991  *    Functionality: Fill UE Capability RAT container list octet string
6992
6993  *
6994  * @params[in] UE capability RAT container list buffer
6995  * @return ROK     - success
6996  *         RFAILED - failure
6997  *
6998  * ****************************************************************/
6999 uint8_t fillUeCapRatContListBuf(UE_CapabilityRAT_ContainerList_t *ueCapablityListBuf)
7000 {
7001    uint8_t          ret = RFAILED;
7002    asn_enc_rval_t   encRetVal;
7003    UE_CapabilityRAT_ContainerListRRC_t  ueCapablityList;
7004
7005    while(true)
7006    {
7007       ret = fillUeCapRatContList(&ueCapablityList);
7008       if(ret != ROK)
7009       {
7010          DU_LOG( "\nERROR  -->  F1AP : Failed to fill UE Capability RAT container list");
7011          break;
7012       }
7013
7014       /* encode UE Capability RAT Container List into duToCuRrcContainer */
7015       xer_fprint(stdout, &asn_DEF_UE_CapabilityRAT_ContainerListRRC, &ueCapablityList);
7016       cmMemset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
7017       encBufSize = 0;
7018       encRetVal = aper_encode(&asn_DEF_UE_CapabilityRAT_ContainerListRRC, 0, \
7019             &ueCapablityList, PrepFinalEncBuf, encBuf);
7020
7021       /* Encode results */
7022       if(encRetVal.encoded == ENCODE_FAIL)
7023       {
7024          DU_LOG( "\nERROR  -->  F1AP : Could not encode UE Capability RAT Container (at %s)\n",\
7025                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
7026          break;
7027       }
7028       else
7029       {
7030          DU_LOG("\nDEBUG  -->  F1AP : Created APER encodedbuffer for UE Capability RAT Container\n");
7031          for(int i=0; i< encBufSize; i++)
7032          {
7033             DU_LOG("%x",encBuf[i]);
7034          }
7035       }
7036
7037       ueCapablityListBuf->size = encBufSize;
7038       CU_ALLOC(ueCapablityListBuf->buf, ueCapablityListBuf->size);
7039       if(!ueCapablityListBuf->buf)
7040       {
7041          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in fillUeCapabilityContainer");
7042          break;
7043       }
7044       memcpy(ueCapablityListBuf->buf, encBuf, ueCapablityListBuf->size);
7045       ret = ROK;
7046       break;
7047    }
7048    freeUeCapRatContList(&ueCapablityList);
7049    return ret;
7050 }
7051
7052 /*******************************************************************
7053  *
7054  * @brief Free Measurement Timing Configuration
7055  *
7056  * @details
7057  *
7058  *    Function : freeMeasuementTimingConfig
7059  *
7060  *    Functionality: Free Measurement Timing Configuration
7061  *
7062  * @params[in] MeasurementTimingConfiguration_IEs_t measTimingCfg
7063  * @return void
7064  *
7065  * ****************************************************************/
7066 void freeMeasuementTimingConfig(MeasurementTimingConfigurationRrc_t measTimingConfig)
7067 {
7068    uint8_t measCfgIdx;
7069    MeasurementTimingConfigurationRrc_IEs_t *measTimingCfg = NULLP;
7070    MeasTiming_t *measTiming = NULLP;
7071
7072    if(measTimingConfig.criticalExtensions.choice.c1)
7073    {
7074       if(measTimingConfig.criticalExtensions.choice.c1->choice.measTimingConf)
7075       {
7076          measTimingCfg = measTimingConfig.criticalExtensions.choice.c1->choice.measTimingConf;
7077          if(measTimingCfg->measTiming)
7078          {
7079             if(measTimingCfg->measTiming->list.array)
7080             {
7081                for(measCfgIdx = 0; measCfgIdx < measTimingCfg->measTiming->list.count; measCfgIdx++)
7082                {
7083                   measTiming = measTimingCfg->measTiming->list.array[measCfgIdx];
7084                   CU_FREE(measTiming->frequencyAndTiming, sizeof(struct MeasTiming__frequencyAndTiming));
7085                   CU_FREE(measTimingCfg->measTiming->list.array[measCfgIdx], sizeof(MeasTiming_t));
7086                }
7087                CU_FREE(measTimingCfg->measTiming->list.array, measTimingCfg->measTiming->list.size);
7088             }
7089             CU_FREE(measTimingCfg->measTiming, sizeof(MeasTimingList_t));
7090          }
7091          CU_FREE(measTimingConfig.criticalExtensions.choice.c1->choice.measTimingConf, sizeof(struct MeasurementTimingConfigurationRrc_IEs));
7092       }
7093       CU_FREE(measTimingConfig.criticalExtensions.choice.c1, sizeof(struct MeasurementTimingConfigurationRrc__criticalExtensions__c1));
7094    }
7095 }
7096
7097 /*******************************************************************
7098  *
7099  * @brief Fill Measurement Timing Configuration
7100  *
7101  * @details
7102  *
7103  *    Function : fillMeasTimingCfg
7104  *
7105  *    Functionality: Fill Measurement Timing Configuration
7106  *
7107  * @params[in] MeasurementTimingConfiguration_IEs_t measTimingCfg
7108  * @return ROK     - success
7109  *         RFAILED - failure
7110  *
7111  * ****************************************************************/
7112 uint8_t fillMeasTimingCfg(MeasurementTimingConfigurationRrc_IEs_t *measTimingCfg)
7113 {
7114    uint8_t elementCnt = 0;
7115    uint8_t measCfgIdx = 0;
7116    MeasTiming_t *measTiming;
7117    SSB_MTC_t *smtc;
7118
7119    CU_ALLOC(measTimingCfg->measTiming, sizeof(MeasTimingList_t));
7120    if(!measTimingCfg->measTiming)
7121    {
7122       DU_LOG( "\nERROR  -->  F1AP : Failed to allocated memory  for measTiming in fillMeasTimingCfg");
7123       return RFAILED;
7124    }
7125
7126    elementCnt = 1;
7127    measTimingCfg->measTiming->list.count = elementCnt;
7128    measTimingCfg->measTiming->list.size = measTimingCfg->measTiming->list.count * sizeof(MeasTiming_t *);
7129    CU_ALLOC(measTimingCfg->measTiming->list.array, measTimingCfg->measTiming->list.size);
7130    if(!measTimingCfg->measTiming->list.array)
7131    {
7132       DU_LOG( "\nERROR  -->  F1AP : Failed to allocated memory for measTiming array in fillMeasTimingCfg");
7133       return RFAILED;
7134    }
7135
7136    for(measCfgIdx = 0; measCfgIdx < measTimingCfg->measTiming->list.count; measCfgIdx++)
7137    {
7138       CU_ALLOC(measTimingCfg->measTiming->list.array[measCfgIdx], sizeof(MeasTiming_t));
7139       if(!measTimingCfg->measTiming->list.array[measCfgIdx])
7140       {
7141          DU_LOG( "\nERROR  -->  F1AP : Failed to allocated memory for measTiming array element in fillMeasTimingCfg");
7142          return RFAILED;
7143       }
7144    }
7145
7146    measCfgIdx = 0;
7147    measTiming = measTimingCfg->measTiming->list.array[measCfgIdx];
7148    CU_ALLOC(measTiming->frequencyAndTiming, sizeof(struct MeasTiming__frequencyAndTiming));
7149    if(!measTiming->frequencyAndTiming)
7150    {
7151       DU_LOG( "\nERROR  -->  F1AP : Failed to allocated memory for frequency and timing IE in fillMeasTimingCfg");
7152       return RFAILED;
7153    }
7154
7155    measTiming->frequencyAndTiming->carrierFreq =  623800; /* This is a randomly chosen value since ARFCN configured in DU is 623400 */
7156    measTiming->frequencyAndTiming->ssbSubcarrierSpacing = SubcarrierSpacing_kHz15;
7157
7158    smtc = &measTiming->frequencyAndTiming->ssb_MeasurementTimingConfiguration;
7159    smtc->periodicityAndOffset.present = SSB_MTC__periodicityAndOffset_PR_sf20;
7160    smtc->periodicityAndOffset.choice.sf20 = 0;
7161    smtc->duration = SSB_MTC__duration_sf1;
7162    return ROK;
7163 }
7164
7165 /*******************************************************************
7166  *
7167  * @brief Fill Measurement Timing Configuration Octet string
7168  *
7169  * @details
7170  *
7171  *    Function : fillMeasConfigBuf
7172  *
7173  *    Functionality: Fill Measurement Timing Configuration Octet string
7174
7175  *
7176  * @params[in] MeasConfig_t *measConfgBuf
7177  * @return ROK     - success
7178  *         RFAILED - failure
7179  *
7180  * ****************************************************************/
7181 uint8_t fillMeasTimingConfigBuf(MeasConfig_t *measTimingConfigBuf)
7182 {
7183    uint8_t          ret = RFAILED;
7184    asn_enc_rval_t   encRetVal;
7185    MeasurementTimingConfigurationRrc_t measTimingConfig;
7186
7187    while(true)
7188    {
7189       measTimingConfig.criticalExtensions.present = MeasurementTimingConfigurationRrc__criticalExtensions_PR_c1;
7190       CU_ALLOC(measTimingConfig.criticalExtensions.choice.c1, sizeof(struct MeasurementTimingConfigurationRrc__criticalExtensions__c1));
7191       if(!measTimingConfig.criticalExtensions.choice.c1)
7192       {
7193          DU_LOG( "\nERROR  -->  F1AP : Failed to allocated memory for measurement configuration extension");
7194          return RFAILED;
7195       }
7196       measTimingConfig.criticalExtensions.choice.c1->present = MeasurementTimingConfigurationRrc__criticalExtensions__c1_PR_measTimingConf;
7197
7198       CU_ALLOC(measTimingConfig.criticalExtensions.choice.c1->choice.measTimingConf, sizeof(struct MeasurementTimingConfigurationRrc_IEs));
7199       if(!measTimingConfig.criticalExtensions.choice.c1->choice.measTimingConf)
7200       {
7201          DU_LOG( "\nERROR  -->  F1AP : Failed to allocated memory for measurement timing configuration IE");
7202          return RFAILED;
7203       }
7204
7205       ret = fillMeasTimingCfg(measTimingConfig.criticalExtensions.choice.c1->choice.measTimingConf);
7206       if(ret != ROK)
7207       {
7208          DU_LOG( "\nERROR  -->  F1AP : Failed to fill measurement timing configuration IE");
7209          break;
7210       }
7211
7212       /* Encode measurement timing configuration into octet string */
7213       xer_fprint(stdout, &asn_DEF_MeasurementTimingConfigurationRrc, &measTimingConfig);
7214       cmMemset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
7215       encBufSize = 0;
7216       encRetVal = aper_encode(&asn_DEF_MeasurementTimingConfigurationRrc, 0, &measTimingConfig, PrepFinalEncBuf, encBuf);
7217
7218       /* Encode results */
7219       if(encRetVal.encoded == ENCODE_FAIL)
7220       {
7221          DU_LOG( "\nERROR  -->  F1AP : Could not encode Measurement Timing Configuration (at %s)\n",\
7222                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
7223          break;
7224       }
7225       else
7226       {
7227          DU_LOG("\nDEBUG  -->  F1AP : Created APER encodedbuffer for Measurement timing configuration\n");
7228          for(int i=0; i< encBufSize; i++)
7229          {
7230             DU_LOG("%x",encBuf[i]);
7231          }
7232       }
7233
7234       measTimingConfigBuf->size = encBufSize;
7235       CU_ALLOC(measTimingConfigBuf->buf, measTimingConfigBuf->size);
7236       if(!measTimingConfigBuf->buf)
7237       {
7238          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed fillMeasTimingConfigBuf");
7239          break;
7240       }
7241       memcpy(measTimingConfigBuf->buf, encBuf, measTimingConfigBuf->size);
7242       ret = ROK;
7243       break;
7244    }
7245    freeMeasuementTimingConfig(measTimingConfig);
7246    return ret;
7247 }
7248
7249 /******************************************************************
7250  *
7251  * @brief Free RRC reconfiguration non-critical extension
7252  *
7253  * @details
7254  *
7255  *    Function : freeRrcReconfigNonCriticalExt
7256  *
7257  *    Functionality: Free RRC reconfiguration non-critical extension
7258  *
7259  * @params[in] RRC reconfiguration IE
7260  * @return void
7261  *
7262  * ****************************************************************/
7263 void freeRrcReconfigNonCriticalExt(RRCReconfiguration_v1530_IEs_t *rrcRecfg)
7264 {
7265    if(rrcRecfg->masterCellGroup)
7266    {
7267       CU_FREE(rrcRecfg->masterCellGroup, sizeof(OCTET_STRING_t));
7268    }
7269 }
7270
7271 /******************************************************************
7272  *
7273  * @brief Free measurement object addmod list
7274  *
7275  * @details
7276  *
7277  *    Function : freeMeasObjToAddModList
7278  *
7279  *    Functionality: Free measurement object add mod list
7280  *
7281  * @params[in] Measurement object add/mod list
7282  * @return void
7283  *
7284  * ****************************************************************/
7285 void freeMeasObjToAddModList(MeasObjectToAddModList_t *measObjList)
7286 {
7287    uint8_t objIdx;
7288    MeasObjectNR_t *measObject;
7289
7290    if(measObjList->list.array)
7291    {
7292       for(objIdx = 0; objIdx < measObjList->list.size; objIdx++)
7293       {
7294          if(measObjList->list.array[objIdx])
7295          {
7296             if(measObjList->list.array[objIdx]->measObject.choice.measObjectNR)
7297             {
7298                measObject = measObjList->list.array[objIdx]->measObject.choice.measObjectNR;
7299                CU_FREE(measObject->ssbFrequency, sizeof(ARFCN_ValueNR_t));
7300                CU_FREE(measObject->ssbSubcarrierSpacing, sizeof(SubcarrierSpacing_t));
7301                CU_FREE(measObject->smtc1 , sizeof(SSB_MTC_t));
7302                if(measObject->absThreshSS_BlocksConsolidation)
7303                {
7304                   CU_FREE(measObject->absThreshSS_BlocksConsolidation->thresholdRSRP, sizeof(RSRP_Range_t));
7305                   CU_FREE(measObject->absThreshSS_BlocksConsolidation->thresholdRSRQ, sizeof(RSRQ_Range_t));
7306                   CU_FREE(measObject->absThreshSS_BlocksConsolidation->thresholdSINR, sizeof(SINR_Range_t));
7307                   CU_FREE(measObject->absThreshSS_BlocksConsolidation, sizeof(ThresholdNR_t));
7308                }
7309                CU_FREE(measObject->nrofSS_BlocksToAverage, sizeof(long));
7310                CU_FREE(measObject->offsetMO.rsrpOffsetSSB, sizeof(Q_OffsetRange_t));
7311                CU_FREE(measObject->offsetMO.rsrqOffsetSSB, sizeof(Q_OffsetRange_t));
7312                CU_FREE(measObject->offsetMO.sinrOffsetSSB, sizeof(Q_OffsetRange_t));
7313                CU_FREE(measObjList->list.array[objIdx]->measObject.choice.measObjectNR, sizeof(MeasObjectNR_t));
7314             }
7315             CU_FREE(measObjList->list.array[objIdx], sizeof(MeasObjectToAddMod_t));
7316          }
7317       }
7318       CU_FREE(measObjList->list.array, measObjList->list.size);
7319    }
7320 }
7321
7322 /******************************************************************
7323  *
7324  * @brief Free report config add mod list
7325  *
7326  * @details
7327  *
7328  *    Function : freeReportCfgToAddModList
7329  *
7330  *    Functionality: Free report config add mod list
7331  *
7332  * @params[in] Report config list
7333  * @return void
7334  *
7335  * ****************************************************************/
7336 void freeReportCfgToAddModList(ReportConfigToAddModList_t *reportCfgList)
7337 {
7338    uint8_t reportCfgIdx;
7339    ReportConfigToAddMod_t *reportCfg;
7340    ReportConfigNR_t *reportCfgNr;
7341    EventTriggerConfig_t *eventTriggCfg;
7342
7343    if(reportCfgList->list.array)
7344    {
7345       for(reportCfgIdx=0; reportCfgIdx < reportCfgList->list.count; reportCfgIdx++)
7346       {
7347          if(reportCfgList->list.array[reportCfgIdx])
7348          {
7349             reportCfg = reportCfgList->list.array[reportCfgIdx];
7350             if(reportCfg->reportConfig.choice.reportConfigNR)
7351             {
7352                reportCfgNr = reportCfg->reportConfig.choice.reportConfigNR;
7353                if(reportCfgNr->reportType.choice.eventTriggered)
7354                {
7355                   eventTriggCfg = reportCfgNr->reportType.choice.eventTriggered;
7356                   CU_FREE(eventTriggCfg->eventId.choice.eventA3, sizeof(struct EventTriggerConfig__eventId__eventA3));
7357                   CU_FREE(eventTriggCfg->reportQuantityRS_Indexes, sizeof(MeasReportQuantity_t));
7358                   CU_FREE(eventTriggCfg->maxNrofRS_IndexesToReport, sizeof(long));
7359                   CU_FREE(reportCfgNr->reportType.choice.eventTriggered, sizeof(EventTriggerConfig_t));
7360                }
7361             }
7362          }
7363          CU_FREE(reportCfgList->list.array[reportCfgIdx], sizeof(ReportConfigToAddMod_t));
7364       }
7365       CU_FREE(reportCfgList->list.array, reportCfgList->list.size);
7366    }
7367 }
7368
7369 /******************************************************************
7370  *
7371  * @brief Free measurement id to add mod list
7372  *
7373  * @details
7374  *
7375  *    Function : freeMeasIdToAddModList
7376  *
7377  *    Functionality: Free measurement id to add mod list
7378  *
7379  * @params[in] Measurement id to add mod list
7380  * @return void
7381  *
7382  * ****************************************************************/
7383 void freeMeasIdToAddModList(MeasIdToAddModList_t *measIdList)
7384 {
7385    uint8_t measIdIdx;
7386    if(measIdList->list.array)
7387    {
7388       for(measIdIdx=0; measIdIdx < measIdList->list.count; measIdIdx++)
7389       {
7390          CU_FREE(measIdList->list.array[measIdIdx], sizeof(MeasIdToAddMod_t));
7391       }
7392       CU_FREE(measIdList->list.array, measIdList->list.size);
7393    }
7394 }
7395
7396 /*******************************************************************
7397  *
7398  * @brief Free quantity config
7399  *
7400  * @details
7401  *
7402  *    Function : freeQunatityConfig
7403  *
7404  *    Functionality: Free quantity config
7405  *
7406  * @params[in] Quantity Config
7407  * @return void
7408  *
7409  * ****************************************************************/
7410 void freeQuantityConfig(QuantityConfig_t *quantityCfg)
7411 {
7412    uint8_t quanCfgIdx;
7413    QuantityConfigNR_t *quantityCfgNr;
7414
7415    if(quantityCfg->quantityConfigNR_List)
7416    {
7417       if(quantityCfg->quantityConfigNR_List->list.array)
7418       {
7419          for(quanCfgIdx = 0; quanCfgIdx < quantityCfg->quantityConfigNR_List->list.count; quanCfgIdx++)
7420          {
7421             if(quantityCfg->quantityConfigNR_List->list.array[quanCfgIdx])
7422             {
7423                quantityCfgNr = quantityCfg->quantityConfigNR_List->list.array[quanCfgIdx];
7424                CU_FREE(quantityCfgNr->quantityConfigCell.ssb_FilterConfig.filterCoefficientRSRP, sizeof(FilterCoefficient_t));
7425                CU_FREE(quantityCfgNr->quantityConfigCell.ssb_FilterConfig.filterCoefficientRSRQ, sizeof(FilterCoefficient_t));
7426                CU_FREE(quantityCfgNr->quantityConfigCell.ssb_FilterConfig.filterCoefficientRS_SINR, sizeof(FilterCoefficient_t));
7427                if(quantityCfgNr->quantityConfigRS_Index)
7428                {
7429                   CU_FREE(quantityCfgNr->quantityConfigRS_Index->ssb_FilterConfig.filterCoefficientRSRP, sizeof(FilterCoefficient_t));
7430                   CU_FREE(quantityCfgNr->quantityConfigRS_Index->ssb_FilterConfig.filterCoefficientRSRQ, sizeof(FilterCoefficient_t));
7431                   CU_FREE(quantityCfgNr->quantityConfigRS_Index->ssb_FilterConfig.filterCoefficientRS_SINR, sizeof(FilterCoefficient_t));
7432                   CU_FREE(quantityCfgNr->quantityConfigRS_Index, sizeof(QuantityConfigRS_t));
7433                }
7434                CU_FREE(quantityCfg->quantityConfigNR_List->list.array[quanCfgIdx], sizeof(QuantityConfigNR_t));
7435             }
7436          }
7437          CU_FREE(quantityCfg->quantityConfigNR_List->list.array, quantityCfg->quantityConfigNR_List->list.size);
7438       }
7439       CU_FREE(quantityCfg->quantityConfigNR_List, sizeof(struct QuantityConfig__quantityConfigNR_List));
7440    }
7441 }
7442
7443 /******************************************************************
7444  *
7445  * @brief Free measurement Config
7446  *
7447  * @details
7448  *
7449  *    Function : freeMeasConfig
7450  *
7451  *    Functionality: Free measurement config
7452  *
7453  * @params[in] Measurement config
7454  * @return void
7455  *
7456  * ****************************************************************/
7457 void freeMeasConfig(MeasConfigRrc_t *measConfig)
7458 {
7459    if(measConfig->measObjectToAddModList)
7460    {
7461       freeMeasObjToAddModList(measConfig->measObjectToAddModList);
7462       CU_FREE(measConfig->measObjectToAddModList, sizeof(MeasObjectToAddModList_t));
7463    }
7464    if(measConfig->reportConfigToAddModList)
7465    {
7466       freeReportCfgToAddModList(measConfig->reportConfigToAddModList);
7467       CU_FREE(measConfig->reportConfigToAddModList, sizeof(ReportConfigToAddModList_t));
7468    }
7469    if(measConfig->measIdToAddModList)
7470    {
7471       freeMeasIdToAddModList(measConfig->measIdToAddModList);
7472       CU_FREE(measConfig->measIdToAddModList, sizeof(MeasIdToAddModList_t));
7473    }
7474    if(measConfig->s_MeasureConfig)
7475    {
7476       CU_FREE(measConfig->s_MeasureConfig, sizeof(struct MeasConfigRrc__s_MeasureConfig));
7477    }
7478    if(measConfig->quantityConfig)
7479    {
7480       freeQuantityConfig(measConfig->quantityConfig);
7481       CU_FREE(measConfig->quantityConfig, sizeof(QuantityConfig_t));
7482    }
7483 }
7484 /******************************************************************
7485  *
7486  * @brief Free DRB to AddMod List
7487  *
7488  * @details
7489  *
7490  *    Function : freeDrbToAddModList
7491  *
7492  *    Functionality: Free SRB to AddMod List
7493  *
7494  * @params[in] SBR to add/mod list
7495  * @return void
7496  *
7497  * ****************************************************************/
7498 void freeDrbToAddModList(DRB_ToAddModList_t *drbToAddList)
7499 {
7500    uint8_t drbIdx;
7501    if(drbToAddList->list.array)
7502    {
7503       for(drbIdx = 0; drbIdx < drbToAddList->list.count; drbIdx++)
7504       {
7505          if(drbToAddList->list.array[drbIdx]->pdcp_Config)
7506          {
7507             if(drbToAddList->list.array[drbIdx]->pdcp_Config->drb)
7508             {
7509                CU_FREE(drbToAddList->list.array[drbIdx]->pdcp_Config->drb->discardTimer, sizeof(long));
7510                CU_FREE(drbToAddList->list.array[drbIdx]->pdcp_Config->drb->pdcp_SN_SizeUL, sizeof(long));
7511                CU_FREE(drbToAddList->list.array[drbIdx]->pdcp_Config->drb->pdcp_SN_SizeDL, sizeof(long));
7512                CU_FREE(drbToAddList->list.array[drbIdx]->pdcp_Config->drb, sizeof(struct PDCP_Config__drb));
7513             }
7514             CU_FREE(drbToAddList->list.array[drbIdx]->pdcp_Config->t_Reordering, sizeof(long));
7515             CU_FREE(drbToAddList->list.array[drbIdx]->pdcp_Config, sizeof(PDCP_Config_t));
7516          }
7517          CU_FREE(drbToAddList->list.array[drbIdx], sizeof(DRB_ToAddMod_t));
7518       }
7519       CU_FREE(drbToAddList->list.array, drbToAddList->list.size);
7520    }
7521 }
7522
7523 /******************************************************************
7524  *
7525  * @brief Free SRB to AddMod List
7526  *
7527  * @details
7528  *
7529  *    Function : freeSrbToAddModList
7530  *
7531  *    Functionality: Free SRB to AddMod List
7532  *
7533  * @params[in] SBR to add/mod list
7534  * @return void
7535  *
7536  * ****************************************************************/
7537 void freeSrbToAddModList(SRB_ToAddModList_t *srbToAddList)
7538 {
7539    uint8_t srbIdx;
7540    if(srbToAddList->list.array)
7541    {
7542       for(srbIdx = 0; srbIdx < srbToAddList->list.count; srbIdx++)
7543       {
7544          CU_FREE(srbToAddList->list.array[srbIdx]->reestablishPDCP, sizeof(long));
7545          if(srbToAddList->list.array[srbIdx]->pdcp_Config)
7546          {
7547             CU_FREE(srbToAddList->list.array[srbIdx]->pdcp_Config->t_Reordering, sizeof(long));
7548             CU_FREE(srbToAddList->list.array[srbIdx]->pdcp_Config, sizeof(PDCP_Config_t));
7549          }
7550
7551          CU_FREE(srbToAddList->list.array[srbIdx], sizeof(SRB_ToAddMod_t));
7552       }
7553       CU_FREE(srbToAddList->list.array, srbToAddList->list.size);
7554    }
7555 }
7556
7557 /******************************************************************
7558  *
7559  * @brief Free Radio Bearer Config
7560  *
7561  * @details
7562  *
7563  *    Function : fillRadioBearerConfig
7564  *
7565  *    Functionality: Free Radio Bearer config
7566  *
7567  * @params[in] Radio bearer config
7568  * @return void
7569  *
7570  * ****************************************************************/
7571 void freeRadioBearerConfig(RadioBearerConfig_t *radioBearerConfig)
7572 {
7573    if(radioBearerConfig->srb_ToAddModList)
7574    {
7575       freeSrbToAddModList(radioBearerConfig->srb_ToAddModList);
7576       CU_FREE(radioBearerConfig->srb_ToAddModList, sizeof(SRB_ToAddModList_t));
7577    }
7578    if(radioBearerConfig->drb_ToAddModList)
7579    {
7580       freeDrbToAddModList(radioBearerConfig->drb_ToAddModList);
7581       CU_FREE(radioBearerConfig->drb_ToAddModList, sizeof(DRB_ToAddModList_t));
7582    }
7583 }
7584
7585 /******************************************************************
7586  *
7587  * @brief Free reconfiguration message
7588  *
7589  * @details
7590  *
7591  *    Function : freeRrcReconfig
7592  *
7593  *    Functionality: Free reconfiguration message
7594  *
7595  * @params[in] RRC Reconfiguration message
7596  * @return void
7597  *
7598  * ****************************************************************/
7599 void freeRrcReconfig(RRCReconfiguration_t *rrcReconfig)
7600 {
7601    if(rrcReconfig->criticalExtensions.choice.rrcReconfiguration)
7602    {
7603       if(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->radioBearerConfig)
7604       {
7605          freeRadioBearerConfig(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->radioBearerConfig);
7606          CU_FREE(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->radioBearerConfig, sizeof(RadioBearerConfig_t));
7607       }
7608       if(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->measConfig)
7609       {
7610          freeMeasConfig(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->measConfig);
7611          CU_FREE(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->measConfig, sizeof(MeasConfigRrc_t));
7612       }
7613       if(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->nonCriticalExtension)
7614       {
7615          freeRrcReconfigNonCriticalExt(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->nonCriticalExtension);
7616          CU_FREE(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->nonCriticalExtension, sizeof(struct RRCReconfiguration_v1530_IEs));
7617       }
7618       CU_FREE(rrcReconfig->criticalExtensions.choice.rrcReconfiguration, sizeof(RRCReconfiguration_IEs_t));
7619    }
7620 }
7621
7622 /******************************************************************
7623  *
7624  * @brief Fill SRB To Add Mod list
7625  *
7626  * @details
7627  *
7628  *    Function : fillSrbToAddModList
7629  *
7630  *    Functionality: fill SRB to Add Mod list
7631  *
7632  * @params[in] UE control block
7633  *             SRB to Add/Mod list
7634  * @return ROK     - success
7635  *         RFAILED - failure
7636  *
7637  * ****************************************************************/
7638 uint8_t fillSrbToAddModList(CuUeCb *ueCb, SRB_ToAddModList_t *srbToAddList, bool updateAllRbCfg)
7639 {
7640    uint8_t srbIdx, srbDbIdx, elementCnt = 0;
7641
7642    if(updateAllRbCfg)
7643       elementCnt = ueCb->numSrb;
7644    else
7645    {
7646       for(srbDbIdx=0; srbDbIdx < ueCb->numSrb; srbDbIdx++)
7647       {
7648          if(ueCb->srbList[srbDbIdx].cfgSentToUe == false)
7649             elementCnt++;
7650       }
7651    }
7652
7653    if(!elementCnt)
7654    {
7655       DU_LOG("INFO  --> F1AP : No SRB available to add or modify");
7656       return ROK;
7657    }
7658
7659    CU_ALLOC(srbToAddList, sizeof(SRB_ToAddModList_t));
7660    if(!srbToAddList)
7661    {
7662       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for SRB to AddMod List in fillRadioBearerConfig");
7663       return RFAILED;
7664    }
7665    srbToAddList->list.count = elementCnt;
7666    srbToAddList->list.size = srbToAddList->list.count * sizeof(SRB_ToAddMod_t *);
7667
7668    CU_ALLOC(srbToAddList->list.array, srbToAddList->list.size);
7669    if(!srbToAddList->list.array)
7670    {
7671       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for SRB to AddMod list array in fillSrbToAddModList");
7672       return RFAILED;
7673    }
7674
7675    srbIdx = 0;
7676    for(srbDbIdx = 0; srbDbIdx < ueCb->numSrb; srbDbIdx++)
7677    {
7678       if(!updateAllRbCfg && ueCb->srbList[srbDbIdx].cfgSentToUe)
7679          continue;
7680
7681       CU_ALLOC(srbToAddList->list.array[srbIdx], sizeof(SRB_ToAddMod_t));
7682       if(!srbToAddList->list.array[srbIdx])
7683       {
7684          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for SRB to AddMod list element in fillSrbToAddModList");
7685          return RFAILED;
7686       }
7687
7688       srbToAddList->list.array[srbIdx]->srb_Identity = ueCb->srbList[srbDbIdx].srbId;
7689
7690       /* Reestablish PDCP */
7691       CU_ALLOC(srbToAddList->list.array[srbIdx]->reestablishPDCP, sizeof(long));
7692       if(!srbToAddList->list.array[srbIdx]->reestablishPDCP)
7693       {
7694          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for reestablish PDCP IE in fillSrbToAddModList");
7695          return RFAILED;
7696       }
7697       *(srbToAddList->list.array[srbIdx]->reestablishPDCP) = SRB_ToAddMod__reestablishPDCP_true;
7698
7699       /* PDCP configuration */
7700       CU_ALLOC(srbToAddList->list.array[srbIdx]->pdcp_Config, sizeof(PDCP_Config_t));
7701       if(!srbToAddList->list.array[srbIdx]->pdcp_Config)
7702       {
7703          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for PDCP config IE in fillSrbToAddModList");
7704          return RFAILED;
7705       }
7706
7707       /* Reordering timer */
7708       CU_ALLOC(srbToAddList->list.array[srbIdx]->pdcp_Config->t_Reordering, sizeof(long));
7709       if(!srbToAddList->list.array[srbIdx]->pdcp_Config->t_Reordering)
7710       {
7711          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for reordering timer in fillSrbToAddModList");
7712          return RFAILED;
7713       }
7714       *(srbToAddList->list.array[srbIdx]->pdcp_Config->t_Reordering) = PDCP_Config__t_Reordering_ms40;
7715
7716       srbIdx++;
7717    }
7718    return ROK;
7719 }
7720
7721 /******************************************************************
7722  *
7723  * @biief Fill DRBeTo Add Mod list
7724  *
7725  * @details
7726  *
7727  *    Function : fillDrbToAddModList
7728  *
7729  *    Functionality: fill DRB to Add Mod list
7730  *
7731  * @params[in] UE control block
7732  *             DRB to Add/Mod list
7733  * @return ROK     - success
7734  *         RFAILED - failure
7735  *
7736  * ****************************************************************/
7737 uint8_t fillDrbToAddModList(CuUeCb *ueCb, DRB_ToAddModList_t *drbToAddList, bool updateAllRbCfg)
7738 {
7739    uint8_t drbIdx, drbDbIdx, elementCnt = 0;
7740
7741    if(updateAllRbCfg)
7742       elementCnt = ueCb->numDrb;
7743    else
7744    {
7745       for(drbDbIdx=0; drbDbIdx < ueCb->numDrb; drbDbIdx++)
7746       {
7747          if(ueCb->drbList[drbDbIdx].cfgSentToUe == false)
7748             elementCnt++;
7749       }
7750    }
7751
7752    if(!elementCnt)
7753    {
7754       DU_LOG("INFO  --> F1AP : No DRB available to add or modify");
7755       return ROK;
7756    }
7757
7758    /* DRB To Add/Mod List */
7759    CU_ALLOC(drbToAddList, sizeof(DRB_ToAddModList_t));
7760    if(!drbToAddList)
7761    {
7762       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for DRB to AddMod List in fillRadioBearerConfig");
7763       return RFAILED;
7764    }
7765
7766    drbToAddList->list.count = elementCnt;
7767    drbToAddList->list.size = drbToAddList->list.count * sizeof(DRB_ToAddMod_t *);
7768
7769    CU_ALLOC(drbToAddList->list.array, drbToAddList->list.size);
7770    if(!drbToAddList->list.array)
7771    {
7772       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for DRB to AddMod list array in fillDrbToAddModList");
7773       return RFAILED;
7774    }
7775
7776    drbIdx = 0;
7777    for(drbDbIdx=0; drbDbIdx < ueCb->numDrb; drbDbIdx++)
7778    {
7779       if(!updateAllRbCfg && ueCb->drbList[drbDbIdx].cfgSentToUe)
7780          continue;
7781
7782       CU_ALLOC(drbToAddList->list.array[drbIdx], sizeof(DRB_ToAddMod_t));
7783       if(!drbToAddList->list.array[drbIdx])
7784       {
7785          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for DRB to AddMod list elements in fillDrbToAddModList");
7786          return RFAILED;
7787       }
7788
7789       /* DRB Id */
7790       drbToAddList->list.array[drbIdx]->drb_Identity = ueCb->drbList[drbDbIdx].drbId;
7791
7792       /* PDCP Config */
7793       CU_ALLOC(drbToAddList->list.array[drbIdx]->pdcp_Config, sizeof(PDCP_Config_t));
7794       if(!drbToAddList->list.array[drbIdx]->pdcp_Config)
7795       {
7796          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for PDCP config IE in fillDrbToAddModList");
7797          return RFAILED;
7798       }
7799
7800       /* PDCP Config -> DRB */
7801       CU_ALLOC(drbToAddList->list.array[drbIdx]->pdcp_Config->drb, sizeof(struct PDCP_Config__drb));
7802       if(!drbToAddList->list.array[drbIdx]->pdcp_Config->drb)
7803       {
7804          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for PDCP config drb in fillDrbToAddModList");
7805          return RFAILED;
7806       }
7807
7808       /* DRB -> Discard Timer */
7809       CU_ALLOC(drbToAddList->list.array[drbIdx]->pdcp_Config->drb->discardTimer, sizeof(long));
7810       if(!drbToAddList->list.array[drbIdx]->pdcp_Config->drb->discardTimer)
7811       {
7812          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for DRB discard timer in fillDrbToAddModList");
7813          return RFAILED;
7814       }
7815       *(drbToAddList->list.array[drbIdx]->pdcp_Config->drb->discardTimer) = PDCP_Config__drb__discardTimer_infinity;
7816
7817       /* UL PDCP SN length */
7818       CU_ALLOC(drbToAddList->list.array[drbIdx]->pdcp_Config->drb->pdcp_SN_SizeUL, sizeof(long));
7819       if(!drbToAddList->list.array[drbIdx]->pdcp_Config->drb->pdcp_SN_SizeUL)
7820       {
7821          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for UL SN length in fillDrbToAddModList");
7822          return RFAILED;
7823       }
7824       *(drbToAddList->list.array[drbIdx]->pdcp_Config->drb->pdcp_SN_SizeUL) = PDCP_Config__drb__pdcp_SN_SizeUL_len12bits;
7825
7826       /* DL PDCP SN length */
7827       CU_ALLOC(drbToAddList->list.array[drbIdx]->pdcp_Config->drb->pdcp_SN_SizeDL, sizeof(long));
7828       if(!drbToAddList->list.array[drbIdx]->pdcp_Config->drb->pdcp_SN_SizeDL)
7829       {
7830          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for DL SN length in fillDrbToAddModList");
7831          return RFAILED;
7832       }
7833       *(drbToAddList->list.array[drbIdx]->pdcp_Config->drb->pdcp_SN_SizeDL) = PDCP_Config__drb__pdcp_SN_SizeDL_len12bits;
7834
7835       /* Header Compression */
7836       drbToAddList->list.array[drbIdx]->pdcp_Config->drb->headerCompression.present = PDCP_Config__drb__headerCompression_PR_notUsed;
7837        drbToAddList->list.array[drbIdx]->pdcp_Config->drb->headerCompression.choice.notUsed = NULLP;
7838
7839       /* Reordering timer */
7840       CU_ALLOC(drbToAddList->list.array[drbIdx]->pdcp_Config->t_Reordering, sizeof(long));
7841       if(!drbToAddList->list.array[drbIdx]->pdcp_Config->t_Reordering)
7842       {
7843          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for reordering timer in fillDrbToAddModList");
7844          return RFAILED;
7845       }
7846       *(drbToAddList->list.array[drbIdx]->pdcp_Config->t_Reordering) = PDCP_Config__t_Reordering_ms40;
7847
7848       drbIdx++;
7849    }
7850
7851    return ROK;
7852 }
7853
7854 /******************************************************************
7855  *
7856  * @brief Fill Radio bearer configuration
7857  *
7858  * @details
7859  *
7860  *    Function : fillRadioBearerConfig
7861  *
7862  *    Functionality: Fill Radio bearer configuration
7863  *
7864  * @params[in] UE control block
7865  *             Radio bearer config pointer
7866  * @return ROK     - success
7867  *         RFAILED - failure
7868  *
7869  * ****************************************************************/
7870 uint8_t fillRadioBearerConfig(CuUeCb *ueCb, RadioBearerConfig_t *radioBearerConfig, bool updateAllRbCfg)
7871 {
7872    /* SRB To Add/Mod List */
7873    if(fillSrbToAddModList(ueCb, radioBearerConfig->srb_ToAddModList, updateAllRbCfg) != ROK)
7874    {
7875       return RFAILED;
7876    }
7877
7878    if(fillDrbToAddModList(ueCb, radioBearerConfig->drb_ToAddModList, updateAllRbCfg) != ROK)
7879    {
7880       return RFAILED;
7881    }
7882
7883    return ROK;
7884 }
7885
7886 /*******************************************************************
7887  *
7888  * @brief Fill measurement object to add/mod list
7889  *
7890  * @details
7891  *
7892  *    Function : fillMeasObjToAddModList
7893  *
7894  *    Functionality: Fill measurement object to add/mod list
7895  *
7896  * @params[in] Measurement object to add/mod list
7897  * @return ROK     - success
7898  *         RFAILED - failure
7899  *
7900  * ****************************************************************/
7901 uint8_t fillMeasObjToAddModList(MeasObjectToAddModList_t *measObjList)
7902 {
7903    uint8_t elementCnt, objIdx;
7904    MeasObjectNR_t *measObject;
7905
7906    elementCnt = 1;
7907    measObjList->list.count = elementCnt;
7908    measObjList->list.size = measObjList->list.count * sizeof(MeasObjectToAddMod_t *);
7909
7910    CU_ALLOC(measObjList->list.array, measObjList->list.size);
7911    if(!measObjList->list.array)
7912    {
7913       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for measurement object list's array");
7914       return RFAILED;
7915    }
7916
7917    for(objIdx = 0; objIdx < measObjList->list.size; objIdx++)
7918    {
7919       CU_ALLOC(measObjList->list.array[objIdx], sizeof(MeasObjectToAddMod_t));
7920       if(!measObjList->list.array[objIdx])
7921       {
7922          DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for measurement object list's array element");
7923          return RFAILED;
7924       }
7925    }
7926
7927    objIdx = 0;
7928    measObjList->list.array[objIdx]->measObjectId = 1;
7929    measObjList->list.array[objIdx]->measObject.present = MeasObjectToAddMod__measObject_PR_measObjectNR;
7930    CU_ALLOC(measObjList->list.array[objIdx]->measObject.choice.measObjectNR, sizeof(MeasObjectNR_t));
7931    if(!measObjList->list.array[objIdx]->measObject.choice.measObjectNR)
7932    {
7933       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for mesurement object NR");
7934       return RFAILED;
7935    }
7936
7937    measObject = measObjList->list.array[objIdx]->measObject.choice.measObjectNR;
7938
7939    /* SSB frequency */
7940    CU_ALLOC(measObject->ssbFrequency, sizeof(ARFCN_ValueNR_t));
7941    if(!measObject->ssbFrequency)
7942    {
7943       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for SSB frequency in fillMeasObjToAddModList");
7944       return RFAILED;
7945    }
7946    *(measObject->ssbFrequency) = 620736; /* Value picked from reference PCAP logs */
7947
7948    /* Subcarrier spacing */
7949    CU_ALLOC(measObject->ssbSubcarrierSpacing, sizeof(SubcarrierSpacing_t));
7950    if(!measObject->ssbSubcarrierSpacing)
7951    {
7952       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for SSB subcarrier spacing in fillMeasObjToAddModList");
7953       return RFAILED;
7954    }
7955    *(measObject->ssbSubcarrierSpacing) = SubcarrierSpacing_kHz15;
7956
7957    /* SMTC1 */
7958    CU_ALLOC(measObject->smtc1 , sizeof(SSB_MTC_t));
7959    if(!measObject->smtc1)
7960    {
7961       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for SMTC1 in fillMeasObjToAddModList");
7962       return RFAILED;
7963    }
7964    measObject->smtc1->duration = SSB_MTC__duration_sf1;
7965    measObject->smtc1->periodicityAndOffset.present = SSB_MTC__periodicityAndOffset_PR_sf20;
7966    measObject->smtc1->periodicityAndOffset.choice.sf20 = 0;
7967
7968    /* Absoulute threshold SSB consolidation */
7969    CU_ALLOC(measObject->absThreshSS_BlocksConsolidation, sizeof(ThresholdNR_t));
7970    if(!measObject->absThreshSS_BlocksConsolidation)
7971    {
7972       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for absolute threshold SSB consolidation in fillMeasObjToAddModList");
7973       return RFAILED;
7974    }
7975
7976    /* RSRP threshold */
7977    CU_ALLOC(measObject->absThreshSS_BlocksConsolidation->thresholdRSRP, sizeof(RSRP_Range_t));
7978    if(!measObject->absThreshSS_BlocksConsolidation->thresholdRSRP)
7979    {
7980       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for threshold RSRP in fillMeasObjToAddModList");
7981       return RFAILED;
7982    }
7983    *(measObject->absThreshSS_BlocksConsolidation->thresholdRSRP) = 1;
7984
7985    /* RSRQ threshold */
7986    CU_ALLOC(measObject->absThreshSS_BlocksConsolidation->thresholdRSRQ, sizeof(RSRQ_Range_t));
7987    if(!measObject->absThreshSS_BlocksConsolidation->thresholdRSRQ)
7988    {
7989       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for threshold RSRQ in fillMeasObjToAddModList");
7990       return RFAILED;
7991    }
7992    *(measObject->absThreshSS_BlocksConsolidation->thresholdRSRQ) = 1;
7993
7994    /* SINR threshold */
7995    CU_ALLOC(measObject->absThreshSS_BlocksConsolidation->thresholdSINR, sizeof(SINR_Range_t));
7996    if(!measObject->absThreshSS_BlocksConsolidation->thresholdSINR)
7997    {
7998       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for threshold SINR in fillMeasObjToAddModList");
7999       return RFAILED;
8000    }
8001    *(measObject->absThreshSS_BlocksConsolidation->thresholdSINR) = 1;
8002
8003    /* Number of SSBs to average */
8004    CU_ALLOC(measObject->nrofSS_BlocksToAverage, sizeof(long));
8005    if(!measObject->nrofSS_BlocksToAverage)
8006    {
8007       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for number of SSB to average in fillMeasObjToAddModList");
8008       return RFAILED;
8009    }
8010    *(measObject->nrofSS_BlocksToAverage) = 2;
8011
8012    /* Quantity Config index */
8013    measObject->quantityConfigIndex = 1;
8014
8015    /* Offset MO */
8016    /* RSRP offset for SSB */
8017    CU_ALLOC(measObject->offsetMO.rsrpOffsetSSB, sizeof(Q_OffsetRange_t));
8018    if(!measObject->offsetMO.rsrpOffsetSSB)
8019    {
8020       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for SSB RSRP offset in fillMeasObjToAddModList");
8021       return RFAILED;
8022    }
8023    *(measObject->offsetMO.rsrpOffsetSSB) = Q_OffsetRange_dB0;
8024
8025    /* RSRQ offset for SSB */
8026    CU_ALLOC(measObject->offsetMO.rsrqOffsetSSB, sizeof(Q_OffsetRange_t));
8027    if(!measObject->offsetMO.rsrpOffsetSSB)
8028    {
8029       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for SSB RSRQ offset in fillMeasObjToAddModList");
8030       return RFAILED;
8031    }
8032    *(measObject->offsetMO.rsrqOffsetSSB) = Q_OffsetRange_dB0;
8033
8034    /* SINR offset for SSB */
8035    CU_ALLOC(measObject->offsetMO.sinrOffsetSSB, sizeof(Q_OffsetRange_t));
8036    if(!measObject->offsetMO.sinrOffsetSSB)
8037    {
8038       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for SSB SINR offset in fillMeasObjToAddModList");
8039       return RFAILED;
8040    }
8041    *(measObject->offsetMO.sinrOffsetSSB) = Q_OffsetRange_dB0;
8042
8043    return ROK;
8044 }
8045
8046 /*******************************************************************
8047  *
8048  * @brief Fill Report configuration to Add/mod list
8049  *
8050  * @details
8051  *
8052  *    Function : fillReportCfgToAddModList
8053  *
8054  *    Functionality: Fill Report configuration to Add/mod list
8055  *
8056  * @params[in] Report Config To Add/Mod List
8057  * @return ROK     - success
8058  *         RFAILED - failure
8059  *
8060  * ****************************************************************/
8061 uint8_t fillReportCfgToAddModList(ReportConfigToAddModList_t *reportCfgList)
8062 {
8063    uint8_t elementCnt;
8064    uint8_t reportCfgIdx;
8065    ReportConfigToAddMod_t *reportCfg;
8066    ReportConfigNR_t *reportCfgNr;
8067    EventTriggerConfig_t *eventTriggCfg;
8068
8069    elementCnt = 1;
8070    reportCfgList->list.count = elementCnt;
8071    reportCfgList->list.size = reportCfgList->list.count * sizeof(ReportConfigToAddMod_t *);
8072
8073    CU_ALLOC(reportCfgList->list.array, reportCfgList->list.size);
8074    if(!reportCfgList->list.array)
8075    {
8076       DU_LOG("\nERROR  -->  F1AP: fillReportCfgToAddModList() :Memory allocation failed for report config list's array");
8077       return RFAILED;
8078    }
8079
8080    for(reportCfgIdx=0; reportCfgIdx < reportCfgList->list.count; reportCfgIdx++)
8081    {
8082       CU_ALLOC(reportCfgList->list.array[reportCfgIdx], sizeof(ReportConfigToAddMod_t));
8083       if(!reportCfgList->list.array[reportCfgIdx])
8084       {
8085          DU_LOG("\nERROR  -->  F1AP: fillReportCfgToAddModList(): Memory allocation failed for report config list's array element");
8086          return RFAILED;
8087       }
8088    }
8089
8090    reportCfgIdx = 0;
8091    reportCfg = reportCfgList->list.array[reportCfgIdx];
8092    reportCfg->reportConfigId = 1;
8093    reportCfg->reportConfig.present = ReportConfigToAddMod__reportConfig_PR_reportConfigNR;
8094
8095    /* Report Configuration for NR */
8096    CU_ALLOC(reportCfg->reportConfig.choice.reportConfigNR, sizeof(ReportConfigNR_t));
8097    if(!reportCfg->reportConfig.choice.reportConfigNR)
8098    {
8099       DU_LOG("\nERROR  -->  F1AP: fillReportCfgToAddModList(): Memory allocation failed for report config NR");
8100       return RFAILED;
8101    }
8102    reportCfgNr = reportCfg->reportConfig.choice.reportConfigNR;
8103
8104    /* Report Type */
8105    reportCfgNr->reportType.present = ReportConfigNR__reportType_PR_eventTriggered;
8106    CU_ALLOC(reportCfgNr->reportType.choice.eventTriggered, sizeof(EventTriggerConfig_t));
8107    if(!reportCfgNr->reportType.choice.eventTriggered)
8108    {
8109       DU_LOG("\nERROR  -->  F1AP: fillReportCfgToAddModList(): Memory allocation failed for event triggerred");
8110       return RFAILED;
8111    }
8112    eventTriggCfg = reportCfgNr->reportType.choice.eventTriggered;
8113
8114    /* Event 3 */
8115    eventTriggCfg->eventId.present = EventTriggerConfig__eventId_PR_eventA3;
8116    CU_ALLOC(eventTriggCfg->eventId.choice.eventA3, sizeof(struct EventTriggerConfig__eventId__eventA3));
8117    if(!eventTriggCfg->eventId.choice.eventA3)
8118    {
8119       DU_LOG("\nERROR  -->  F1AP: fillReportCfgToAddModList(): Memory allocation failed for event A3");
8120       return RFAILED;
8121    }
8122
8123    eventTriggCfg->eventId.choice.eventA3->a3_Offset.present = MeasTriggerQuantityOffset_PR_rsrp;
8124    eventTriggCfg->eventId.choice.eventA3->a3_Offset.choice.rsrp = 6; /* i.e. 3.0db . From Reference pcap log */
8125    eventTriggCfg->eventId.choice.eventA3->reportOnLeave = false;
8126    eventTriggCfg->eventId.choice.eventA3->hysteresis = 0;
8127    eventTriggCfg->eventId.choice.eventA3->timeToTrigger = TimeToTrigger_ms40;
8128    eventTriggCfg->eventId.choice.eventA3->useWhiteCellList = false;
8129
8130    /* Reference Signal Type */
8131    eventTriggCfg->rsType = NR_RS_Type_ssb;
8132
8133    /* Report Interval */
8134    eventTriggCfg->reportInterval = ReportInterval_ms1024;
8135
8136    /* Report Amount */
8137    eventTriggCfg->reportAmount = EventTriggerConfig__reportAmount_r8;
8138
8139    /* Report Quantity cell */
8140    eventTriggCfg->reportQuantityCell.rsrp = true;
8141    eventTriggCfg->reportQuantityCell.rsrq = false;
8142    eventTriggCfg->reportQuantityCell.sinr = false;
8143
8144    /* Maximum reported cells */
8145    eventTriggCfg->maxReportCells = 3;
8146
8147    /* Report qunatity RS Indexes */
8148    CU_ALLOC(eventTriggCfg->reportQuantityRS_Indexes, sizeof(MeasReportQuantity_t));
8149    if(!eventTriggCfg->reportQuantityRS_Indexes)
8150    {
8151       DU_LOG("\nERROR  -->  F1AP: fillReportCfgToAddModList(): Memory allocation failed for report qunatity RS indexes");
8152       return RFAILED;
8153    }
8154    eventTriggCfg->reportQuantityRS_Indexes->rsrp = true;
8155    eventTriggCfg->reportQuantityRS_Indexes->rsrq = false;
8156    eventTriggCfg->reportQuantityRS_Indexes->sinr = false;
8157
8158    /* Maximum number of RS indexes to report */
8159    CU_ALLOC(eventTriggCfg->maxNrofRS_IndexesToReport, sizeof(long));
8160    if(!eventTriggCfg->maxNrofRS_IndexesToReport)
8161    {
8162       DU_LOG("\nERROR  -->  F1AP: fillReportCfgToAddModList(): Memory allocation failed for max number of RS indexes to report");
8163       return RFAILED;
8164    }
8165    *(eventTriggCfg->maxNrofRS_IndexesToReport) = 1;
8166
8167    /* Include Beam measurement */
8168    eventTriggCfg->includeBeamMeasurements = false;
8169
8170    return ROK;
8171 }
8172
8173 /*******************************************************************
8174  *
8175  * @brief Fill measurement Id to add/mod list
8176
8177  * @details
8178  *
8179  *    Function : fillMeasIdToAddModList
8180  *
8181  *    Functionality: Fill measurement Id to add/mod list
8182  *
8183  * @params[in] Measurement Id to add/mod list
8184  * @return ROK     - success
8185  *         RFAILED - failure
8186  *
8187  * ****************************************************************/
8188 uint8_t fillMeasIdToAddModList(MeasIdToAddModList_t *measIdList)
8189 {
8190    uint8_t elementCnt;
8191    uint8_t measIdIdx;
8192
8193    elementCnt = 1;
8194    measIdList->list.count = elementCnt;
8195    measIdList->list.size = measIdList->list.count *sizeof(MeasIdToAddMod_t *);
8196
8197    CU_ALLOC(measIdList->list.array, measIdList->list.size);
8198    if(!measIdList->list.array)
8199    {
8200       return RFAILED;
8201    }
8202
8203    for(measIdIdx=0; measIdIdx < measIdList->list.count; measIdIdx++)
8204    {
8205       CU_ALLOC(measIdList->list.array[measIdIdx], sizeof(MeasIdToAddMod_t));
8206       if(!measIdList->list.array[measIdIdx])
8207       {
8208          return RFAILED;
8209       }
8210
8211       measIdIdx=0;
8212       measIdList->list.array[measIdIdx]->measId = 1;
8213       measIdList->list.array[measIdIdx]->measObjectId = 1;
8214       measIdList->list.array[measIdIdx]->reportConfigId = 1;
8215    }
8216    return ROK;
8217 }
8218
8219 /*******************************************************************
8220  *
8221  * @brief Fill s-measurement configuration
8222  *
8223  * @details
8224  *
8225  *    Function : fillSMeasConfig
8226  *
8227  *    Functionality: Fill s-measurement configuration
8228  *
8229  * @params[in] s-Measurement config
8230  * @return ROK     - success
8231  *         RFAILED - failure
8232  *
8233  * ****************************************************************/
8234 uint8_t fillSMeasConfig(struct MeasConfigRrc__s_MeasureConfig *sMeasCfg)
8235 {
8236    sMeasCfg->present = MeasConfigRrc__s_MeasureConfig_PR_ssb_RSRP;
8237    sMeasCfg->choice.ssb_RSRP = 100; /* Value taken from reference PCAP log */
8238
8239    return ROK;
8240 }
8241
8242 /*******************************************************************
8243  *
8244  * @brief Fill quantity config
8245  *
8246  * @details
8247  *
8248  *    Function : fillQunatityConfig
8249  *
8250  *    Functionality: Fill quantity config
8251  *
8252  * @params[in] Quantity Config
8253  * @return ROK     - success
8254  *         RFAILED - failure
8255  *
8256  * ****************************************************************/
8257 uint8_t fillQuantityConfig(QuantityConfig_t *quantityCfg)
8258 {
8259    uint8_t elementCnt = 0;
8260    uint8_t quanCfgIdx = 0;
8261    QuantityConfigNR_t *quantityCfgNr;
8262
8263    CU_ALLOC(quantityCfg->quantityConfigNR_List, sizeof(struct QuantityConfig__quantityConfigNR_List));
8264    if(!quantityCfg->quantityConfigNR_List)
8265    {
8266       return RFAILED;
8267    }
8268
8269    elementCnt = 1;
8270    quantityCfg->quantityConfigNR_List->list.count = elementCnt;
8271    quantityCfg->quantityConfigNR_List->list.size = elementCnt * sizeof(QuantityConfigNR_t *);
8272
8273    CU_ALLOC(quantityCfg->quantityConfigNR_List->list.array, quantityCfg->quantityConfigNR_List->list.size);
8274    if(!quantityCfg->quantityConfigNR_List->list.array)
8275    {
8276       return RFAILED;
8277    }
8278
8279    for(quanCfgIdx = 0; quanCfgIdx < quantityCfg->quantityConfigNR_List->list.count; quanCfgIdx++)
8280    {
8281       CU_ALLOC(quantityCfg->quantityConfigNR_List->list.array[quanCfgIdx], sizeof(QuantityConfigNR_t));
8282       if(!quantityCfg->quantityConfigNR_List->list.array[quanCfgIdx])
8283       {
8284          return RFAILED;
8285       }
8286    }
8287
8288    quanCfgIdx = 0;
8289    quantityCfgNr = quantityCfg->quantityConfigNR_List->list.array[quanCfgIdx];
8290
8291    /* Quantity Config of Reference signal */
8292    CU_ALLOC(quantityCfgNr->quantityConfigCell.ssb_FilterConfig.filterCoefficientRSRP, sizeof(FilterCoefficient_t));
8293    if(!quantityCfgNr->quantityConfigCell.ssb_FilterConfig.filterCoefficientRSRP)
8294    {
8295       return RFAILED;
8296    }
8297    *(quantityCfgNr->quantityConfigCell.ssb_FilterConfig.filterCoefficientRSRP) = FilterCoefficient_fc4;
8298
8299    CU_ALLOC(quantityCfgNr->quantityConfigCell.ssb_FilterConfig.filterCoefficientRSRQ, sizeof(FilterCoefficient_t));
8300    if(!quantityCfgNr->quantityConfigCell.ssb_FilterConfig.filterCoefficientRSRQ)
8301    {
8302       return RFAILED;
8303    }
8304    *(quantityCfgNr->quantityConfigCell.ssb_FilterConfig.filterCoefficientRSRQ) = FilterCoefficient_fc4;
8305
8306    CU_ALLOC(quantityCfgNr->quantityConfigCell.ssb_FilterConfig.filterCoefficientRS_SINR, sizeof(FilterCoefficient_t));
8307    if(!quantityCfgNr->quantityConfigCell.ssb_FilterConfig.filterCoefficientRS_SINR)
8308    {
8309       return RFAILED;
8310    }
8311    *(quantityCfgNr->quantityConfigCell.ssb_FilterConfig.filterCoefficientRS_SINR) = FilterCoefficient_fc4;
8312
8313    /* Quantity Config RS index */
8314    CU_ALLOC(quantityCfgNr->quantityConfigRS_Index, sizeof(QuantityConfigRS_t));
8315    if(!quantityCfgNr->quantityConfigRS_Index)
8316    {
8317       return RFAILED;
8318    }
8319
8320    CU_ALLOC(quantityCfgNr->quantityConfigRS_Index->ssb_FilterConfig.filterCoefficientRSRP, sizeof(FilterCoefficient_t));
8321    if(!quantityCfgNr->quantityConfigRS_Index->ssb_FilterConfig.filterCoefficientRSRP)
8322    {
8323       return RFAILED;
8324    }
8325    *(quantityCfgNr->quantityConfigRS_Index->ssb_FilterConfig.filterCoefficientRSRP) = FilterCoefficient_fc4;
8326
8327    CU_ALLOC(quantityCfgNr->quantityConfigRS_Index->ssb_FilterConfig.filterCoefficientRSRQ, sizeof(FilterCoefficient_t));
8328    if(!quantityCfgNr->quantityConfigRS_Index->ssb_FilterConfig.filterCoefficientRSRQ)
8329    {
8330       return RFAILED;
8331    }
8332    *(quantityCfgNr->quantityConfigRS_Index->ssb_FilterConfig.filterCoefficientRSRQ) = FilterCoefficient_fc4;
8333
8334    CU_ALLOC(quantityCfgNr->quantityConfigRS_Index->ssb_FilterConfig.filterCoefficientRS_SINR, sizeof(FilterCoefficient_t));
8335    if(!quantityCfgNr->quantityConfigRS_Index->ssb_FilterConfig.filterCoefficientRS_SINR)
8336    {
8337       return RFAILED;
8338    }
8339    *(quantityCfgNr->quantityConfigRS_Index->ssb_FilterConfig.filterCoefficientRS_SINR) = FilterCoefficient_fc4;
8340
8341    return ROK;
8342 }
8343
8344 /*******************************************************************
8345  *
8346  * @brief Fill measurement configuration
8347  *
8348  * @details
8349  *
8350  *    Function : fillMeasConfig
8351  *
8352  *    Functionality: Fill measurement configuration
8353  *
8354  * @params[in] Measurement config
8355  * @return ROK     - success
8356  *         RFAILED - failure
8357  *
8358  * ****************************************************************/
8359 uint8_t fillMeasConfig(MeasConfigRrc_t *measConfig)
8360 {
8361    /* Measurement object to add/mod list */
8362    CU_ALLOC(measConfig->measObjectToAddModList, sizeof(MeasObjectToAddModList_t));
8363    if(!measConfig->measObjectToAddModList)
8364    {
8365       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for measurement object list in fillMeasConfig");
8366       return RFAILED;
8367    }
8368    if(fillMeasObjToAddModList(measConfig->measObjectToAddModList) != ROK)
8369    {
8370       DU_LOG("\nERROR  -->  F1AP: Failure in fillMeasObjToAddModList");
8371       return RFAILED;
8372    }
8373
8374    /* Report Config To add/mod list */
8375    CU_ALLOC(measConfig->reportConfigToAddModList, sizeof(ReportConfigToAddModList_t));
8376    if(!measConfig->reportConfigToAddModList)
8377    {
8378       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for report config list in  fillMeasConfig");
8379       return RFAILED;
8380    }
8381    if(fillReportCfgToAddModList(measConfig->reportConfigToAddModList) != ROK)
8382    {
8383       DU_LOG("\nERROR  -->  F1AP: Failure in fillReportCfgToAddModList");
8384       return RFAILED;
8385    }
8386
8387    /* Measurement Id to add/mod list */
8388    CU_ALLOC(measConfig->measIdToAddModList, sizeof(MeasIdToAddModList_t));
8389    if(!measConfig->measIdToAddModList)
8390    {
8391       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for measuerment id list in  fillMeasConfig");
8392       return RFAILED;
8393    }
8394    if(fillMeasIdToAddModList(measConfig->measIdToAddModList) != ROK)
8395    {
8396       DU_LOG("\nERROR  -->  F1AP: Failure in fillMeasIdToAddModList");
8397       return RFAILED;
8398    }
8399
8400    /* S-Measurement config */
8401    CU_ALLOC(measConfig->s_MeasureConfig, sizeof(struct MeasConfigRrc__s_MeasureConfig));
8402    if(!measConfig->s_MeasureConfig)
8403    {
8404       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for s measuerment config in  fillMeasConfig");
8405       return RFAILED;
8406    }
8407    if(fillSMeasConfig(measConfig->s_MeasureConfig) != ROK)
8408    {
8409       DU_LOG("\nERROR  -->  F1AP: Failure in fillSMeasConfig");
8410       return RFAILED;
8411    }
8412
8413    /* Qunatity Config */
8414    CU_ALLOC(measConfig->quantityConfig, sizeof(QuantityConfig_t));
8415    if(!measConfig->quantityConfig)
8416    {
8417       DU_LOG("\nERROR  -->  F1AP: Memory allocation failed for quantity config in  fillMeasConfig");
8418       return RFAILED;
8419    }
8420    if(fillQuantityConfig(measConfig->quantityConfig) != ROK)
8421    {
8422       DU_LOG("\nERROR  -->  F1AP: Failure in fillQuantityConfig");
8423       return RFAILED;
8424    }
8425
8426 return ROK;
8427 }
8428
8429 /*******************************************************************
8430  *
8431  * @brief Fill RRC reconfiguration non-critical extension IE
8432  *
8433  * @details
8434  *
8435  *    Function : fillRrcReconfigNonCriticalExt
8436  *
8437  *    Functionality: Fill RRC reconfiguration non-critical extension
8438  *
8439  * @params[in] RRC Reconfig Non-critical extension
8440  * @return ROK     - success
8441  *         RFAILED - failure
8442  *
8443  * ****************************************************************/
8444 uint8_t fillRrcReconfigNonCriticalExt(CuUeCb *ueCb, RRCReconfiguration_v1530_IEs_t *rrcRecfg, bool updateAllRbCfg)
8445 {
8446    CU_ALLOC(rrcRecfg->masterCellGroup, sizeof(OCTET_STRING_t));
8447    if(!rrcRecfg->masterCellGroup)
8448    {
8449       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in fillRrcReconfigNonCriticalExt");
8450       return RFAILED;
8451    }
8452
8453    rrcRecfg->masterCellGroup->size = ueCb->f1apMsgDb.duToCuContainer.size;
8454    CU_ALLOC(rrcRecfg->masterCellGroup->buf, rrcRecfg->masterCellGroup->size);
8455    if(!rrcRecfg->masterCellGroup->buf)
8456    {
8457       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in fillRrcReconfigNonCriticalExt");
8458       return RFAILED;
8459    }
8460    memcpy(rrcRecfg->masterCellGroup->buf, ueCb->f1apMsgDb.duToCuContainer.buf, rrcRecfg->masterCellGroup->size);
8461
8462 #if 0
8463    /* Use below code if masterCEllGroup is to be filled explicitly at CU rather than copying from DUToCURRCContainer
8464     * received from DU */
8465    if(fillCellGrpCfg(ueCb, rrcRecfg->masterCellGroup, updateAllRbCfg) != ROK)
8466    {
8467       DU_LOG("\nERROR  -->  F1AP : Failed to fill CellGroupCfg in fillRrcReconfigNonCriticalExt");
8468       return RFAILED;
8469    }
8470 #endif
8471
8472    return ROK;
8473 }
8474
8475 /*******************************************************************
8476  *
8477  * @brief Fill RRC reconfiguration structure
8478  *
8479  * @details
8480  *
8481  *    Function : fillRrcReconfig
8482  *
8483  *    Functionality: Fill RRC reconfiguration
8484
8485  *
8486  * @params[in] UE Cb
8487  *             RRC reconfiguration structure
8488  * @return ROK     - success
8489  *         RFAILED - failure
8490  *
8491  * ****************************************************************/
8492 uint8_t fillRrcReconfig(CuUeCb *ueCb, RRCReconfiguration_t *rrcReconfig, bool updateAllRbCfg)
8493 {
8494    memset(rrcReconfig, 0, sizeof(RRCReconfiguration_t));
8495
8496    rrcReconfig->rrc_TransactionIdentifier = 1;
8497    rrcReconfig->criticalExtensions.present = RRCReconfiguration__criticalExtensions_PR_rrcReconfiguration;
8498
8499    CU_ALLOC(rrcReconfig->criticalExtensions.choice.rrcReconfiguration, sizeof(RRCReconfiguration_IEs_t));
8500    if(!rrcReconfig->criticalExtensions.choice.rrcReconfiguration)
8501    {
8502       DU_LOG("\nERROR  -->  F1AP : Memormy allocation failed for RRC reconfiguration IE in fillRrcReconfig");
8503       return RFAILED;
8504    }
8505
8506    /* Radio Bearer Configuration */
8507    CU_ALLOC(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->radioBearerConfig, sizeof(RadioBearerConfig_t));
8508    if(!rrcReconfig->criticalExtensions.choice.rrcReconfiguration->radioBearerConfig)
8509    {
8510       DU_LOG("\nERROR  -->  F1AP : Memormy allocation failed for radio bearer config in fillRrcReconfig");
8511       return RFAILED;
8512    }
8513    if(fillRadioBearerConfig(ueCb, rrcReconfig->criticalExtensions.choice.rrcReconfiguration->radioBearerConfig, updateAllRbCfg) != ROK)
8514    {
8515       DU_LOG("\nERROR  -->  F1AP : Failed to fill radio bearer config in fillRrcReconfig");
8516       return RFAILED;
8517    }
8518
8519    /* Measurement Configuration */
8520    CU_ALLOC(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->measConfig, sizeof(MeasConfigRrc_t));
8521    if(!rrcReconfig->criticalExtensions.choice.rrcReconfiguration->measConfig)
8522    {
8523       DU_LOG("\nERROR  -->  F1AP : Memormy allocation failed for Measurement config IE in fillRrcReconfig");
8524       return RFAILED;
8525    }
8526    if(fillMeasConfig(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->measConfig) != ROK)
8527    {
8528       DU_LOG("\nERROR  -->  F1AP : Failed to fill measurement config in fillRrcReconfig");
8529       return RFAILED;
8530    }
8531
8532    /* Non Critical extension */
8533    CU_ALLOC(rrcReconfig->criticalExtensions.choice.rrcReconfiguration->nonCriticalExtension, sizeof(struct RRCReconfiguration_v1530_IEs));
8534    if(!rrcReconfig->criticalExtensions.choice.rrcReconfiguration->nonCriticalExtension)
8535    {
8536       DU_LOG("\nERROR  -->  F1AP : Memormy allocation failed for non critical extension IE in fillRrcReconfig");
8537       return RFAILED;
8538    }
8539    if(fillRrcReconfigNonCriticalExt(ueCb, rrcReconfig->criticalExtensions.choice.rrcReconfiguration->nonCriticalExtension, updateAllRbCfg) != ROK)
8540    {
8541       DU_LOG("\nERROR  -->  F1AP : Failed to fill non critical extension in fillRrcReconfig");
8542       return RFAILED;
8543    }
8544    return ROK;
8545 }
8546
8547 /*******************************************************************
8548  *
8549  * @brief Fill RRC reconfiguration Octet string
8550  *
8551  * @details
8552  *
8553  *    Function : fillRrcReconfigBuf
8554  *
8555  *    Functionality: Fill RRC reconfiguration octet string
8556
8557  *
8558  * @params[in] OCTET_STRING_t buffer
8559  * @return ROK     - success
8560  *         RFAILED - failure
8561  *
8562  * ****************************************************************/
8563 uint8_t fillRrcReconfigBuf(CuUeCb *ueCb, OCTET_STRING_t  *rrcReconfigBuf, bool updateAllRbCfg)
8564 {
8565    uint8_t          ret = RFAILED;
8566    asn_enc_rval_t   encRetVal;
8567    RRCReconfiguration_t rrcRecfg, *rrcReconfig = NULLP;
8568    rrcReconfig = &rrcRecfg;
8569
8570    while(true)
8571    {
8572       if(fillRrcReconfig(ueCb, rrcReconfig, updateAllRbCfg) != ROK)
8573       {
8574          DU_LOG( "\nERROR  -->  F1AP : Failed to fill RRC Reconfiguration in fillRrcReconfigBuf");
8575          break;
8576       }
8577
8578       /* Encode RRC Reconfiguration */
8579       xer_fprint(stdout, &asn_DEF_RRCReconfiguration, rrcReconfig);
8580       cmMemset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
8581       encBufSize = 0;
8582       encRetVal = aper_encode(&asn_DEF_RRCReconfiguration, 0, rrcReconfig, PrepFinalEncBuf, encBuf);
8583
8584       /* Encode results */
8585       if(encRetVal.encoded == ENCODE_FAIL)
8586       {
8587          DU_LOG( "\nERROR  -->  F1AP : Could not encode RRC Reconfiguration (at %s)\n",\
8588                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
8589          break;
8590       }
8591       else
8592       {
8593          DU_LOG("\nDEBUG  -->  F1AP : Created APER encoded buffer for RRC Reconfiguration\n");
8594          for(int i=0; i< encBufSize; i++)
8595          {
8596             DU_LOG("%x",encBuf[i]);
8597          }
8598       }
8599
8600       rrcReconfigBuf->size = encBufSize;
8601       CU_ALLOC(rrcReconfigBuf->buf, rrcReconfigBuf->size);
8602       if(!rrcReconfigBuf->buf)
8603       {
8604          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in fillRrcReconfigBuf");
8605          break;
8606       }
8607       memcpy(rrcReconfigBuf->buf, encBuf, rrcReconfigBuf->size);
8608       ret = ROK;
8609       break;
8610    }
8611
8612    freeRrcReconfig(rrcReconfig);
8613    return ret;
8614 }
8615
8616 /*******************************************************************
8617  *
8618  * @brief Fill HO preparation information Octet string
8619  *
8620  * @details
8621  *
8622  *    Function : fillHOPreparationInfoBuf
8623  *
8624  *    Functionality: Fill HO preparation information Octet string
8625
8626  *
8627  * @params[in] HandoverPreparationInformation_t buffer
8628  * @return ROK     - success
8629  *         RFAILED - failure
8630  *
8631  * ****************************************************************/
8632 uint8_t fillHOPreparationInfoBuf(CuUeCb *ueCb, HandoverPreparationInformation_t *hoPrepInfoBuf)
8633 {
8634    uint8_t          ret = RFAILED;
8635    asn_enc_rval_t   encRetVal;
8636    HandoverPreparationInformationRrc_t hoPrepInfo;
8637    HandoverPreparationInformationRrc_IEs_t *hoPrepInfoIe;
8638
8639    while(true)
8640    {
8641
8642       hoPrepInfo.criticalExtensions.present = HandoverPreparationInformationRrc__criticalExtensions_PR_c1;
8643       CU_ALLOC(hoPrepInfo.criticalExtensions.choice.c1, sizeof(struct HandoverPreparationInformationRrc__criticalExtensions__c1));
8644       if(!hoPrepInfo.criticalExtensions.choice.c1)
8645       {
8646          DU_LOG( "\nERROR  -->  F1AP : Failed to allocate memory for c1 in fillHOPreparationInfo");
8647          break;
8648       }
8649       hoPrepInfo.criticalExtensions.choice.c1->present = \
8650          HandoverPreparationInformationRrc__criticalExtensions__c1_PR_handoverPreparationInformation;
8651
8652       CU_ALLOC(hoPrepInfo.criticalExtensions.choice.c1->choice.handoverPreparationInformation , \
8653          sizeof(HandoverPreparationInformationRrc_IEs_t));
8654       if(!hoPrepInfo.criticalExtensions.choice.c1->choice.handoverPreparationInformation)
8655       {
8656          DU_LOG( "\nERROR  -->  F1AP : Failed to allocate memory for handover preparation information IE in fillHOPreparationInfo");
8657          break;
8658       }
8659       hoPrepInfoIe = hoPrepInfo.criticalExtensions.choice.c1->choice.handoverPreparationInformation;
8660
8661       /* Fill UE Capability RAT container list */
8662       ret = fillUeCapRatContList(&hoPrepInfoIe->ue_CapabilityRAT_List);
8663       if(ret != ROK)
8664       {
8665          DU_LOG( "\nERROR  -->  F1AP : Failed to fill UE Capability RAT container list");
8666          break;
8667       }
8668
8669       /* Fill Source config */
8670       hoPrepInfoIe->sourceConfig = NULLP;
8671       CU_ALLOC(hoPrepInfoIe->sourceConfig, sizeof(AS_Config_t));
8672       if(!hoPrepInfoIe->sourceConfig)
8673       {
8674          DU_LOG( "\nERROR  -->  F1AP : Failed to allocate memory for source config in fillHOPreparationInfo");
8675          return RFAILED;
8676       }
8677       ret = fillRrcReconfigBuf(ueCb, &hoPrepInfoIe->sourceConfig->rrcReconfiguration, true);
8678
8679       if(ret != ROK)
8680       {
8681          DU_LOG( "\nERROR  -->  F1AP : Failed to fill Rrc reconfiguration buffer");
8682          return RFAILED;
8683       }
8684
8685       hoPrepInfoIe->rrm_Config = NULLP;
8686       hoPrepInfoIe->as_Context = NULLP;
8687       hoPrepInfoIe->nonCriticalExtension = NULLP;
8688
8689       /* encode UE Capability RAT Container List into duToCuRrcContainer */
8690       xer_fprint(stdout, &asn_DEF_HandoverPreparationInformationRrc, &hoPrepInfo);
8691       cmMemset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
8692       encBufSize = 0;
8693       encRetVal = aper_encode(&asn_DEF_HandoverPreparationInformationRrc, 0, \
8694             &hoPrepInfo, PrepFinalEncBuf, encBuf);
8695
8696       /* Encode results */
8697       if(encRetVal.encoded == ENCODE_FAIL)
8698       {
8699          DU_LOG( "\nERROR  -->  F1AP : Could not encode UE Capability RAT Container (at %s)\n",\
8700                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
8701          break;
8702       }
8703       else
8704       {
8705          DU_LOG("\nDEBUG  -->  F1AP : Created APER encodedbuffer for UE Capability RAT Container\n");
8706          for(int i=0; i< encBufSize; i++)
8707          {
8708             DU_LOG("%x",encBuf[i]);
8709          }
8710       }
8711
8712       hoPrepInfoBuf->size = encBufSize;
8713       CU_ALLOC(hoPrepInfoBuf->buf, hoPrepInfoBuf->size);
8714       if(!hoPrepInfoBuf->buf)
8715       {
8716          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in fillUeCapabilityContainer");
8717          break;
8718       }
8719       memcpy(hoPrepInfoBuf->buf, encBuf, hoPrepInfoBuf->size);
8720       ret = ROK;
8721       break;
8722    }
8723    freeHOPreparationInfo(&hoPrepInfo);
8724    return ret;
8725 }
8726
8727 /*******************************************************************
8728  *
8729  * @brief Fills CuToDuContainer
8730  *
8731  * @details
8732  *
8733  *    Function : fillCuToDuContainer
8734  *
8735  *    Functionality: Fills CuToDuContainer
8736  *
8737  * @params[in] pointer to CUtoDURRCInformation_t
8738  *
8739  * @return ROK     - success
8740  *         RFAILED - failure
8741  *
8742  ******************************************************************/
8743
8744 uint8_t fillCuToDuContainer(CuUeCb *ueCb, CUtoDURRCInformation_t *rrcMsg)
8745 {
8746    uint8_t elementCnt = 0;
8747    uint8_t ret = ROK;
8748    uint8_t idx, idx2, rrcBufLen;
8749
8750    /* UE Capabulity RAT Container List */
8751    CU_ALLOC(rrcMsg->uE_CapabilityRAT_ContainerList, sizeof(UE_CapabilityRAT_ContainerList_t));
8752    if(!rrcMsg->uE_CapabilityRAT_ContainerList)
8753    {
8754       DU_LOG("\nERROR  -->  F1AP : Memory allocation for UE capability RAT container list failed");
8755       return RFAILED;
8756    }
8757    ret = fillUeCapRatContListBuf(rrcMsg->uE_CapabilityRAT_ContainerList);
8758
8759    CU_ALLOC(rrcMsg->measConfig, sizeof(MeasConfig_t));
8760    if(!rrcMsg->measConfig)
8761    {
8762       DU_LOG("\nERROR  -->  F1AP : Memory allocation for measurement configuration failed");
8763       return RFAILED;
8764    }
8765    ret = fillMeasTimingConfigBuf(rrcMsg->measConfig);
8766
8767    if(ueCb->state == UE_HANDOVER_IN_PROGRESS)
8768    {
8769       /* IE extensions */
8770       CU_ALLOC(rrcMsg->iE_Extensions, sizeof(ProtocolExtensionContainer_4624P16_t));
8771       if(rrcMsg->iE_Extensions)
8772       {
8773          elementCnt = 1;
8774          rrcMsg->iE_Extensions->list.count = elementCnt;
8775          rrcMsg->iE_Extensions->list.size = elementCnt * sizeof(CUtoDURRCInformation_ExtIEs_t *);
8776
8777          /* Initialize the CUtoDURRCInformation_ExtIEs */
8778          CU_ALLOC(rrcMsg->iE_Extensions->list.array, rrcMsg->iE_Extensions->list.size);
8779
8780          if(rrcMsg->iE_Extensions->list.array == NULLP)
8781          {
8782             DU_LOG("\nERROR  -->  F1AP : Memory allocation for CUtoDURRCInformation_ExtIEs failed");
8783             ret = RFAILED;
8784          }
8785
8786          for(idx=0; idx<elementCnt; idx++)
8787          {
8788             CU_ALLOC(rrcMsg->iE_Extensions->list.array[idx], sizeof(CUtoDURRCInformation_ExtIEs_t));
8789             if(rrcMsg->iE_Extensions->list.array[idx] == NULLP)
8790             {
8791                DU_LOG("\nERROR  -->  F1AP : Memory allocation for array elements failed");
8792                ret = RFAILED;
8793             }
8794          }
8795
8796          idx = 0;
8797 #if 0
8798          /* Cell Group Configuration */
8799          rrcMsg->iE_Extensions->list.array[idx]->id = ProtocolIE_ID_id_CellGroupConfig;
8800          rrcMsg->iE_Extensions->list.array[idx]->criticality = Criticality_ignore;
8801          rrcMsg->iE_Extensions->list.array[idx]->extensionValue.present  =\
8802                                                                           CUtoDURRCInformation_ExtIEs__extensionValue_PR_CellGroupConfig;
8803          ret = fillCellGrpCfg(ueCb, &rrcMsg->iE_Extensions->list.array[idx]->extensionValue.choice.CellGroupConfig, true);
8804          idx++;
8805 #endif
8806          /* Handover Preparation Information */
8807          rrcMsg->iE_Extensions->list.array[idx]->id = ProtocolIE_ID_id_HandoverPreparationInformation;
8808          rrcMsg->iE_Extensions->list.array[idx]->criticality = Criticality_ignore;
8809          rrcMsg->iE_Extensions->list.array[idx]->extensionValue.present  = \
8810                                                                            CUtoDURRCInformation_ExtIEs__extensionValue_PR_HandoverPreparationInformation;
8811          ret = fillHOPreparationInfoBuf(ueCb, &rrcMsg->iE_Extensions->list.array[idx]->extensionValue.choice.HandoverPreparationInformation);
8812       }
8813    }
8814    return ret;
8815 }
8816
8817 /*******************************************************************
8818  *
8819  * @brief Free CuToDuContainer
8820  *
8821  * @details
8822  *
8823  *    Function : FreeCuToDuInfo
8824  *
8825  *    Functionality: Free CuToDuContainer
8826  *
8827  * @params[in] pointer to CUtoDURRCInformation_t
8828  *
8829  * @return ROK     - success
8830  *         RFAILED - failure
8831  *
8832  ******************************************************************/
8833
8834 void FreeCuToDuInfo(CUtoDURRCInformation_t *rrcMsg)
8835 {
8836    uint8_t idx, idx2;
8837
8838    if(rrcMsg->uE_CapabilityRAT_ContainerList)
8839    {
8840       if(rrcMsg->uE_CapabilityRAT_ContainerList->buf)
8841          CU_FREE(rrcMsg->uE_CapabilityRAT_ContainerList->buf, rrcMsg->uE_CapabilityRAT_ContainerList->size);
8842       CU_FREE(rrcMsg->uE_CapabilityRAT_ContainerList, sizeof(UE_CapabilityRAT_ContainerList_t));
8843    }
8844    if(rrcMsg->iE_Extensions)
8845    {
8846       if(rrcMsg->iE_Extensions->list.array)
8847       {
8848          for(idx= 0; idx < rrcMsg->iE_Extensions->list.count; idx++)
8849          {
8850             if(rrcMsg->iE_Extensions->list.array[idx])
8851             {
8852                switch(rrcMsg->iE_Extensions->list.array[idx]->id)
8853                {
8854                   case ProtocolIE_ID_id_CellGroupConfig:
8855                      if(rrcMsg->iE_Extensions->list.array[idx]->extensionValue.choice.CellGroupConfig.buf != NULLP)
8856                      {
8857                         CU_FREE(rrcMsg->iE_Extensions->list.array[idx]->extensionValue.choice.CellGroupConfig.buf,\
8858                               rrcMsg->iE_Extensions->list.array[idx]->extensionValue.choice.CellGroupConfig.size);
8859
8860                      }
8861                      break;
8862                   default:
8863                      DU_LOG("\nERROR  -->  F1AP : Invalid Event type %ld at FreeCuToDuInfo()", \
8864                            rrcMsg->iE_Extensions->list.array[idx]->id);
8865                      break;
8866                }
8867             }
8868             break;
8869          }
8870          for(idx2 = 0; idx2 < idx; idx2++)
8871          {
8872             CU_FREE(rrcMsg->iE_Extensions->list.array[idx2], sizeof(CUtoDURRCInformation_ExtIEs_t));
8873          }
8874          CU_FREE(rrcMsg->iE_Extensions->list.array, rrcMsg->iE_Extensions->list.size);
8875
8876       }
8877
8878       CU_FREE(rrcMsg->iE_Extensions, sizeof(ProtocolExtensionContainer_4624P16_t));
8879    }
8880 }
8881 /*******************************************************************
8882  *
8883  * @brief Builds and sends the UE Setup Request
8884  *
8885  * @details
8886  *
8887  *    Function : BuildAndSendUeContextSetupReq
8888  *
8889  *    Functionality: Constructs the UE Setup Request and sends
8890  *                   it to the CU through SCTP.
8891  *
8892  * @params[in]
8893  *
8894  * @return ROK     - success
8895  *         RFAILED - failure
8896  *
8897  * ****************************************************************/
8898 uint8_t BuildAndSendUeContextSetupReq(uint32_t duId, CuUeCb *ueCb, uint16_t rrcContLen, uint8_t *rrcContainer)
8899 {
8900    uint8_t   Nrcgiret, SplCellListret, SrbSetupret;
8901    uint8_t   ret= RFAILED, ret1;
8902    uint8_t   elementCnt;
8903    uint8_t   idx, idx1, bufLen, duIdx;
8904    uint32_t  spCellId;
8905    DuDb      *targetDuDb = NULLP;
8906    F1AP_PDU_t           *f1apMsg = NULLP;
8907    UEContextSetupRequest_t *ueSetReq = NULLP;
8908    asn_enc_rval_t encRetVal;        /* Encoder return value */
8909    memset(&encRetVal, 0, sizeof(asn_enc_rval_t));
8910
8911    while(true)
8912    {
8913       DU_LOG("\nINFO  -->  F1AP : Building UE Context Setup Request\n");
8914
8915       CU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
8916       if(f1apMsg == NULLP)
8917       {
8918          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
8919          break;
8920       }
8921
8922       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
8923       CU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
8924       if(f1apMsg->choice.initiatingMessage == NULLP)
8925       {
8926          DU_LOG("\nERROR  -->  F1AP : Memory allocation for     F1AP-PDU failed");
8927          break;
8928       }
8929
8930       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_UEContextSetup;
8931       f1apMsg->choice.initiatingMessage->criticality = Criticality_reject;
8932       f1apMsg->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_UEContextSetupRequest;
8933
8934       ueSetReq = &f1apMsg->choice.initiatingMessage->value.choice.UEContextSetupRequest;
8935
8936       if(ueCb->state == UE_HANDOVER_IN_PROGRESS)
8937          elementCnt = 7;
8938       else
8939          elementCnt = 12;
8940       ueSetReq->protocolIEs.list.count = elementCnt;
8941       ueSetReq->protocolIEs.list.size = elementCnt * sizeof(UEContextSetupRequestIEs_t *);
8942
8943       /* Initialize the UESetup members */
8944       CU_ALLOC(ueSetReq->protocolIEs.list.array,ueSetReq->protocolIEs.list.size);
8945
8946       if(ueSetReq->protocolIEs.list.array == NULLP)
8947       {
8948          DU_LOG("\nERROR  -->  F1AP : Memory allocation for UE Context SetupRequest failed");
8949          break;
8950       }
8951
8952       for(idx1=0; idx1<elementCnt; idx1++)
8953       {
8954          CU_ALLOC(ueSetReq->protocolIEs.list.array[idx1],sizeof(UEContextSetupRequestIEs_t));
8955          if(ueSetReq->protocolIEs.list.array[idx1] == NULLP)
8956          {
8957             break;
8958          }
8959       }
8960
8961       idx = 0;
8962
8963       /*GNB CU UE F1AP ID*/
8964       ueSetReq->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
8965       ueSetReq->protocolIEs.list.array[idx]->criticality        =       Criticality_reject;
8966       ueSetReq->protocolIEs.list.array[idx]->value.present = UEContextSetupRequestIEs__value_PR_GNB_CU_UE_F1AP_ID;
8967       ueSetReq->protocolIEs.list.array[idx]->value.choice.GNB_CU_UE_F1AP_ID = ueCb->gnbCuUeF1apId;
8968
8969       if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
8970       {
8971          /*GNB DU UE F1AP ID*/
8972          idx++;
8973          ueSetReq->protocolIEs.list.array[idx]->id      = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
8974          ueSetReq->protocolIEs.list.array[idx]->criticality     =       Criticality_ignore;
8975          ueSetReq->protocolIEs.list.array[idx]->value.present = UEContextSetupRequestIEs__value_PR_GNB_DU_UE_F1AP_ID;
8976          ueSetReq->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID = ueCb->gnbDuUeF1apId;
8977       }
8978
8979       /*Special Cell ID*/
8980       idx++;
8981       ueSetReq->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_SpCell_ID;
8982       ueSetReq->protocolIEs.list.array[idx]->criticality        =       Criticality_reject;
8983       ueSetReq->protocolIEs.list.array[idx]->value.present = UEContextSetupRequestIEs__value_PR_NRCGI;
8984       if(ueCb->state == UE_HANDOVER_IN_PROGRESS)
8985       {
8986          /* Spec 38.473 Sec 9.2.2.1 : For handover case, this IE shall be considered as target cell. */
8987          SEARCH_DU_DB(duIdx, ueCb->hoInfo.targetDuId, targetDuDb);
8988          /* Since we are supporting only one cell per DU, accessing 0th index to
8989           * get target cell info */
8990          spCellId = targetDuDb->cellCb[0].nrCellId;
8991       }
8992       else
8993          spCellId = ueCb->cellCb->nrCellId;
8994       Nrcgiret = BuildNrcgi(&ueSetReq->protocolIEs.list.array[idx]->value.choice.NRCGI, spCellId);
8995       if(Nrcgiret != ROK)
8996       {
8997          break;
8998       }
8999
9000       /*Served Cell Index*/
9001       idx++;
9002       ueSetReq->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_ServCellIndex;
9003       ueSetReq->protocolIEs.list.array[idx]->criticality        =       Criticality_reject;
9004       ueSetReq->protocolIEs.list.array[idx]->value.present = UEContextSetupRequestIEs__value_PR_ServCellIndex;
9005       ueSetReq->protocolIEs.list.array[idx]->value.choice.ServCellIndex = CELL_INDEX;
9006
9007       if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
9008       {
9009          /*CellULConfigured*/
9010          idx++;
9011          ueSetReq->protocolIEs.list.array[idx]->id      = ProtocolIE_ID_id_SpCellULConfigured;
9012          ueSetReq->protocolIEs.list.array[idx]->criticality     =       Criticality_ignore;
9013          ueSetReq->protocolIEs.list.array[idx]->value.present = UEContextSetupRequestIEs__value_PR_CellULConfigured;
9014          ueSetReq->protocolIEs.list.array[idx]->value.choice.CellULConfigured = CellULConfigured_none;
9015       }
9016
9017       /*CUtoDURRCContainer*/
9018       idx++;
9019       ueSetReq->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_CUtoDURRCInformation;
9020       ueSetReq->protocolIEs.list.array[idx]->criticality        =       Criticality_reject;
9021       ueSetReq->protocolIEs.list.array[idx]->value.present = UEContextSetupRequestIEs__value_PR_CUtoDURRCInformation;
9022       if(fillCuToDuContainer(ueCb, &ueSetReq->protocolIEs.list.array[idx]->value.choice.CUtoDURRCInformation))
9023       {
9024          break;
9025       }
9026
9027       if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
9028       {
9029          /*Special Cells to be SetupList*/
9030          idx++;
9031          ueSetReq->protocolIEs.list.array[idx]->id      = ProtocolIE_ID_id_SCell_ToBeSetup_List;
9032          ueSetReq->protocolIEs.list.array[idx]->criticality     =       Criticality_ignore;
9033          ueSetReq->protocolIEs.list.array[idx]->value.present = UEContextSetupRequestIEs__value_PR_SCell_ToBeSetup_List;
9034          SplCellListret = BuildSplCellList(ueCb, &ueSetReq->protocolIEs.list.array[idx]->value.choice.SCell_ToBeSetup_List);
9035          if(SplCellListret != ROK)
9036          {
9037             break;
9038          }
9039       }
9040
9041       /*SRBs To Be Setup List*/
9042       idx++;
9043       ueSetReq->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_SRBs_ToBeSetup_List;
9044       ueSetReq->protocolIEs.list.array[idx]->criticality        =       Criticality_reject;
9045       ueSetReq->protocolIEs.list.array[idx]->value.present = UEContextSetupRequestIEs__value_PR_SRBs_ToBeSetup_List;
9046       SrbSetupret = BuildSRBSetup(ueCb, &ueSetReq->protocolIEs.list.array[idx]->value.choice.SRBs_ToBeSetup_List);
9047       if(SrbSetupret != ROK)
9048       {
9049          break;
9050       }
9051
9052       /*DRBs to Be Setup List*/
9053       idx++;
9054       ueSetReq->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_DRBs_ToBeSetup_List;
9055       ueSetReq->protocolIEs.list.array[idx]->criticality        =       Criticality_reject;
9056       ueSetReq->protocolIEs.list.array[idx]->value.present = UEContextSetupRequestIEs__value_PR_DRBs_ToBeSetup_List;
9057       ret1 = BuildDRBSetup(duId, ueCb, &ueSetReq->protocolIEs.list.array[idx]->value.choice.DRBs_ToBeSetup_List);
9058       if(ret1 != ROK)
9059       {
9060          break;
9061       }
9062
9063       if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
9064       {
9065          /* RRC Container for security mode */
9066          idx++;
9067          ueSetReq->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_RRCContainer;
9068          ueSetReq->protocolIEs.list.array[idx]->criticality = Criticality_reject;
9069          ueSetReq->protocolIEs.list.array[idx]->value.present = UEContextSetupRequestIEs__value_PR_RRCContainer;
9070
9071          char secModeBuf[9]={0x00, 0x02, 0x22, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00};
9072          bufLen =9;
9073          ueSetReq->protocolIEs.list.array[idx]->value.choice.RRCContainer.size = bufLen;
9074          CU_ALLOC(ueSetReq->protocolIEs.list.array[idx]->value.choice.RRCContainer.buf,
9075                ueSetReq->protocolIEs.list.array[idx]->value.choice.RRCContainer.size);
9076          if(!ueSetReq->protocolIEs.list.array[idx]->value.choice.RRCContainer.buf)
9077          {
9078             DU_LOG("\nERROR  -->  F1AP : Memory allocation for BuildAndSendUeContextSetupReq failed");
9079             break;
9080          }
9081          memset(ueSetReq->protocolIEs.list.array[idx]->value.choice.RRCContainer.buf, 0, bufLen);
9082          memcpy(ueSetReq->protocolIEs.list.array[idx]->value.choice.RRCContainer.buf, secModeBuf, bufLen);
9083
9084          /* RRC delivery status request */
9085          idx++;
9086          ueSetReq->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_RRCDeliveryStatusRequest;
9087          ueSetReq->protocolIEs.list.array[idx]->criticality = Criticality_ignore;
9088          ueSetReq->protocolIEs.list.array[idx]->value.present = UEContextSetupRequestIEs__value_PR_RRCDeliveryStatusRequest;
9089          ueSetReq->protocolIEs.list.array[idx]->value.choice.RRCDeliveryStatusRequest = RRCDeliveryStatusRequest_true;
9090       }
9091
9092       /* GNB-DU UE Aggregate Maximum Bit Rate hardcoded as in reference logs */
9093       idx++;
9094       ueSetReq->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_GNB_DU_UE_AMBR_UL;
9095       ueSetReq->protocolIEs.list.array[idx]->criticality = Criticality_ignore;
9096       ueSetReq->protocolIEs.list.array[idx]->value.present = UEContextSetupRequestIEs__value_PR_BitRate;
9097
9098       char bitRateBuf[4]= {0x3B, 0x37, 0xF4, 0xCD};
9099       bufLen = 4;
9100       ueSetReq->protocolIEs.list.array[idx]->value.choice.BitRate.size = bufLen;
9101       CU_ALLOC(ueSetReq->protocolIEs.list.array[idx]->value.choice.BitRate.buf,\
9102             ueSetReq->protocolIEs.list.array[idx]->value.choice.BitRate.size);
9103       if(!ueSetReq->protocolIEs.list.array[idx]->value.choice.BitRate.buf)
9104       {
9105          DU_LOG("\nERROR  -->  F1AP : Failed to allocate memory for Bit Rate in BuildAndSendUeContextSetupReq()");
9106          break;
9107       }
9108       memset(ueSetReq->protocolIEs.list.array[idx]->value.choice.BitRate.buf, 0, bufLen);
9109       memcpy(ueSetReq->protocolIEs.list.array[idx]->value.choice.BitRate.buf, bitRateBuf, bufLen);
9110
9111       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
9112
9113       /* Encode the F1SetupRequest type as APER */
9114       memset(encBuf, 0, ENC_BUF_MAX_LEN);
9115       encBufSize = 0;
9116       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
9117
9118       /* Encode results */
9119       if(encRetVal.encoded == ENCODE_FAIL)
9120       {
9121          DU_LOG( "\nERROR  -->  F1AP : Could not encode UE Context Setup Request structure (at %s)\n",\
9122                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
9123          break;
9124       }
9125       else
9126       {
9127          DU_LOG("\nDEBUG  -->  F1AP : Created APER encodedbuffer for UE Context Setup Request\n");
9128          for(int i=0; i< encBufSize; i++)
9129          {
9130             DU_LOG("%x",encBuf[i]);
9131          }
9132       }
9133
9134       /* Sending  msg  */
9135       if(SendF1APMsg(CU_APP_MEM_REG, CU_POOL, duId)     !=      ROK)
9136       {
9137          DU_LOG("\nERROR  -->  F1AP : Sending UE Context Setup Request Failed");
9138          break;
9139       }
9140       ret = ROK;
9141       break;
9142    }
9143    FreeUeContextSetupReq(f1apMsg);
9144
9145    return ret;
9146 }/* End of BuildAndSendUeContextSetupReq*/
9147
9148 /**********************************************************************
9149  * @brief Function to extractTeId received in UE context setup Response
9150  *
9151  * @details
9152  *
9153  *    Function : extractTeId
9154  *
9155  *    Functionality:
9156  *         - Function to extract TeId
9157  *
9158  * @params[in]
9159  * @return ROK     - success
9160  *         RFAILED - failure
9161  *
9162  **********************************************************************/
9163 uint8_t extractTeId(DLUPTNLInformation_ToBeSetup_List_t *dlTnlInfo)
9164 {
9165    uint8_t arrIdx = 0;
9166    uint32_t teId = 0;
9167    GTPTunnel_t *gtpDl = NULLP;
9168
9169    for(arrIdx =0; arrIdx < dlTnlInfo->list.count; arrIdx++)
9170    {
9171       if(dlTnlInfo->list.array[arrIdx]->dLUPTNLInformation.present == UPTransportLayerInformation_PR_gTPTunnel)
9172       {
9173          if(dlTnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel != NULLP)
9174          {
9175             gtpDl = dlTnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel;
9176             if(gtpDl->gTP_TEID.size > 0)
9177             {
9178                teIdStringToInt(gtpDl->gTP_TEID.buf, &teId);
9179             }
9180             else
9181                DU_LOG("\nERROR  -->  EGTP: No TeId received");
9182             return(teId);
9183          }
9184       }
9185    }
9186    return teId;
9187 }
9188
9189 /****************************************************************
9190  * @brief Function to add Drb tunnels
9191  *
9192  * @details
9193  *
9194  *    Function : addDrbTunnels
9195  *
9196  *    Functionality:
9197  *         - Function to add Drb tunnels
9198  *
9199  * @params[in]
9200  * @return ROK     - success
9201  *         RFAILED - failure
9202  *
9203  * ****************************************************************/
9204 uint8_t addDrbTunnels(uint32_t duId, uint8_t teId)
9205 {
9206    uint8_t ret = ROK;
9207    EgtpTnlEvt tnlEvt;
9208
9209    if(teId > MAX_TEID || teId < MIN_TEID)
9210    {
9211       DU_LOG("\nERROR  -->  EGTP : TEID(%x) OUT Of Range",teId);
9212    }
9213    memset(&tnlEvt, 0, sizeof(EgtpTnlEvt));
9214    tnlEvt.action = EGTP_TNL_MGMT_ADD;
9215    tnlEvt.lclTeid = teId;
9216    tnlEvt.remTeid = teId;
9217    ret = cuEgtpTnlMgmtReq(duId, tnlEvt);
9218    if(ret != ROK)
9219    {
9220       DU_LOG("\nERROR  -->  EGTP : Tunnel management request failed for teId %x", teId);
9221    }
9222    return ROK;
9223 }
9224
9225 /****************************************************************
9226  * @brief Function to process Drb Setup List
9227  *
9228  * @details
9229  *
9230  *    Function : procDrbSetupList
9231  *
9232  *    Functionality:
9233  *         - Function to process DRB Setup List
9234  *
9235  * @params[in]
9236  * @return ROK     - success
9237  *         RFAILED - failure
9238  *
9239  * ****************************************************************/
9240 uint8_t procDrbSetupList(uint32_t duId, DRBs_Setup_List_t *drbSetupList)
9241 {
9242    uint8_t arrIdx = 0;
9243    uint32_t teId = 0;
9244    DRBs_Setup_ItemIEs_t *drbItemIe = NULLP;
9245
9246    if(drbSetupList != NULLP)
9247    {
9248       for(arrIdx = 0; arrIdx < drbSetupList->list.count; arrIdx++)
9249       {
9250          drbItemIe = ((DRBs_Setup_ItemIEs_t *)drbSetupList->list.array[arrIdx]);
9251          if(drbItemIe->value.present == DRBs_Setup_ItemIEs__value_PR_DRBs_Setup_Item)
9252          {
9253             /* extracting teId */
9254             teId  = extractTeId(&drbItemIe->value.choice.DRBs_Setup_Item.dLUPTNLInformation_ToBeSetup_List);
9255             if(teId > 0)
9256             {
9257               if(addDrbTunnels(duId, teId)== ROK)
9258               {
9259                 DU_LOG("\nDEBUG  --> EGTP: Tunnel Added for TeId %d", teId);
9260               }
9261             }
9262             else
9263                return RFAILED;
9264          }
9265       }
9266    }
9267    return ROK;
9268 }
9269
9270 /****************************************************************
9271  * @brief Function to process Ue Context Setup Response
9272  *
9273  * @details
9274  *
9275  *    Function : procUeContextSetupResponse
9276  *
9277  *    Functionality:
9278  *         - Function to process Ue Context Setup Response
9279  *
9280  * @params[in]
9281  * @return ROK     - success
9282  *         RFAILED - failure
9283  *
9284  * ****************************************************************/
9285 uint8_t procUeContextSetupResponse(uint32_t duId, F1AP_PDU_t *f1apMsg)
9286 {
9287    uint8_t duIdx = 0, idx = 0, ueIdx = 0;
9288    uint8_t duUeF1apId = 0, cuUeF1apId = 0;
9289    DuDb *duDb = NULLP;
9290    CuUeCb *ueCb = NULLP;
9291    UEContextSetupResponse_t *ueCtxtSetupRsp = NULLP;
9292    OCTET_STRING_t *duToCuRrcContainer;
9293
9294    SEARCH_DU_DB(duIdx, duId, duDb);
9295    ueCtxtSetupRsp = &f1apMsg->choice.successfulOutcome->value.choice.UEContextSetupResponse;
9296
9297    for(idx=0; idx < ueCtxtSetupRsp->protocolIEs.list.count; idx++)
9298    {
9299       switch(ueCtxtSetupRsp->protocolIEs.list.array[idx]->id)
9300       {
9301           case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
9302              {
9303                cuUeF1apId = ueCtxtSetupRsp->protocolIEs.list.array[idx]->value.choice.GNB_CU_UE_F1AP_ID;
9304                break;
9305              }
9306           case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
9307              {
9308                 duUeF1apId = ueCtxtSetupRsp->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID;
9309                 ueCb = &duDb->ueCb[duUeF1apId-1];
9310                 /* If ue context is not present in du db, then create UE context
9311                  * here. This flow is hit in case of UE handover where UE
9312                  * context is created before UE performs RACH on target DU */
9313                 if(ueCb->gnbDuUeF1apId == 0)
9314                 {
9315                    /* Creating UE context in target DU */
9316                    memset(ueCb, 0, sizeof(CuUeCb));
9317                    ueCb->cellCb = &duDb->cellCb[0];
9318                    ueCb->gnbDuUeF1apId = duUeF1apId;
9319                    ueCb->gnbCuUeF1apId = cuUeF1apId;
9320                    ueCb->state = UE_HANDOVER_IN_PROGRESS;
9321                    ueCb->hoInfo.targetDuId = duId;
9322                    (duDb->numUe)++;
9323
9324                    ueCb->cellCb->ueCb[ueCb->cellCb->numUe] = ueCb;
9325                    ueCb->cellCb->numUe++;
9326                 }
9327                 break;
9328              }
9329           case ProtocolIE_ID_id_C_RNTI:
9330              {
9331                 ueCb->crnti = ueCtxtSetupRsp->protocolIEs.list.array[idx]->value.choice.C_RNTI;
9332                 break;
9333              }
9334           case ProtocolIE_ID_id_DRBs_Setup_List:
9335              {
9336                 /* Adding Tunnels for successful DRB */
9337                 procDrbSetupList(duId, &ueCtxtSetupRsp->protocolIEs.list.array[idx]->value.choice.DRBs_Setup_List);
9338                 break;
9339              }
9340          case ProtocolIE_ID_id_DUtoCURRCInformation:
9341              {
9342                 DU_LOG("\nINFO  -->  Received Du to Cu RRC Information ");
9343                 duToCuRrcContainer = &ueCtxtSetupRsp->protocolIEs.list.array[idx]->value.choice.\
9344                    DUtoCURRCInformation.cellGroupConfig;
9345                 if((extractDuToCuRrcCont(ueCb, ueCtxtSetupRsp->protocolIEs.list.array[idx]->value.choice.\
9346                    DUtoCURRCInformation.cellGroupConfig)) != ROK)
9347                 {
9348                    DU_LOG("\nERROR  -->  F1AP: Failed to extract Du to Cu RRC Information ");
9349                    return RFAILED;
9350                 }
9351                 break;
9352              }
9353       }
9354    }
9355
9356    ueCb->f1apMsgDb.dlRrcMsgCount++; /* keeping DL RRC Msg Count */
9357
9358    /* If the UE is in handover, UE context modification request is to be sent to
9359     * source DU once UE context setup response is received from target DU */
9360    if(ueCb->state == UE_HANDOVER_IN_PROGRESS)
9361    {
9362       DuDb *srcDuDb = NULLP;
9363       CuUeCb *ueCbInSrcDu = NULLP;
9364
9365       /* Since Source DU Id and DU UE F1AP ID assigned to UE by source DU is not known here, we
9366        * need to find Source DU and UE CB in source DU using CU UE F1AP ID */
9367       for(duIdx=0; duIdx < cuCb.numDu; duIdx++)
9368       {
9369          /* UE context setup response is received from target DU. Search all
9370           * DUs to find source DU except this target DU Id.*/
9371          if(cuCb.duInfo[duIdx].duId != duId)
9372          {
9373             for(ueIdx = 0; ueIdx < MAX_NUM_UE; ueIdx++)
9374             {
9375                /* Check following:
9376                 * 1. CU UE F1AP ID in srcDU->ueCb should be same as cuUeF1apId
9377                 * received in UE context setup response since CU UE F1AP ID does not
9378                 * change for UE in handover.
9379                 * 2. srcDU->UeCb->uestate should be UE_HANDOVER_IN_PROGRESS
9380                 */
9381                if((cuCb.duInfo[duIdx].ueCb[ueIdx].gnbCuUeF1apId == cuUeF1apId) &&
9382                      (cuCb.duInfo[duIdx].ueCb[ueIdx].state == UE_HANDOVER_IN_PROGRESS))
9383                {
9384                   srcDuDb = &cuCb.duInfo[duIdx];
9385                   ueCbInSrcDu = &cuCb.duInfo[duIdx].ueCb[ueIdx];
9386
9387                   /* Store source DU info in the new UE context created in
9388                    * tareget DU */
9389                   ueCb->hoInfo.sourceDuId = srcDuDb->duId;
9390
9391                   /* Copy the received container to UeCb */
9392                   memcpy(&ueCbInSrcDu->f1apMsgDb.duToCuContainer, duToCuRrcContainer, sizeof(OCTET_STRING_t));
9393
9394                   if(BuildAndSendUeContextModificationReq(srcDuDb->duId, ueCbInSrcDu, STOP_DATA_TX) != ROK)
9395                   {
9396                      DU_LOG("\nERROR  ->  F1AP : Failed at BuildAndSendUeContextModificationReq()");
9397                      return RFAILED;
9398                   }
9399                   break;
9400                }
9401             }
9402          }
9403          if(srcDuDb && ueCbInSrcDu)
9404             break;
9405       }
9406    }
9407    return ROK;
9408 }
9409
9410 /****************************************************************
9411  * @brief Function to process Ul Rrc Msg received from DU
9412  *
9413  * @details
9414  *
9415  *    Function : procUlRrcMsg
9416  *
9417  *    Functionality:
9418  *         - Function to process Ul Rrc Msg received from DU
9419  *
9420  * @params[in]
9421  * @return ROK     - success
9422  *         RFAILED - failure
9423  *
9424  * ****************************************************************/
9425
9426 uint8_t procUlRrcMsg(uint32_t duId, F1AP_PDU_t *f1apMsg)
9427 {
9428    uint8_t idx, ret, srbId, rrcMsgType, duIdx=0;
9429    uint8_t cuUeF1apId, duUeF1apId;
9430    uint8_t *rrcContainer = NULLP;
9431    uint16_t rrcContLen;
9432    DuDb     *duDb;
9433    CuUeCb   *ueCb;
9434    ULRRCMessageTransfer_t *ulRrcMsg = NULLP;
9435
9436    ret = ROK;
9437    SEARCH_DU_DB(duIdx, duId, duDb);
9438    ulRrcMsg = &f1apMsg->choice.initiatingMessage->value.choice.ULRRCMessageTransfer;
9439
9440    for(idx=0; idx < ulRrcMsg->protocolIEs.list.count; idx++)
9441    {
9442       switch(ulRrcMsg->protocolIEs.list.array[idx]->id)
9443       {
9444          case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
9445             {
9446                cuUeF1apId = ulRrcMsg->protocolIEs.list.array[idx]->value.choice.GNB_CU_UE_F1AP_ID;
9447                break;
9448             }
9449          case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
9450             {
9451                duUeF1apId = ulRrcMsg->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID;
9452                break;
9453             }
9454          case ProtocolIE_ID_id_SRBID:
9455             srbId = ulRrcMsg->protocolIEs.list.array[idx]->value.choice.SRBID;
9456             break;
9457
9458          case ProtocolIE_ID_id_RRCContainer:
9459             {
9460                rrcContLen = ulRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.size;
9461                CU_ALLOC(rrcContainer, rrcContLen);
9462                if(!rrcContainer)
9463                {
9464                   DU_LOG("\nERROR  -->  F1AP : Failed to allocated memory in procUlRrcMsg");
9465                   return RFAILED;
9466                }
9467                memcpy(rrcContainer, ulRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.buf, rrcContLen);
9468
9469                if(duDb->ueCb[duUeF1apId-1].state == UE_HANDOVER_IN_PROGRESS)
9470                   return;
9471
9472                break;
9473             }
9474
9475          default:
9476             DU_LOG("\nERROR  -->  F1AP : Invalid Event %ld", ulRrcMsg->protocolIEs.list.array[idx]->id);
9477             break;
9478       }
9479    }
9480
9481    if(srbId == 1)
9482    {
9483       ueCb = &duDb->ueCb[duUeF1apId-1];
9484       ueCb->f1apMsgDb.dlRrcMsgCount++;
9485       rrcMsgType = setDlRRCMsgType(ueCb);
9486       if(rrcMsgType == REGISTRATION_ACCEPT)
9487       {
9488          DU_LOG("\nINFO  -->  F1AP: Sending DL RRC MSG for RRC Registration Accept");
9489          ret = BuildAndSendDLRRCMessageTransfer(duId, ueCb, srbId, rrcMsgType);
9490       }
9491       if(rrcMsgType == UE_CONTEXT_SETUP_REQ)
9492       {
9493          DU_LOG("\nINFO  -->  F1AP: Sending Ue Context Setup Req");
9494          ret = BuildAndSendUeContextSetupReq(duId, ueCb, rrcContLen, rrcContainer);
9495       }
9496       if(rrcMsgType == SECURITY_MODE_COMPLETE)
9497       {
9498          /* To trigger the DL RRC Msg for RRC Reconfig */
9499          ueCb->f1apMsgDb.dlRrcMsgCount++;
9500          rrcMsgType = setDlRRCMsgType(ueCb);
9501          if(rrcMsgType == RRC_RECONFIG)
9502          {
9503             DU_LOG("\nINFO  -->  F1AP: Sending DL RRC MSG for RRC Reconfig");
9504             BuildAndSendDLRRCMessageTransfer(duId, ueCb, srbId, rrcMsgType);
9505          }
9506       }
9507       if(rrcMsgType == RRC_RECONFIG_COMPLETE)
9508       {
9509          ueCb->state = UE_ACTIVE;
9510          ueCb->f1apMsgDb.dlRrcMsgCount++;
9511          rrcMsgType = setDlRRCMsgType(ueCb);
9512          if(rrcMsgType == UE_CONTEXT_MOD_REQ)
9513          {
9514             DU_LOG("\nINFO  -->  F1AP: Sending UE Context Modification Request");
9515             BuildAndSendUeContextModificationReq(duId, ueCb, RRC_RECONFIG_COMPLETE_IND);
9516          }
9517       }
9518    }
9519    return ret;
9520 }
9521
9522 /****************************************************************
9523  * @brief Build And Send F1ResetAck
9524  *
9525  * @details
9526  *
9527  *    Function : FreeF1ResetAck
9528  *
9529  *    Functionality:
9530  *         - Build And Send  F1ResetRSP
9531  *
9532  *  @params[in]
9533  * @return ROK     - success
9534  *         RFAILED - failure
9535  *
9536  * ****************************************************************/
9537 void FreeF1ResetAck(F1AP_PDU_t *f1apMsg)
9538 {
9539    uint8_t idx;
9540    ResetAcknowledge_t *f1ResetAck;
9541
9542    if(f1apMsg)
9543    {
9544       if(f1apMsg->choice.successfulOutcome)
9545       {
9546          f1ResetAck= &f1apMsg->choice.successfulOutcome->value.choice.ResetAcknowledge;
9547
9548          if(f1ResetAck->protocolIEs.list.array)
9549          {
9550             for(idx=0; idx<f1ResetAck->protocolIEs.list.count ; idx++)
9551             {
9552                if(f1ResetAck->protocolIEs.list.array[idx])
9553                {
9554                   CU_FREE(f1ResetAck->protocolIEs.list.array[idx], sizeof(ResetAcknowledgeIEs_t));
9555                }
9556             }
9557             CU_FREE(f1ResetAck->protocolIEs.list.array, f1ResetAck->protocolIEs.list.size );
9558          }
9559          CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
9560       }
9561       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
9562    }
9563 }
9564
9565 /****************************************************************
9566  * @brief Build And Send F1ResetAck
9567  *
9568  * @details
9569  *
9570  *    Function : BuildAndSendF1ResetAck
9571  *
9572  *    Functionality:
9573  *         - Build And Send  F1ResetRSP
9574  *
9575  *  @params[in]
9576  * @return ROK     - success
9577  *         RFAILED - failure
9578  *
9579  * ****************************************************************/
9580
9581 uint8_t BuildAndSendF1ResetAck()
9582 {
9583    uint8_t                idx = 0;
9584    uint8_t                elementCnt = 0;
9585    uint8_t                ret = RFAILED;
9586    F1AP_PDU_t             *f1apMsg = NULL;
9587    ResetAcknowledge_t     *f1ResetAck = NULLP;
9588    asn_enc_rval_t         encRetVal;
9589    DU_LOG("\nINFO  -->  F1AP : Building F1 Reset Acknowledgment \n");
9590
9591    do{
9592       /* Allocate the memory for F1ResetRequest_t */
9593       CU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
9594       if(f1apMsg == NULLP)
9595       {
9596          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
9597          break;
9598       }
9599
9600       f1apMsg->present =  F1AP_PDU_PR_successfulOutcome;
9601
9602       CU_ALLOC(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
9603       if(f1apMsg->choice.successfulOutcome == NULLP)
9604       {
9605          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
9606          break;
9607       }
9608
9609       f1apMsg->choice.successfulOutcome->procedureCode = ProcedureCode_id_Reset;
9610       f1apMsg->choice.successfulOutcome->criticality   = Criticality_reject;
9611       f1apMsg->choice.successfulOutcome->value.present = SuccessfulOutcome__value_PR_ResetAcknowledge;
9612       f1ResetAck = &f1apMsg->choice.successfulOutcome->value.choice.ResetAcknowledge;
9613
9614       elementCnt = 1;
9615
9616       f1ResetAck->protocolIEs.list.count = elementCnt;
9617       f1ResetAck->protocolIEs.list.size = elementCnt*sizeof(ResetAcknowledgeIEs_t *);
9618
9619       CU_ALLOC(f1ResetAck->protocolIEs.list.array, f1ResetAck->protocolIEs.list.size );
9620       if(f1ResetAck->protocolIEs.list.array == NULLP)
9621       {
9622          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1ResetAckIEs failed");
9623          break;
9624       }
9625
9626       for(idx=0; idx<elementCnt; idx++)
9627       {
9628          CU_ALLOC(f1ResetAck->protocolIEs.list.array[idx], sizeof(ResetAcknowledgeIEs_t));
9629          if(f1ResetAck->protocolIEs.list.array[idx] == NULLP)
9630          {
9631             break;
9632          }
9633       }
9634       /*TransactionID*/
9635       idx = 0;
9636       f1ResetAck->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_TransactionID;
9637       f1ResetAck->protocolIEs.list.array[idx]->criticality = Criticality_reject;
9638       f1ResetAck->protocolIEs.list.array[idx]->value.present = ResetAcknowledgeIEs__value_PR_TransactionID;
9639       f1ResetAck->protocolIEs.list.array[idx]->value.choice.TransactionID = TRANS_ID;
9640
9641       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
9642
9643       /* Encode the F1SetupRequest type as UPER */
9644       memset(encBuf, 0, ENC_BUF_MAX_LEN);
9645       encBufSize = 0;
9646       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
9647
9648       /* Check encode results */
9649       if(encRetVal.encoded == ENCODE_FAIL)
9650       {
9651          DU_LOG("\nERROR  -->  F1AP : Could not encode F1ResetAck structure (at %s)\n",\
9652                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
9653          break;
9654       }
9655       else
9656       {
9657          DU_LOG("\nDEBUG  -->  F1AP : Created APER encodedbuffer for F1ResetAck \n");
9658          for(int i=0; i< encBufSize; i++)
9659          {
9660             DU_LOG("%x",encBuf[i]);
9661          }
9662       }
9663
9664       /* Sending msg */
9665       /* TODO : Hardcoding DU ID to 1 for messages other than F1 Setup Response. This will be made generic in future gerrit */
9666       if(SendF1APMsg(CU_APP_MEM_REG, CU_POOL, DU_ID) != ROK)
9667       {
9668          DU_LOG("\nERROR  -->  F1AP : Sending F1 Reset Response failed");
9669          break;
9670       }
9671
9672       ret = ROK;
9673       break;
9674    }while(true);
9675
9676    FreeF1ResetAck(f1apMsg);
9677    return ret;
9678 }
9679
9680 void FreeUlTnlInfoforDrb2(ULUPTNLInformation_ToBeSetup_List_t *ulInfo)
9681 {
9682    uint8_t arrIdx =0;
9683
9684    if(ulInfo->list.array)
9685    {
9686       for(arrIdx=0; arrIdx<ulInfo->list.count ; arrIdx++)
9687       {
9688          if(ulInfo->list.array[arrIdx])
9689          {
9690             if(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel )
9691             {
9692                if(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf)
9693                {
9694                   if(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf)
9695                   {
9696                      CU_FREE(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
9697                      gTP_TEID.buf,ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.\
9698                      gTPTunnel->gTP_TEID.size);
9699                   }
9700                   CU_FREE(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
9701                   transportLayerAddress.buf,ulInfo->list.array[arrIdx]->\
9702                   uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.size);
9703                }
9704                CU_FREE(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel,\
9705                sizeof(GTPTunnel_t));
9706             }
9707             CU_FREE(ulInfo->list.array[arrIdx],sizeof(ULUPTNLInformation_ToBeSetup_Item_t));
9708          }
9709       }
9710       CU_FREE(ulInfo->list.array,ulInfo->list.size);
9711    }
9712 }
9713
9714 /*******************************************************************
9715 *
9716 * @brief Deletes the EGTP tunnel
9717 *
9718 * @details
9719 *
9720 *    Function : deleteEgtpTunnel
9721 *
9722 *    Functionality: Deletes the EGTP tunnel
9723 *
9724 * @params[in] uint8_t *buf
9725 *
9726 * @return ROK     - success
9727 *         RFAILED - failure
9728 *
9729 * ****************************************************************/
9730 uint8_t deleteEgtpTunnel(uint32_t duId, uint8_t *buf)
9731 {
9732    uint32_t teId = 0;
9733    EgtpTnlEvt tnlEvt;
9734
9735    teIdStringToInt(buf, &teId);
9736    if(teId > MAX_TEID || teId < MIN_TEID)
9737    {
9738       DU_LOG("\nERROR  -->  EGTP : TEID(%d) OUT Of Range", teId);
9739       return RFAILED;
9740    }
9741    memset(&tnlEvt, 0, sizeof(EgtpTnlEvt));
9742    tnlEvt.action = EGTP_TNL_MGMT_DEL;
9743    tnlEvt.lclTeid = teId;
9744    tnlEvt.remTeid = teId;
9745    if((cuEgtpTnlMgmtReq(duId, tnlEvt)) != ROK)
9746    {
9747       DU_LOG("\nERROR  -->  EGTP : Failed to delete tunnel Id %d", teId);
9748    }
9749    return ROK;
9750 }
9751
9752 /*******************************************************************
9753 *
9754 * @brief Builds the Uplink Tunnel Info
9755 *
9756 * @details
9757 *
9758 *    Function : BuildUlTnlInfoforSetupMod
9759 *
9760 *    Functionality: Constructs the UL TnlInfo For DRB list
9761 *
9762 * @params[in] ULUPTNLInformation_ToBeSetup_List_t *ulInfo
9763 *
9764 * @return ROK     - success
9765 *         RFAILED - failure
9766 *
9767 * ****************************************************************/
9768 uint8_t BuildUlTnlInfoforSetupMod(uint32_t duId, uint8_t ueId, uint8_t drbId, TnlInfo *ulTnlInfo, ULUPTNLInformation_ToBeSetup_List_t *ulInfo, uint8_t actionType)
9769 {
9770    uint8_t arrIdx;
9771    uint8_t ulCnt;
9772
9773    ulCnt = 1;
9774    ulInfo->list.count = ulCnt;
9775    ulInfo->list.size = ulCnt * sizeof(ULUPTNLInformation_ToBeSetup_Item_t *);
9776    CU_ALLOC(ulInfo->list.array,ulInfo->list.size);
9777    if(ulInfo->list.array == NULLP)
9778    {
9779       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildUlTnlInfoforSetupMod");
9780       return RFAILED;
9781    }
9782    for(arrIdx=0; arrIdx<ulCnt; arrIdx++)
9783    {
9784       CU_ALLOC(ulInfo->list.array[arrIdx],sizeof(ULUPTNLInformation_ToBeSetup_Item_t));
9785       if(ulInfo->list.array[arrIdx] == NULLP)
9786       {
9787          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildUlTnlInfoforSetupMod");
9788          return RFAILED;
9789       }
9790    }
9791
9792    arrIdx = 0;
9793    ulInfo->list.array[arrIdx]->uLUPTNLInformation.present = \
9794    UPTransportLayerInformation_PR_gTPTunnel;
9795
9796    /*GTP TUNNEL*/
9797    CU_ALLOC(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel,\
9798          sizeof(GTPTunnel_t));
9799    if(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel == NULLP)
9800    {
9801       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildUlTnlInfoforSetupMod");
9802       return RFAILED;
9803    }
9804    ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
9805       transportLayerAddress.size        = 4*sizeof(uint8_t);
9806    CU_ALLOC(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
9807          transportLayerAddress.buf,ulInfo->list.array[arrIdx]->\
9808          uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.size);
9809    if(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
9810          transportLayerAddress.buf == NULLP)
9811    {
9812       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildUlTnlInfoforSetupMod");
9813       return RFAILED;
9814    }
9815
9816    ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
9817       transportLayerAddress.buf[0] = 192;
9818    ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
9819       transportLayerAddress.buf[1] = 168;
9820    ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
9821       transportLayerAddress.buf[2] = 130;
9822    ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
9823       transportLayerAddress.buf[3] = 82;
9824    ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
9825       transportLayerAddress.bits_unused = 0;
9826
9827    ulTnlInfo->address[0] = ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[0];
9828    ulTnlInfo->address[1] = ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[1];
9829    ulTnlInfo->address[2] = ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[2];
9830    ulTnlInfo->address[3] = ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf[3];
9831
9832    /*GTP TEID*/
9833    ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.size\
9834       = 4 * sizeof(uint8_t);
9835    CU_ALLOC(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
9836          gTP_TEID.buf,ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.\
9837          gTPTunnel->gTP_TEID.size);
9838    if(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf\
9839          == NULLP)
9840    {
9841       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildUlTnlInfoforSetupMod");
9842       return RFAILED;
9843    }
9844    ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
9845       gTP_TEID.buf[0] = 0;
9846    ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
9847       gTP_TEID.buf[1] = 0;
9848    ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
9849       gTP_TEID.buf[2] = 0;
9850    if(actionType == ProtocolIE_ID_id_DRBs_ToBeModified_Item)
9851    {
9852      /*TODO: DRB context to be stored in CU STUB so that tunnel Id can be easily
9853       * fetched based on the Drb Id */
9854
9855      /*For For UE Id=1, DRB=2 is modified. For UE Id = 2, DRB=5 is modified and so on.*/
9856       ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[3]=\
9857                                                         (MAX_NUM_DRB_ADDED_PER_UE *(ueId  - 1)) + drbId;
9858    }
9859    else
9860    {
9861       ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
9862         gTP_TEID.buf[3] = cuCb.cuCfgParams.egtpParams.currTunnelId++;
9863    }
9864
9865    ulTnlInfo->teId[0] = ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[0];
9866    ulTnlInfo->teId[1] = ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[1];
9867    ulTnlInfo->teId[2] = ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[2];
9868    ulTnlInfo->teId[3] = ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf[3];
9869    return ROK;
9870 }/*End of BuildULTnlInfo*/
9871
9872 /*******************************************************************
9873 *
9874 * @brief freeing the DRB item
9875 *
9876 * @details
9877 *
9878 *    Function : FreeDrbItem
9879 *
9880 *    Functionality: freeing the DRB item
9881 *
9882 * @params[in] DRBs_ToBeSetupMod_Item_t *drbItem
9883 *
9884 * @return ROK     - success
9885 *         RFAILED - failure
9886 *
9887 * ****************************************************************/
9888
9889 void FreeDrbItem(DRBs_ToBeSetupMod_Item_t *drbItem)
9890 {
9891    uint8_t arrIdx =0;
9892    SNSSAI_t *snssai =NULLP;
9893    Flows_Mapped_To_DRB_List_t *flowMap = NULLP;
9894
9895    drbItem->qoSInformation.present = QoSInformation_PR_choice_extension;
9896    switch(drbItem->qoSInformation.present)
9897    {
9898       case QoSInformation_PR_NOTHING:
9899          break;
9900       case QoSInformation_PR_eUTRANQoS:
9901          {
9902             if(drbItem->qoSInformation.choice.eUTRANQoS)
9903             {
9904                CU_FREE(drbItem->qoSInformation.choice.eUTRANQoS, sizeof(EUTRANQoS_t));
9905             }
9906             break;
9907          }
9908       case QoSInformation_PR_choice_extension:
9909          {
9910             if(drbItem->qoSInformation.choice.choice_extension)
9911             {
9912                FreeQOSInfo(&drbItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS);
9913
9914                snssai = &drbItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI;
9915                if(snssai->sST.buf)
9916                {
9917                   CU_FREE(snssai->sST.buf,snssai->sST.size);
9918                }
9919                if(snssai->sD)
9920                {
9921                   if(snssai->sD->buf)
9922                   {
9923                      CU_FREE(snssai->sD->buf,snssai->sD->size);
9924                   }
9925                   CU_FREE(snssai->sD,sizeof(OCTET_STRING_t));
9926                }
9927
9928                flowMap = &drbItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.flows_Mapped_To_DRB_List;
9929                if(flowMap->list.array)
9930                {
9931                   for(arrIdx=0; arrIdx<flowMap->list.count; arrIdx++)
9932                   {
9933                      if(flowMap->list.array[arrIdx] )
9934                      {
9935                         FreeQOSInfo(&flowMap->list.array[arrIdx]->qoSFlowLevelQoSParameters);
9936                         CU_FREE(flowMap->list.array[arrIdx],sizeof(Flows_Mapped_To_DRB_Item_t));
9937                      }
9938                   }
9939                   CU_FREE(flowMap->list.array,flowMap->list.size);
9940                }
9941
9942                CU_FREE(drbItem->qoSInformation.choice.choice_extension,sizeof(QoSInformation_ExtIEs_t));
9943             }
9944             break;
9945          }
9946
9947    }
9948    FreeUlTnlInfoforDrb2(&drbItem->uLUPTNLInformation_ToBeSetup_List);
9949    if(drbItem->uLConfiguration)
9950    {
9951       CU_FREE(drbItem->uLConfiguration,sizeof(ULConfiguration_t));
9952    }
9953 }
9954
9955 /*******************************************************************
9956 *
9957 * @brief filling the DRB setup Mod item
9958 *
9959 * @details
9960 *
9961 *    Function : FillDrbItemToSetupMod
9962 *
9963 *    Functionality: filling the DRB setup Mod item
9964 *
9965 *
9966 * @params[in] DRBs_ToBeSetupMod_Item_t *drbItem
9967 *
9968 * @return ROK     - success
9969 *         RFAILED - failure
9970 *
9971 * ****************************************************************/
9972
9973 uint8_t FillDrbItemToSetupMod(uint32_t duId, CuUeCb *ueCb, uint8_t arrIdx, DRBs_ToBeSetupMod_Item_t *drbItem)
9974 {
9975    uint8_t ret = ROK;
9976
9977    /*Drb Id */
9978    drbItem->dRBID = arrIdx + DRB_ID_TO_ADD_MOD;
9979    ueCb->drbList[ueCb->numDrb].drbId = drbItem->dRBID;
9980
9981    /*qoSInformation*/
9982    drbItem->qoSInformation.present = QoSInformation_PR_choice_extension;
9983
9984    switch(drbItem->qoSInformation.present)
9985    {
9986       case QoSInformation_PR_NOTHING:
9987       {
9988          break;
9989       }
9990       case QoSInformation_PR_eUTRANQoS:
9991       {
9992
9993          CU_ALLOC(drbItem->qoSInformation.choice.eUTRANQoS, sizeof(EUTRANQoS_t));
9994          if(drbItem->qoSInformation.choice.eUTRANQoS)
9995          {
9996             DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in FillDrbItemToSetupMod");
9997             return RFAILED;
9998          }
9999          drbItem->qoSInformation.choice.eUTRANQoS->qCI = QCI;
10000          drbItem->qoSInformation.choice.eUTRANQoS->allocationAndRetentionPriority.priorityLevel =
10001             PriorityLevel_no_priority;
10002
10003          drbItem->qoSInformation.choice.eUTRANQoS->allocationAndRetentionPriority.pre_emptionCapability =
10004             Pre_emptionCapability_may_trigger_pre_emption;
10005
10006          drbItem->qoSInformation.choice.eUTRANQoS->allocationAndRetentionPriority.pre_emptionVulnerability =
10007             Pre_emptionVulnerability_pre_emptable;
10008
10009          break;
10010       }
10011       case QoSInformation_PR_choice_extension:
10012       {
10013          CU_ALLOC(drbItem->qoSInformation.choice.choice_extension,sizeof(QoSInformation_ExtIEs_t));
10014          if(drbItem->qoSInformation.choice.choice_extension == NULLP)
10015          {
10016             DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in FillDrbItemToSetupMod");
10017             return RFAILED;
10018          }
10019
10020          drbItem->qoSInformation.choice.choice_extension->id = ProtocolIE_ID_id_DRB_Information;
10021          drbItem->qoSInformation.choice.choice_extension->criticality = Criticality_ignore;
10022          drbItem->qoSInformation.choice.choice_extension->value.present = QoSInformation_ExtIEs__value_PR_DRB_Information;
10023          ret =  BuildQOSInfo(&ueCb->drbList[ueCb->numDrb].qos, &drbItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS,\
10024            ProtocolIE_ID_id_DRBs_ToBeSetupMod_Item, PDU_SESSION_ID_2, FALSE);
10025          if(ret != ROK)
10026          {
10027             DU_LOG("\nERROR  -->  F1AP : BuildQOSInfo failed");
10028             return RFAILED;
10029          }
10030
10031          /*SNSSAI*/
10032          ret = BuildSNSSAI(&ueCb->drbList[ueCb->numDrb], &drbItem->qoSInformation.choice.\
10033                choice_extension->value.choice.DRB_Information.sNSSAI, cuCb.snssaiList[1], FALSE);
10034          if(ret != ROK)
10035          {
10036             DU_LOG("\nERROR  -->  F1AP : BuildSNSSAI failed");
10037             return RFAILED;
10038          }
10039
10040          /*Flows mapped to DRB List*/
10041          ret = BuildFlowsMap(&ueCb->drbList[ueCb->numDrb], &drbItem->qoSInformation.choice.\
10042                choice_extension->value.choice.DRB_Information.flows_Mapped_To_DRB_List,\
10043           ProtocolIE_ID_id_DRBs_ToBeSetupMod_Item, FALSE);
10044          if(ret != ROK)
10045          {
10046             DU_LOG("\nERROR  -->  F1AP : BuildFlowsMap failed");
10047             return RFAILED;
10048          }
10049       }
10050    }
10051
10052    /*ULUPTNLInformation To Be Setup List*/
10053    ret = BuildUlTnlInfoforSetupMod(duId, ueCb->gnbCuUeF1apId, drbItem->dRBID, &ueCb->drbList[ueCb->numDrb].ulUpTnlInfo, \
10054       &drbItem->uLUPTNLInformation_ToBeSetup_List, ProtocolIE_ID_id_DRBs_ToBeSetupMod_Item);
10055    if(ret != ROK)
10056    {
10057       DU_LOG("\nERROR  -->  F1AP : BuildUlTnlInfoforSetupMod failed");
10058       return RFAILED;
10059    }
10060
10061    /*RLCMode*/
10062    drbItem->rLCMode = RLCMode_rlc_um_bidirectional;
10063    ueCb->drbList[ueCb->numDrb].rlcMode = drbItem->rLCMode;
10064
10065    ueCb->numDrb++;
10066    return ROK;
10067 }
10068
10069 /*******************************************************************
10070 *
10071 * @brief Builds the DRB to be Setup Mod ItemIes
10072 *
10073 * @details
10074 *
10075 *    Function : FillDrbItemList
10076 *
10077 *    Functionality: Constructs the DRB to be Setup Mod Item Ies
10078 *
10079 * @params[in] struct DRBs_ToBeSetupMod_ItemIEs *drbItemIe
10080 *
10081 * @return ROK     - success
10082 *         RFAILED - failure
10083 *
10084 * ****************************************************************/
10085
10086 uint8_t FillDrbItemList(uint32_t duId, CuUeCb *ueCb, uint8_t arrIdx, struct DRBs_ToBeSetupMod_ItemIEs *drbItemIe)
10087 {
10088    drbItemIe->id = ProtocolIE_ID_id_DRBs_ToBeSetupMod_Item;
10089    drbItemIe->criticality = Criticality_reject;
10090    drbItemIe->value.present = DRBs_ToBeSetupMod_ItemIEs__value_PR_DRBs_ToBeSetupMod_Item;
10091
10092    if(FillDrbItemToSetupMod(duId, ueCb, arrIdx, (&(drbItemIe->value.choice.DRBs_ToBeSetupMod_Item))) != ROK)
10093    {
10094       DU_LOG("\nERROR  -->  F1AP : FillDrbItemToSetupMod failed");
10095       return RFAILED;
10096    }
10097    return ROK;
10098 }
10099 /*******************************************************************
10100 *
10101 * @brief free the DRB to be Setup Mod list
10102 *
10103 * @details
10104 *
10105 *    Function : FreeDrbToBeSetupModList
10106 *
10107 *    Functionality: free the DRB to be Setup Mod list
10108 *
10109 * @params[in] DRBs_ToBeSetupMod_List_t *drbSet
10110 *
10111 * @return ROK     - success
10112 *         RFAILED - failure
10113 *
10114 * ****************************************************************/
10115 void FreeDrbToBeSetupModList(DRBs_ToBeSetupMod_List_t *drbSet)
10116 {
10117    uint8_t arrIdx =0;
10118    struct DRBs_ToBeSetupMod_ItemIEs *drbItemIe;
10119
10120    if(drbSet->list.array)
10121    {
10122       for(arrIdx=0; arrIdx<drbSet->list.count ; arrIdx++)
10123       {
10124          if(drbSet->list.array[arrIdx] != NULLP)
10125          {
10126             if(arrIdx == 0)
10127             {
10128                drbItemIe = (DRBs_ToBeSetupMod_ItemIEs_t *)drbSet->list.array[arrIdx];
10129                FreeDrbItem(&(drbItemIe->value.choice.DRBs_ToBeSetupMod_Item));
10130             }
10131             CU_FREE(drbSet->list.array[arrIdx], sizeof(DRBs_ToBeSetupMod_ItemIEs_t));
10132          }
10133       }
10134       CU_FREE(drbSet->list.array, drbSet->list.size);
10135    }
10136
10137 }
10138
10139 /*******************************************************************
10140 *
10141 * @brief Builds the DRB to be Setup Mod list
10142 *
10143 * @details
10144 *
10145 *    Function : BuildDrbToBeSetupList
10146 *
10147 *    Functionality: Constructs the DRB to be Setup Mod list
10148 *
10149 * @params[in] DRBs_ToBeSetupMod_List_t *drbSet
10150 *
10151 * @return ROK     - success
10152 *         RFAILED - failure
10153 *
10154 * ****************************************************************/
10155
10156 uint8_t BuildDrbToBeSetupList(uint32_t duId, CuUeCb *ueCb, DRBs_ToBeSetupMod_List_t *drbSet)
10157 {
10158    uint8_t ret = ROK;
10159    uint8_t arrIdx =0;
10160    uint8_t drbCnt =0;
10161
10162    drbCnt = MAX_DRB_SET_UE_CONTEXT_MOD_REQ;
10163    drbSet->list.count = drbCnt;
10164    drbSet->list.size = drbCnt * sizeof(DRBs_ToBeSetupMod_ItemIEs_t *);
10165    CU_ALLOC(drbSet->list.array, drbSet->list.size);
10166    if(drbSet->list.array == NULLP)
10167    {
10168       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDrbToBeSetupList");
10169       return  RFAILED;
10170    }
10171
10172    for(arrIdx=0; arrIdx<drbCnt; arrIdx++)
10173    {
10174       CU_ALLOC(drbSet->list.array[arrIdx], sizeof(DRBs_ToBeSetupMod_ItemIEs_t));
10175       if(drbSet->list.array[arrIdx] == NULLP)
10176       {
10177          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDrbToBeSetupList for array idx [%d]", arrIdx);
10178          return  RFAILED;
10179       }
10180
10181       ret = FillDrbItemList(duId, ueCb, arrIdx, (DRBs_ToBeSetupMod_ItemIEs_t *)drbSet->list.array[arrIdx]);
10182       if(ret != ROK)
10183       {
10184          DU_LOG("\nERROR  -->  F1AP : FillDrbItemList failed");
10185       }
10186    }
10187
10188    return ret;
10189 }
10190
10191 /*******************************************************************
10192 *
10193 * @brief Filling the DRB to be modified item
10194 *
10195 * @details
10196 *
10197 *    Function : FillDrbToBeModItem
10198 *
10199 *    Functionality: filling the DRB to be modified item
10200 *
10201 * @params[in] DRBs_ToBeModified_Item_t *drbItem
10202 *
10203 * @return ROK     - success
10204 *         RFAILED - failure
10205 *
10206 * ****************************************************************/
10207
10208 uint8_t FillDrbToBeModItem(uint32_t duId, CuUeCb *ueCb, uint8_t arrIdx, DRBs_ToBeModified_Item_t *drbItem)
10209 {
10210    uint8_t ret = ROK;
10211    uint drbIdx=0;
10212    DrbInfo *drbToBeMod;
10213
10214    /*Drb Id */
10215    drbItem->dRBID = DRB2 + arrIdx;
10216
10217    /* Search for DRB ID in CU databse */
10218    for(drbIdx = 0; drbIdx < ueCb->numDrb; drbIdx++)
10219    {
10220       if(ueCb->drbList[drbIdx].drbId == drbItem->dRBID)
10221       {
10222          drbToBeMod = &ueCb->drbList[drbIdx];
10223          break;
10224       }
10225    }
10226
10227    /*qoSInformation*/
10228    drbItem->qoSInformation = NULLP;
10229    CU_ALLOC(drbItem->qoSInformation, sizeof(QoSInformation_t));
10230    if(drbItem->qoSInformation != NULLP)
10231    {
10232       drbItem->qoSInformation->present = QoSInformation_PR_choice_extension;
10233
10234       switch(drbItem->qoSInformation->present)
10235       {
10236          case QoSInformation_PR_NOTHING:
10237             {
10238                break;
10239             }
10240          case QoSInformation_PR_eUTRANQoS:
10241             {
10242
10243                CU_ALLOC(drbItem->qoSInformation->choice.eUTRANQoS, sizeof(EUTRANQoS_t));
10244                if(drbItem->qoSInformation->choice.eUTRANQoS)
10245                {
10246                   DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in FillDrbToBeModItem");
10247                   return RFAILED;
10248                }
10249                drbItem->qoSInformation->choice.eUTRANQoS->qCI = QCI;
10250                drbItem->qoSInformation->choice.eUTRANQoS->allocationAndRetentionPriority.priorityLevel =
10251                   PriorityLevel_no_priority;
10252
10253                drbItem->qoSInformation->choice.eUTRANQoS->allocationAndRetentionPriority.pre_emptionCapability =
10254                   Pre_emptionCapability_may_trigger_pre_emption;
10255
10256                drbItem->qoSInformation->choice.eUTRANQoS->allocationAndRetentionPriority.pre_emptionVulnerability =
10257                   Pre_emptionVulnerability_pre_emptable;
10258
10259                break;
10260             }
10261          case QoSInformation_PR_choice_extension:
10262             {
10263                CU_ALLOC(drbItem->qoSInformation->choice.choice_extension,sizeof(QoSInformation_ExtIEs_t));
10264                if(drbItem->qoSInformation->choice.choice_extension == NULLP)
10265                {
10266                   DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in FillDrbItemToSetupMod");
10267                   return RFAILED;
10268                }
10269
10270                drbItem->qoSInformation->choice.choice_extension->id = ProtocolIE_ID_id_DRB_Information;
10271                drbItem->qoSInformation->choice.choice_extension->criticality = Criticality_ignore;
10272                drbItem->qoSInformation->choice.choice_extension->value.present = QoSInformation_ExtIEs__value_PR_DRB_Information;
10273                ret =  BuildQOSInfo(&drbToBeMod->qos, &drbItem->qoSInformation->choice.choice_extension->value.choice.DRB_Information.dRB_QoS,\
10274                      ProtocolIE_ID_id_DRBs_ToBeModified_Item, INVALID_PDU_SESSION_ID, FALSE);
10275                if(ret != ROK)
10276                {
10277                   DU_LOG("\nERROR  -->  F1AP : BuildQOSInfo failed");
10278                   return RFAILED;
10279                }
10280
10281                /*SNSSAI*/
10282                ret = BuildSNSSAI(drbToBeMod, &drbItem->qoSInformation->choice.\
10283                      choice_extension->value.choice.DRB_Information.sNSSAI, cuCb.snssaiList[0], FALSE);
10284                if(ret != ROK)
10285                {
10286                   DU_LOG("\nERROR  -->  F1AP : BuildSNSSAI failed");
10287                   return RFAILED;
10288                }
10289
10290                /*Flows mapped to DRB List*/
10291                ret = BuildFlowsMap(drbToBeMod, &drbItem->qoSInformation->choice.\
10292                      choice_extension->value.choice.DRB_Information.flows_Mapped_To_DRB_List,\
10293                      ProtocolIE_ID_id_DRBs_ToBeModified_Item, FALSE);
10294                if(ret != ROK)
10295                {
10296                   DU_LOG("\nERROR  -->  F1AP : BuildFlowsMap failed");
10297                   return RFAILED;
10298                }
10299             }
10300       }
10301    }/* End of QoS */
10302
10303    /*ULUPTNLInformation To Be Setup List*/
10304    ret = BuildUlTnlInfoforSetupMod(duId, ueCb->gnbCuUeF1apId, drbItem->dRBID, &drbToBeMod->ulUpTnlInfo, &drbItem->uLUPTNLInformation_ToBeSetup_List,\
10305             ProtocolIE_ID_id_DRBs_ToBeModified_Item);
10306    if(ret != ROK)
10307    {
10308       DU_LOG("\nERROR  -->  F1AP : BuildUlTnlInfoforSetupMod failed");
10309       return RFAILED;
10310    }
10311    return ROK;
10312 }
10313
10314 /*******************************************************************
10315 *
10316 * @brief Builds the DRB to be modified Item IE
10317 *
10318 * @details
10319 *
10320 *    Function : FillDrbToBeModItemList
10321 *
10322 *    Functionality: Constructs the DRB to be modified Mod Item Ies
10323 *
10324 * @params[in] struct DRBs_ToBeModified_ItemIEs *drbItemIe
10325 *
10326 * @return ROK     - success
10327 *         RFAILED - failure
10328 *
10329 * ****************************************************************/
10330
10331 uint8_t FillDrbToBeModItemList(uint32_t duId, CuUeCb *ueCb, uint8_t arrIdx, struct DRBs_ToBeModified_ItemIEs *drbItemIe)
10332 {
10333    drbItemIe->id = ProtocolIE_ID_id_DRBs_ToBeModified_Item;
10334    drbItemIe->criticality = Criticality_reject;
10335    drbItemIe->value.present = DRBs_ToBeModified_ItemIEs__value_PR_DRBs_ToBeModified_Item;
10336    if(FillDrbToBeModItem(duId, ueCb, arrIdx, &(drbItemIe->value.choice.DRBs_ToBeModified_Item)) != ROK)
10337    {
10338       DU_LOG("\nERROR  -->  F1AP : FillDrbToBeModItem failed");
10339       return RFAILED;
10340    }
10341
10342    return ROK;
10343 }
10344
10345 /*******************************************************************
10346 *
10347 * @brief Builds the DRB to be modified list
10348 *
10349 * @details
10350 *
10351 *    Function : BuildDrbToBeModList
10352 *
10353 *    Functionality: Constructs the DRB to be modified list
10354 *
10355 * @params[in] DRBs_ToBeModified_List_t *drbSet
10356 *
10357 * @return ROK     - success
10358 *         RFAILED - failure
10359 *
10360 * ****************************************************************/
10361
10362 uint8_t BuildDrbToBeModifiedList(uint32_t duId, CuUeCb *ueCb, DRBs_ToBeModified_List_t *drbSet)
10363 {
10364    uint8_t ret = ROK;
10365    uint8_t arrIdx =0;
10366    uint8_t drbCnt =0;
10367
10368    drbCnt = MAX_DRB_MODIFIED_UE_MOD_REQ;
10369    drbSet->list.count = drbCnt;
10370    drbSet->list.size = drbCnt * sizeof(DRBs_ToBeModified_ItemIEs_t *);
10371    CU_ALLOC(drbSet->list.array, drbSet->list.size);
10372    if(drbSet->list.array == NULLP)
10373    {
10374       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDrbToBeModifiedList");
10375       return  RFAILED;
10376    }
10377    for(arrIdx=0; arrIdx<drbCnt; arrIdx++)
10378    {
10379       CU_ALLOC(drbSet->list.array[arrIdx], sizeof(DRBs_ToBeModified_ItemIEs_t));
10380       if(drbSet->list.array[arrIdx] == NULLP)
10381       {
10382          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDrbToBeSetupList");
10383          return  RFAILED;
10384       }
10385
10386       ret = FillDrbToBeModItemList(duId, ueCb, arrIdx, (DRBs_ToBeModified_ItemIEs_t *)drbSet->list.array[arrIdx]);
10387       if(ret != ROK)
10388       {
10389          DU_LOG("\nERROR  -->  F1AP : FillDrbToBeModItemList failed");
10390       }
10391    }
10392
10393    return ret;
10394 }
10395
10396 /*******************************************************************
10397 *
10398 * @brief freeing the DRB  item
10399 *
10400 * @details
10401 *
10402 *    Function : FreeModifiedDrbItem
10403 *
10404 *    Functionality: freeing the DRB 2 item
10405 *
10406 * @params[in] DRBs_ToBeSetupMod_Item_t *drbItem
10407 *
10408 * @return ROK     - success
10409 *         RFAILED - failure
10410 *
10411 * ****************************************************************/
10412
10413 void FreeModifiedDrbItem(DRBs_ToBeModified_Item_t *drbItem)
10414 {
10415    uint8_t arrIdx =0;
10416    SNSSAI_t *snssai =NULLP;
10417    Flows_Mapped_To_DRB_List_t *flowMap = NULLP;
10418
10419    if(drbItem->qoSInformation != NULLP)
10420    {
10421       switch(drbItem->qoSInformation->present)
10422       {
10423          case QoSInformation_PR_NOTHING:
10424             break;
10425          case QoSInformation_PR_eUTRANQoS:
10426             {
10427                if(drbItem->qoSInformation->choice.eUTRANQoS)
10428                {
10429                   CU_FREE(drbItem->qoSInformation->choice.eUTRANQoS, sizeof(EUTRANQoS_t));
10430                }
10431                break;
10432             }
10433          case QoSInformation_PR_choice_extension:
10434             {
10435                if(drbItem->qoSInformation->choice.choice_extension)
10436                {
10437                   FreeQOSInfo(&drbItem->qoSInformation->choice.choice_extension->value.choice.DRB_Information.dRB_QoS);
10438
10439                   snssai = &drbItem->qoSInformation->choice.choice_extension->value.choice.DRB_Information.sNSSAI;
10440                   if(snssai->sST.buf)
10441                   {
10442                      CU_FREE(snssai->sST.buf,snssai->sST.size);
10443                   }
10444                   if(snssai->sD)
10445                   {
10446                      if(snssai->sD->buf)
10447                      {
10448                         CU_FREE(snssai->sD->buf,snssai->sD->size);
10449                      }
10450                      CU_FREE(snssai->sD,sizeof(OCTET_STRING_t));
10451                   }
10452
10453                   flowMap = &drbItem->qoSInformation->choice.choice_extension->value.choice.DRB_Information.flows_Mapped_To_DRB_List;
10454                   if(flowMap->list.array)
10455                   {
10456                      for(arrIdx=0; arrIdx<flowMap->list.count; arrIdx++)
10457                      {
10458                         if(flowMap->list.array[arrIdx] )
10459                         {
10460                            FreeQOSInfo(&flowMap->list.array[arrIdx]->qoSFlowLevelQoSParameters);
10461                            CU_FREE(flowMap->list.array[arrIdx],sizeof(Flows_Mapped_To_DRB_Item_t));
10462                         }
10463                      }
10464                      CU_FREE(flowMap->list.array,flowMap->list.size);
10465                   }
10466
10467                   CU_FREE(drbItem->qoSInformation->choice.choice_extension,sizeof(QoSInformation_ExtIEs_t));
10468                }
10469                break;
10470             }
10471       }
10472    }
10473    FreeUlTnlInfoforDrb2(&drbItem->uLUPTNLInformation_ToBeSetup_List);
10474    if(drbItem->uLConfiguration)
10475    {
10476       CU_FREE(drbItem->uLConfiguration,sizeof(ULConfiguration_t));
10477    }
10478 }
10479
10480 /*******************************************************************
10481 *
10482 * @brief free the DRB to be modfified list
10483 *
10484 * @details
10485 *
10486 *    Function : FreeDrbToBeModifiedList
10487 *
10488 *    Functionality: free the DRB to be Setup Mod list
10489 *
10490 * @params[in] FreeDrbToBeModifiedList_t *drbSet
10491 *
10492 * @return ROK     - success
10493 *         RFAILED - failure
10494 *
10495 * ****************************************************************/
10496 void FreeDrbToBeModifiedList(DRBs_ToBeModified_List_t *drbSet)
10497 {
10498    uint8_t arrIdx =0;
10499    struct DRBs_ToBeModified_ItemIEs *drbItemIe;
10500
10501    if(drbSet->list.array)
10502    {
10503       for(arrIdx=0; arrIdx<drbSet->list.count ; arrIdx++)
10504       {
10505          if(drbSet->list.array[arrIdx] != NULLP)
10506          {
10507             drbItemIe = (struct DRBs_ToBeModified_ItemIEs *)drbSet->list.array[arrIdx];
10508             FreeModifiedDrbItem(&(drbItemIe->value.choice.DRBs_ToBeModified_Item));
10509             CU_FREE(drbSet->list.array[arrIdx], sizeof(DRBs_ToBeModified_ItemIEs_t));
10510          }
10511       }
10512       CU_FREE(drbSet->list.array, drbSet->list.size);
10513    }
10514
10515 }
10516
10517 /*******************************************************************
10518  *
10519  * @brief  free the UeContextModification Request
10520  *
10521  * @details
10522  *
10523  *    Function : FreeUeContextModicationRequest
10524  *
10525  *    Functionality : deallocation of memory allocated in UeContextModiification
10526  request
10527  *
10528  * @params[in] F1AP_PDU_t *f1apMsg
10529  *
10530  * @return void
10531 *
10532 * ****************************************************************/
10533 void FreeUeContextModicationRequest(F1AP_PDU_t *f1apMsg)
10534 {
10535    uint8_t arrIdx =0 , ieId=0;
10536    UEContextModificationRequest_t *ueContextModifyReq = NULLP;
10537
10538    if(f1apMsg)
10539    {
10540       if(f1apMsg->choice.initiatingMessage)
10541       {
10542          ueContextModifyReq =&f1apMsg->choice.initiatingMessage->value.choice.UEContextModificationRequest;
10543          if(ueContextModifyReq->protocolIEs.list.array)
10544          {
10545             for( arrIdx = 0 ; arrIdx<ueContextModifyReq->protocolIEs.list.count ; arrIdx++)
10546             {
10547                if(ueContextModifyReq->protocolIEs.list.array[arrIdx])
10548                {
10549                   ieId = ueContextModifyReq->protocolIEs.list.array[arrIdx]->id;
10550                   switch(ieId)
10551                   {
10552                      case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
10553                         break;
10554                      case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
10555                         break;
10556                      case ProtocolIE_ID_id_DRBs_ToBeSetupMod_List:
10557                         {
10558                            FreeDrbToBeSetupModList(&ueContextModifyReq->protocolIEs.list.array[arrIdx]->value.\
10559                                  choice.DRBs_ToBeSetupMod_List);
10560                            break;
10561                         }
10562                      case ProtocolIE_ID_id_DRBs_ToBeModified_List:
10563                         {
10564                            FreeDrbToBeModifiedList(&ueContextModifyReq->protocolIEs.list.array[arrIdx]->value.\
10565                                  choice.DRBs_ToBeModified_List);
10566                            break;
10567                         }
10568                     case ProtocolIE_ID_id_TransmissionActionIndicator:
10569                         break;
10570                     case ProtocolIE_ID_id_RRCContainer:
10571                     {
10572                         CU_FREE(ueContextModifyReq->protocolIEs.list.array[arrIdx]->value.choice.RRCContainer.buf,\
10573                         ueContextModifyReq->protocolIEs.list.array[arrIdx]->value.choice.RRCContainer.size);
10574                     }
10575
10576                   }
10577                   CU_FREE(ueContextModifyReq->protocolIEs.list.array[arrIdx], sizeof(UEContextModificationRequest_t));
10578                }
10579             }
10580             CU_FREE(ueContextModifyReq->protocolIEs.list.array, ueContextModifyReq->protocolIEs.list.size);
10581          }
10582          CU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
10583       }
10584       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
10585    }
10586 }
10587
10588 /*******************************************************************
10589  *
10590  * @brief Builds the Ue Context Modification Req
10591  *
10592  * @details
10593  *
10594  *    Function : BuildAndSendUeContextModificationReq
10595  *
10596  *    Functionality: Constructs the Ue Context Modification Req
10597  *
10598  * @params[in]
10599  *
10600  * @return ROK     - success
10601  *         RFAILED - failure
10602  *
10603  * ****************************************************************/
10604 uint8_t BuildAndSendUeContextModificationReq(uint32_t duId, void *cuUeCb, UeCtxtModAction action)
10605 {
10606    uint8_t    ieIdx = 0;
10607    uint8_t    elementCnt = 0;
10608    uint8_t    ret = RFAILED;
10609    CuUeCb     *ueCb = (CuUeCb *)cuUeCb;
10610    F1AP_PDU_t *f1apMsg = NULLP;
10611    UEContextModificationRequest_t *ueContextModifyReq = NULLP;
10612    asn_enc_rval_t         encRetVal;
10613    DU_LOG("\nINFO  -->  F1AP : Building Ue context modification request\n");
10614    while(1)
10615    {
10616       CU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
10617       if(f1apMsg == NULLP)
10618       {
10619          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed Ue context modification");
10620          break;
10621       }
10622
10623       f1apMsg->present =  F1AP_PDU_PR_initiatingMessage;
10624
10625       CU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
10626       if(f1apMsg->choice.initiatingMessage == NULLP)
10627       {
10628          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed Ue context modification");
10629          break;
10630       }
10631       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_UEContextModification;
10632       f1apMsg->choice.initiatingMessage->criticality = Criticality_reject;
10633       f1apMsg->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_UEContextModificationRequest;
10634
10635       ueContextModifyReq =&f1apMsg->choice.initiatingMessage->value.choice.UEContextModificationRequest;
10636
10637       if(action == MODIFY_UE)
10638          elementCnt = 4;
10639       else if(action == QUERY_CONFIG)
10640          elementCnt = 3;
10641       else if(action == RRC_RECONFIG_COMPLETE_IND)
10642          elementCnt = 3;
10643       else if((action == STOP_DATA_TX) || (action == RESTART_DATA_TX))
10644          elementCnt = 5;
10645
10646       ueContextModifyReq->protocolIEs.list.count = elementCnt;
10647       ueContextModifyReq->protocolIEs.list.size = elementCnt*sizeof(UEContextModificationRequest_t *);
10648
10649       /* Initialize the UE context modification members */
10650       CU_ALLOC(ueContextModifyReq->protocolIEs.list.array, ueContextModifyReq->protocolIEs.list.size);
10651       if(ueContextModifyReq->protocolIEs.list.array == NULLP)
10652       {
10653          DU_LOG("\nERROR  -->  F1AP : Memory allocation for UE context modifcation Request failed");
10654          break;
10655       }
10656
10657       for(ieIdx=0 ; ieIdx<elementCnt; ieIdx++)
10658       {
10659          CU_ALLOC(ueContextModifyReq->protocolIEs.list.array[ieIdx], sizeof(UEContextModificationRequest_t));
10660          if(ueContextModifyReq->protocolIEs.list.array[ieIdx] == NULLP)
10661          {
10662             DU_LOG("\nERROR  -->  F1AP : Memory allocation for UE context modifcation Request failed");
10663             break;
10664          }
10665       }
10666
10667       ieIdx=0;
10668       ueContextModifyReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
10669       ueContextModifyReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
10670       ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present = \
10671                                                                          UEContextModificationRequestIEs__value_PR_GNB_CU_UE_F1AP_ID;
10672       ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID = ueCb->gnbCuUeF1apId;
10673
10674       ieIdx++;
10675       ueContextModifyReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
10676       ueContextModifyReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
10677       ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present=\
10678                                                                        UEContextModificationRequestIEs__value_PR_GNB_DU_UE_F1AP_ID;
10679       ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID = ueCb->gnbDuUeF1apId;
10680
10681       if(action == MODIFY_UE)
10682       {
10683          /* DRB to be setup list */
10684          ieIdx++;
10685          ueContextModifyReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_DRBs_ToBeSetupMod_List;
10686          ueContextModifyReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
10687          ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present =\
10688                                                                            UEContextModificationRequestIEs__value_PR_DRBs_ToBeSetupMod_List;
10689          ret = BuildDrbToBeSetupList(duId, ueCb, &(ueContextModifyReq->protocolIEs.list.array[ieIdx]->\
10690                   value.choice.DRBs_ToBeSetupMod_List));
10691
10692          /* DRB to be modified list */
10693          ieIdx++;
10694          ueContextModifyReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_DRBs_ToBeModified_List;
10695          ueContextModifyReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
10696          ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present =\
10697                                                                            UEContextModificationRequestIEs__value_PR_DRBs_ToBeModified_List;
10698          ret = BuildDrbToBeModifiedList(duId, ueCb, &(ueContextModifyReq->protocolIEs.list.array[ieIdx]->\
10699                   value.choice.DRBs_ToBeModified_List));
10700
10701          /* TODO: DRB to be release list */
10702
10703          if(ret != ROK)
10704          {
10705             DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextModificationReq(): Failed to build drb to be modified list");
10706             break;
10707          }
10708
10709          /* TODO: fill the RRC reconfiguration information in RRC Contaiiner ie in case of MODIFY_UE  */
10710       }
10711       else if(action == QUERY_CONFIG)
10712       {
10713          ieIdx++;
10714          ueContextModifyReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_GNB_DUConfigurationQuery;
10715          ueContextModifyReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
10716          ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present = \
10717             UEContextModificationRequestIEs__value_PR_GNB_DUConfigurationQuery;
10718          ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DUConfigurationQuery = GNB_DUConfigurationQuery_true;
10719       }
10720       else if(action == RRC_RECONFIG_COMPLETE_IND)
10721       {
10722          ieIdx++;
10723          ueContextModifyReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_RRCReconfigurationCompleteIndicator;
10724          ueContextModifyReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
10725          ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present = \
10726             UEContextModificationRequestIEs__value_PR_RRCReconfigurationCompleteIndicator;
10727          ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.RRCReconfigurationCompleteIndicator = \
10728             RRCReconfigurationCompleteIndicator_true;
10729       }
10730       else if((action == STOP_DATA_TX) || (action == RESTART_DATA_TX))
10731       {
10732          ieIdx++;
10733          if(action == STOP_DATA_TX)
10734          {
10735             ueContextModifyReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_TransmissionActionIndicator;
10736             ueContextModifyReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
10737             ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present = \
10738             UEContextModificationRequestIEs__value_PR_TransmissionActionIndicator;
10739             ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.TransmissionActionIndicator = \
10740             TransmissionActionIndicator_stop;
10741          }
10742          else if (action == RESTART_DATA_TX)
10743          {
10744             ueContextModifyReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_TransmissionActionIndicator;
10745             ueContextModifyReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
10746             ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present = \
10747             UEContextModificationRequestIEs__value_PR_TransmissionActionIndicator;
10748             ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.TransmissionActionIndicator = \
10749             TransmissionActionIndicator_restart;
10750          }
10751
10752          ieIdx++;
10753          ueContextModifyReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_RRCContainer;
10754          ueContextModifyReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
10755          ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present = \
10756          UEContextModificationRequestIEs__value_PR_RRCContainer;
10757          if(fillRrcReconfigBuf(ueCb, &ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer, true) != ROK)
10758          {
10759             DU_LOG( "\nERROR  -->  F1AP : Failed to fill Rrc reconfiguration buffer");
10760             return RFAILED;
10761          }
10762
10763          /* RRC delivery status request */
10764          ieIdx++;
10765          ueContextModifyReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_RRCDeliveryStatusRequest;
10766          ueContextModifyReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_ignore;
10767          ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present = UEContextModificationRequestIEs__value_PR_RRCDeliveryStatusRequest;
10768          ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.RRCDeliveryStatusRequest = RRCDeliveryStatusRequest_true;
10769       }
10770
10771       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
10772
10773       /* Encode the F1SetupRequest type as APER */
10774       memset(encBuf, 0, ENC_BUF_MAX_LEN);
10775       encBufSize = 0;
10776       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
10777
10778       /* Encode results */
10779       if(encRetVal.encoded == ENCODE_FAIL)
10780       {
10781          DU_LOG("\nERROR  -->  F1AP : Could not encode ueContextModifyReq structure (at %s)\n",\
10782                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
10783          break;
10784       }
10785       else
10786       {
10787          DU_LOG("\nDEBUG  -->  F1AP : Created APER encodedbuffer for ueContextModifyReq\n");
10788 #if 0
10789          /* This for loop was going into an infinite loop even though encBufSize
10790           * has a small value. Hence commented this
10791           */
10792          for(ieIdx=0; ieIdx< encBufSize; ieIdx++)
10793          {
10794             DU_LOG("%x",encBuf[ieIdx]);
10795          }
10796 #endif
10797       }
10798
10799       /* TODO : Hardcoding DU ID to 1 for messages other than F1 Setup Response. This will be made generic in future gerrit */
10800       if(SendF1APMsg(CU_APP_MEM_REG, CU_POOL, duId) != ROK)
10801       {
10802          DU_LOG("\nERROR  -->  F1AP : Sending Ue context modification request  failed");
10803          break;
10804       }
10805
10806       ret = ROK;
10807       break;
10808
10809    }
10810    FreeUeContextModicationRequest(f1apMsg);
10811    return ret;
10812 }
10813
10814 /*****************************************************************i
10815  *
10816 * @brief Free memory allocated for UE Context Release Command
10817 *
10818 * @details
10819 *
10820 *    Function : FreeUeContextReleaseCommand
10821 *
10822 *    Functionality:
10823 *         - Free memory allocated for UE Context Release Command
10824 *
10825 * @params[in] F1AP_PDU_t *f1apMsg
10826 * @return void
10827 *
10828 * *************************************************************/
10829 void FreeUeContextReleaseCommand(F1AP_PDU_t *f1apMsg)
10830 {
10831    uint8_t ieIdx;
10832    UEContextReleaseCommand_t *ueReleaseCommand = NULLP;
10833
10834    if(f1apMsg)
10835    {
10836       if(f1apMsg->choice.initiatingMessage)
10837       {
10838          ueReleaseCommand =&f1apMsg->choice.initiatingMessage->value.choice.UEContextReleaseCommand;
10839          if(ueReleaseCommand->protocolIEs.list.array)
10840          {
10841             for(ieIdx=0 ; ieIdx<ueReleaseCommand->protocolIEs.list.count; ieIdx++)
10842             {
10843                CU_FREE(ueReleaseCommand->protocolIEs.list.array[ieIdx], sizeof(UEContextReleaseCommand_t));
10844             }
10845             CU_FREE(ueReleaseCommand->protocolIEs.list.array, ueReleaseCommand->protocolIEs.list.size);
10846          }
10847          CU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
10848       }
10849       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
10850    }
10851 }
10852 /*******************************************************************
10853  *
10854  * @brief Builds the Ue Context Release Command
10855  *
10856  * @details
10857 *
10858 *    Function : BuildAndSendUeContextReleaseCommand
10859 *
10860 *    Functionality: Constructs the Ue Context Release Command
10861 *
10862 * @params[in]
10863 *
10864 * @return ROK     - success
10865 *         RFAILED - failure
10866 *
10867 * ****************************************************************/
10868 uint8_t BuildAndSendUeContextReleaseCommand(uint32_t duId, uint8_t cuUeF1apId, uint8_t duUeF1apId)
10869 {
10870    bool       memAllocFailed = false;
10871    uint8_t  duIdx = 0, ieIdx = 0,elementCnt = 0, ret = RFAILED, bufLen=0;
10872    DuDb *duDb;
10873    CuUeCb *ueCb;
10874    F1AP_PDU_t *f1apMsg = NULLP;
10875    UEContextReleaseCommand_t *ueContextReleaseCommand = NULLP;
10876
10877    asn_enc_rval_t         encRetVal;
10878    DU_LOG("\nINFO  -->  F1AP : Building Ue context release command\n");
10879
10880    while(true)
10881    {
10882       CU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
10883       if(f1apMsg == NULLP)
10884       {
10885          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseCommand(): Memory allocation for F1AP-PDU");
10886          break;
10887       }
10888
10889       f1apMsg->present =  F1AP_PDU_PR_initiatingMessage;
10890
10891       CU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
10892       if(f1apMsg->choice.initiatingMessage == NULLP)
10893       {
10894          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseCommand(): Memory allocation for F1AP-PDU failed ");
10895          break;
10896       }
10897       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_UEContextRelease;
10898       f1apMsg->choice.initiatingMessage->criticality = Criticality_reject;
10899       f1apMsg->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_UEContextReleaseCommand;
10900
10901       ueContextReleaseCommand =&f1apMsg->choice.initiatingMessage->value.choice.UEContextReleaseCommand;
10902
10903       SEARCH_DU_DB(duIdx, duId, duDb);
10904       ueCb = &duDb->ueCb[duUeF1apId-1];
10905       if(ueCb->state == UE_HANDOVER_IN_PROGRESS)
10906          elementCnt = 3;
10907       else
10908          elementCnt = 4;
10909
10910       ueContextReleaseCommand->protocolIEs.list.count = elementCnt;
10911       ueContextReleaseCommand->protocolIEs.list.size = elementCnt*sizeof(UEContextReleaseCommand_t*);
10912
10913       /* Initialize the UE context modification members */
10914       CU_ALLOC(ueContextReleaseCommand->protocolIEs.list.array, ueContextReleaseCommand->protocolIEs.list.size);
10915       if(ueContextReleaseCommand->protocolIEs.list.array == NULLP)
10916       {
10917          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseCommand():Memory allocation failed");
10918          break;
10919       }
10920
10921       for(ieIdx=0 ; ieIdx<elementCnt; ieIdx++)
10922       {
10923          CU_ALLOC(ueContextReleaseCommand->protocolIEs.list.array[ieIdx], sizeof(UEContextReleaseCommand_t));
10924          if(ueContextReleaseCommand->protocolIEs.list.array[ieIdx] == NULLP)
10925          {
10926             DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseCommand(): Memory allocation failed ");
10927             memAllocFailed = true;
10928             break;
10929          }
10930       }
10931
10932       if(memAllocFailed == true)
10933       {
10934          break;
10935       }
10936
10937       ieIdx=0;
10938       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
10939       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
10940       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.present = \
10941       UEContextReleaseCommandIEs__value_PR_GNB_CU_UE_F1AP_ID;
10942       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID =cuUeF1apId;
10943
10944       ieIdx++;
10945       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
10946       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
10947       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.present=\
10948       UEContextReleaseCommandIEs__value_PR_GNB_DU_UE_F1AP_ID;
10949       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID =duUeF1apId;
10950
10951       /* Cause of UE context release */
10952       ieIdx++;
10953       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_Cause;
10954       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->criticality = Criticality_ignore;
10955       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.present=\
10956                                                                             UEContextReleaseCommandIEs__value_PR_Cause;
10957       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.Cause.present = Cause_PR_radioNetwork;
10958       ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.Cause.choice.radioNetwork=\
10959                                                                                                      CauseRadioNetwork_normal_release;
10960       if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
10961       {
10962          /* RRC Container for RRC release */
10963          ieIdx++;
10964          ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_RRCContainer;
10965          ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->criticality = Criticality_ignore;
10966          ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.present = \
10967                                                                                  UEContextReleaseCommandIEs__value_PR_RRCContainer;
10968          char secModeBuf[7]={ 0x00, 0x05, 0x13, 0x00, 0x00, 0x00, 0x00};
10969          bufLen =7;
10970          ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.size = bufLen;
10971          CU_ALLOC(ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf,
10972                ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.size);
10973          if(!ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf)
10974          {
10975             DU_LOG("\nERROR  -->  F1AP : Memory allocation for BuildAndSendUeContextReleaseCommand failed");
10976             break;
10977          }
10978          memset(ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf, 0, bufLen);
10979          memcpy(ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf, secModeBuf, bufLen);
10980       }
10981       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
10982
10983       /* Encode the UE Context Release Command type as APER */
10984       memset(encBuf, 0, ENC_BUF_MAX_LEN);
10985       encBufSize = 0;
10986       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
10987             encBuf);
10988
10989       /* Encode results */
10990       if(encRetVal.encoded == ENCODE_FAIL)
10991       {
10992          DU_LOG("\nERROR  -->  F1AP : Could not encode Release Command structure (at %s)\n",\
10993                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
10994          break;
10995       }
10996       else
10997       {
10998          DU_LOG("\nDEBUG  -->  F1AP : Created APER encoded buffer for Ue Context Release Command\n");
10999          for(ieIdx=0; ieIdx< encBufSize; ieIdx++)
11000          {
11001             DU_LOG("%x",encBuf[ieIdx]);
11002          }
11003       }
11004
11005       /* TODO : Hardcoding DU ID to 1 for messages other than F1 Setup Response. This will be made generic in future gerrit */
11006       if(SendF1APMsg(CU_APP_MEM_REG, CU_POOL, duId) != ROK)
11007       {
11008          DU_LOG("\nERROR  -->  F1AP : Sending Ue context Release Command failed");
11009          break;
11010       }
11011
11012       ret = ROK;
11013       break;
11014
11015    }
11016    FreeUeContextReleaseCommand(f1apMsg);
11017    return ret;
11018 }
11019 /*******************************************************************
11020 *
11021 * @brief process Ue context release request
11022 *
11023 * @details
11024 *
11025 *    Function : procUeContextReleaseReq
11026 *
11027 *    Functionality:
11028 *         - process Ue context release request
11029 *
11030 * @params[in] F1AP_PDU_t *f1apMsg
11031 * @return ROK     - success
11032 *         RFAILED - failure
11033 *
11034 * ****************************************************************/
11035 uint8_t procUeContextReleaseReq(uint32_t duId, F1AP_PDU_t *f1apMsg)
11036 {
11037    uint8_t ieIdx=0, duUeF1apId=0,cuUeF1apId=0;
11038
11039    UEContextReleaseRequest_t *ueReleaseReq = NULLP;
11040    ueReleaseReq = &f1apMsg->choice.initiatingMessage->value.choice.UEContextReleaseRequest;
11041
11042    for(ieIdx=0; ieIdx < ueReleaseReq->protocolIEs.list.count; ieIdx++)
11043    {
11044       switch(ueReleaseReq->protocolIEs.list.array[ieIdx]->id)
11045       {
11046          case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
11047             {
11048                cuUeF1apId = ueReleaseReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID;
11049                break;
11050             }
11051          case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
11052             {
11053                duUeF1apId = ueReleaseReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID;
11054                break;
11055             }
11056          default:
11057               break;
11058       }
11059    }
11060
11061    if(BuildAndSendUeContextReleaseCommand(duId, cuUeF1apId, duUeF1apId) != ROK)
11062    {
11063       DU_LOG("\nERROR  -->  F1AP : procUeContextReleaseReq(): Failed to build Ue Context Release Command ");
11064       return RFAILED;
11065    }
11066    return ROK;
11067 }
11068 /*******************************************************************
11069 *
11070 * @brief processing of Gnb-DU config update
11071 *
11072 * @details
11073 *
11074 *    Function : procGnbDuUpdate
11075 *
11076 *    Functionality:
11077 *         - processing of Gnb-DU config update
11078 *
11079 * @params[in] F1AP_PDU_t *f1apMsg
11080 * @return ROK     - success
11081 *         RFAILED - failure
11082 *
11083 * ****************************************************************/
11084 uint8_t procGnbDuUpdate(uint32_t duId, F1AP_PDU_t *f1apMsg)
11085 {
11086    bool cellToBeDelete = false;
11087    uint8_t ieIdx = 0, ueIdx = 0, duIdx = 0, cellIdx=0;
11088    uint16_t nrCellId;
11089    DuDb *duDb;
11090    CuCellCb *cellCb;
11091    GNBDUConfigurationUpdate_t *duCfgUpdate = NULLP;
11092
11093    duCfgUpdate = &f1apMsg->choice.initiatingMessage->value.choice.GNBDUConfigurationUpdate;
11094    for(ieIdx=0; ieIdx < duCfgUpdate->protocolIEs.list.count; ieIdx++)
11095    {
11096       switch(duCfgUpdate->protocolIEs.list.array[ieIdx]->id)
11097       {
11098          case ProtocolIE_ID_id_TransactionID:
11099             break;
11100          case ProtocolIE_ID_id_Served_Cells_To_Modify_List:
11101             break;
11102          case ProtocolIE_ID_id_Served_Cells_To_Delete_List:
11103             {
11104                struct Served_Cells_To_Delete_ItemIEs *deleteItemIe = \
11105                   (struct Served_Cells_To_Delete_ItemIEs *)duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.\
11106                   Served_Cells_To_Delete_List.list.array[0];
11107                nrCellId = deleteItemIe->value.choice.Served_Cells_To_Delete_Item.oldNRCGI.nRCellIdentity.buf[4] >>\
11108                   deleteItemIe->value.choice.Served_Cells_To_Delete_Item.oldNRCGI.nRCellIdentity.bits_unused;
11109                cellToBeDelete = true;
11110                break;
11111             }
11112          case ProtocolIE_ID_id_gNB_DU_ID:
11113             break;
11114       }
11115    }
11116    if(BuildAndSendDUUpdateAck(duId) != ROK)
11117    {
11118       DU_LOG("ERROR  -->  F1AP : Failed to build and send DUUpdateAck");
11119       return RFAILED;
11120    }
11121 #if 0
11122    /* We don't require F1 Reset message in Cell Up and Broadcast Procedure flow, So that's why
11123     * commented this trigger for now */
11124
11125    if(cellToBeDelete == false)
11126    {
11127       DU_LOG("\nINFO  -->  F1AP : Sending F1 reset request");
11128       if(BuildAndSendF1ResetReq() != ROK)
11129       {
11130          DU_LOG("ERROR  -->  F1AP : Failed to build and send F1 reset request");
11131          return RFAILED;
11132       }
11133    }
11134 #endif
11135    if(cellToBeDelete == true)
11136    {
11137       SEARCH_DU_DB(duIdx, duId, duDb);
11138       SEARCH_CELL_DB(cellIdx, duDb, nrCellId, cellCb);
11139       if(cellCb->numUe == 0)
11140       {
11141          memset(cellCb, 0, sizeof(CuCellCb));
11142          duDb->numCells--;
11143       }
11144       else
11145          cellCb->cellStatus = CELL_DELETION_IN_PROGRESS;
11146    }
11147    return ROK;
11148 }
11149
11150 /*******************************************************************
11151 *
11152 * @brief storing slice list in CU database
11153 *
11154 * @details
11155 *
11156 *    Function : buildSliceList
11157 *
11158 *    Functionality:
11159 *         - storing slice list in CU database
11160 *
11161 * @params[in] SliceSupportList_t *sliceSupportList
11162 * @return ROK     - success
11163 *         RFAILED - failure
11164 *
11165 * ****************************************************************/
11166 uint8_t buildSliceList(SliceSupportList_t *sliceSupportList)
11167 {
11168    uint8_t sliceListIdx = 0;
11169
11170    if(sliceSupportList)
11171    {
11172       if(sliceSupportList->list.array)
11173       {
11174          cuCb.numSnssaiSupported = sliceSupportList->list.count;
11175          for(sliceListIdx=0; sliceListIdx<sliceSupportList->list.count; sliceListIdx++)
11176          {
11177             if(sliceSupportList->list.array[sliceListIdx])
11178             {
11179                CU_ALLOC(cuCb.snssaiList[sliceListIdx], sizeof(Snssai));
11180                if(cuCb.snssaiList[sliceListIdx] == NULLP)
11181                {
11182                    DU_LOG("\nERROR  --> CU_STUB: buildSliceList(): Memory allocation failed");
11183                    return RFAILED;
11184                }
11185                if(sliceSupportList->list.array[sliceListIdx]->sNSSAI.sST.buf)
11186                {
11187                   memcpy(&cuCb.snssaiList[sliceListIdx]->sst, sliceSupportList->list.array[sliceListIdx]->\
11188                   sNSSAI.sST.buf, sliceSupportList->list.array[sliceListIdx]->sNSSAI.sST.size);
11189                }
11190                if(sliceSupportList->list.array[sliceListIdx]->sNSSAI.sD->size)
11191                {
11192                   memcpy(&cuCb.snssaiList[sliceListIdx]->sd,\
11193                   sliceSupportList->list.array[sliceListIdx]->sNSSAI.sD->buf,\
11194                   sliceSupportList->list.array[sliceListIdx]->sNSSAI.sD->size);
11195                }
11196             }
11197          }
11198       }
11199    }
11200    return ROK;
11201 }
11202
11203 /****************************************************************
11204  * @brief Function to process Srb Setup Mod List
11205  *
11206  * @details
11207  *
11208  *    Function : procSrbSetupModList
11209  *
11210  *    Functionality:
11211  *         - Function to process SRB Setup Mod List
11212  *
11213  * @params[in]
11214  * @return ROK     - success
11215  *         RFAILED - failure
11216  *
11217  * ****************************************************************/
11218 uint8_t procSrbSetupModList(CuUeCb *ueCb, SRBs_SetupMod_List_t *srbSetupList)
11219 {
11220    uint8_t arrIdx = 0, srbIdx;
11221    struct SRBs_SetupMod_ItemIEs *srbItemIe = NULLP;
11222
11223    if(srbSetupList != NULLP)
11224    {
11225       for(arrIdx = 0; arrIdx < srbSetupList->list.count; arrIdx++)
11226       {
11227          srbItemIe = ((struct SRBs_SetupMod_ItemIEs *)srbSetupList->list.array[arrIdx]);
11228          if(srbItemIe->value.present == SRBs_SetupMod_ItemIEs__value_PR_SRBs_SetupMod_Item)
11229          {
11230             for(srbIdx = 0; srbIdx < ueCb->numSrb; srbIdx++)
11231             {
11232                if(ueCb->srbList[srbIdx].srbId == srbItemIe->value.choice.SRBs_SetupMod_Item.sRBID)
11233                {
11234                   ueCb->srbList[srbIdx].lcId = srbItemIe->value.choice.SRBs_SetupMod_Item.lCID;
11235                   break;
11236                }
11237             }
11238          }
11239
11240       }
11241    }
11242    return ROK;
11243 }
11244
11245
11246 /****************************************************************
11247  * @brief Function to process Drb Setup Mod List
11248  *
11249  * @details
11250  *
11251  *    Function : procDrbSetupModList
11252  *
11253  *    Functionality:
11254  *         - Function to process DRB Setup Mod List
11255  *
11256  * @params[in]
11257  * @return ROK     - success
11258  *         RFAILED - failure
11259  *
11260  * ****************************************************************/
11261 uint8_t procDrbSetupModList(uint32_t duId, CuUeCb *ueCb, DRBs_SetupMod_List_t *drbSetupList)
11262 {
11263    uint8_t arrIdx = 0, drbIdx;
11264    uint32_t teId = 0;
11265    struct DRBs_SetupMod_ItemIEs *drbItemIe = NULLP;
11266
11267    if(drbSetupList != NULLP)
11268    {
11269       for(arrIdx = 0; arrIdx < drbSetupList->list.count; arrIdx++)
11270       {
11271          drbItemIe = ((struct DRBs_SetupMod_ItemIEs *)drbSetupList->list.array[arrIdx]);
11272          if(drbItemIe->value.present == DRBs_SetupMod_ItemIEs__value_PR_DRBs_SetupMod_Item)
11273          {
11274             for(drbIdx = 0; drbIdx < ueCb->numDrb; drbIdx++)
11275             {
11276                if(ueCb->drbList[drbIdx].drbId == drbItemIe->value.choice.DRBs_SetupMod_Item.dRBID)
11277                {
11278                   if(drbItemIe->value.choice.DRBs_SetupMod_Item.lCID)
11279                      ueCb->drbList[drbIdx].lcId = *(drbItemIe->value.choice.DRBs_SetupMod_Item.lCID);
11280                   break;
11281                }
11282             }
11283
11284             if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
11285             {
11286             /* extracting teId */
11287             teId  = extractTeId(&drbItemIe->value.choice.DRBs_SetupMod_Item.dLUPTNLInformation_ToBeSetup_List);
11288             if(teId > 0)
11289             {
11290               if(addDrbTunnels(duId, teId)== ROK)
11291               {
11292                 DU_LOG("\nDEBUG  --> EGTP: Tunnel Added for TeId %d", teId);
11293               }
11294             }
11295             else
11296                return RFAILED;
11297             }
11298          }
11299       }
11300    }
11301    return ROK;
11302 }
11303
11304 /*******************************************************************
11305 *
11306 * @brief processing of GNB_DU_Served_Cells Plmn list  information
11307 *
11308 * @details
11309 *
11310 *    Function : procServedCellPlmnList
11311 *
11312 *    Functionality:
11313 *         - processing of GNB_DU_Served_Cells Plmn list information for storing
11314 *         SNSSAI list
11315 *
11316 * @params[in] F1AP_PDU_t *f1apMsg
11317 * @return ROK     - success
11318 *         RFAILED - failure
11319 *
11320 * ****************************************************************/
11321 uint8_t procServedCellPlmnList(ServedPLMNs_List_t *srvPlmn)
11322 {
11323    uint8_t srvPlmnIdx=0, ieExtensionsLstIdx=0;
11324    ProtocolExtensionContainer_4624P3_t **ieExtend;
11325
11326    if(srvPlmn->list.array)
11327    {
11328       for(srvPlmnIdx=0; srvPlmnIdx<srvPlmn->list.count; srvPlmnIdx++)
11329       {
11330          if(srvPlmn->list.array[srvPlmnIdx])
11331          {
11332             ieExtend =  &srvPlmn->list.array[srvPlmnIdx]->iE_Extensions;
11333             if(*ieExtend)
11334             {
11335                if((*ieExtend)->list.array)
11336                {
11337                   for(ieExtensionsLstIdx = 0; ieExtensionsLstIdx<(*ieExtend)->list.count; ieExtensionsLstIdx++)
11338                   {
11339                      if((*ieExtend)->list.array[ieExtensionsLstIdx])
11340                      {
11341                         switch((*ieExtend)->list.array[ieExtensionsLstIdx]->id )
11342                         {
11343                            case ProtocolIE_ID_id_TAISliceSupportList:
11344                               {
11345                                  if(buildSliceList(&(*ieExtend)->list.array[ieExtensionsLstIdx]->\
11346                                           extensionValue.choice.SliceSupportList) != ROK)
11347                                  {
11348                                     DU_LOG("\nERROR  --> CU_STUB: procServedCellPlmnList(): Failed to build slice List");
11349                                     return RFAILED;
11350                                  }
11351                               }
11352                         }
11353                      }
11354                   }
11355                }
11356             }
11357          }
11358       }
11359    }
11360    return ROK;
11361 }
11362
11363 /****************************************************************
11364  * @brief Function to process Ue Context Modification Response
11365  *
11366  * @details
11367  *
11368  *    Function : procUeContextModificationResponse
11369  *
11370  *    Functionality:
11371  *         - Function to process Ue Context Modification Response
11372  *
11373  * @params[in]
11374  * @return ROK     - success
11375  *         RFAILED - failure
11376  *
11377  * ****************************************************************/
11378 uint8_t procUeContextModificationResponse(uint32_t duId, F1AP_PDU_t *f1apMsg)
11379 {
11380    uint8_t idx=0, duIdx=0;
11381    uint8_t duUeF1apId = 0, cuUeF1apId = 0;
11382    DuDb *duDb = NULLP;
11383    CuUeCb *ueCb = NULLP;
11384    UEContextModificationResponse_t *ueCtxtModRsp = NULLP;
11385
11386    SEARCH_DU_DB(duIdx, duId, duDb);
11387    ueCtxtModRsp = &f1apMsg->choice.successfulOutcome->value.choice.UEContextModificationResponse;
11388
11389    for(idx=0; idx < ueCtxtModRsp->protocolIEs.list.count; idx++)
11390    {
11391       switch(ueCtxtModRsp->protocolIEs.list.array[idx]->id)
11392       {
11393           case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
11394              {
11395                 cuUeF1apId = ueCtxtModRsp->protocolIEs.list.array[idx]->value.choice.GNB_CU_UE_F1AP_ID;
11396                 break;
11397              }
11398           case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
11399              {
11400                 duUeF1apId = ueCtxtModRsp->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID;
11401                 ueCb = &duDb->ueCb[duUeF1apId-1];
11402                 break;
11403              }
11404           case ProtocolIE_ID_id_DRBs_SetupMod_List:
11405              {
11406                 /* Adding Tunnels for successful DRB */
11407                 procDrbSetupModList(duId, ueCb, &ueCtxtModRsp->protocolIEs.list.array[idx]->value.choice.DRBs_SetupMod_List);
11408                 break;
11409
11410              }
11411           case ProtocolIE_ID_id_SRBs_SetupMod_List:
11412              {
11413                 procSrbSetupModList(ueCb, &ueCtxtModRsp->protocolIEs.list.array[idx]->value.choice.SRBs_SetupMod_List);
11414                 break;
11415              }
11416          case ProtocolIE_ID_id_DUtoCURRCInformation:
11417              {
11418                 DU_LOG("\nINFO  -->  Received Du to Cu RRC Information ");
11419                 if((extractDuToCuRrcCont(ueCb, ueCtxtModRsp->protocolIEs.list.array[idx]->value.choice.\
11420                    DUtoCURRCInformation.cellGroupConfig)) != ROK)
11421                 {
11422                    DU_LOG("\nERROR  -->  F1AP : Failed to extract Du to Cu RRC Information");
11423                    return RFAILED;
11424                 }
11425                 break;
11426              }
11427
11428       }
11429    }
11430
11431    /* If UE is in handover and UE context is not yet created at target DU, then send
11432     * UE context setup request to target DU */
11433    if(ueCb->state == UE_HANDOVER_IN_PROGRESS)
11434    {
11435       uint8_t ueIdx = 0;
11436       DuDb *tgtDuDb = NULLP;
11437       CuUeCb *ueCbInTgtDu = NULLP;
11438
11439       SEARCH_DU_DB(duIdx, ueCb->hoInfo.targetDuId, tgtDuDb);
11440       if(tgtDuDb)
11441       {
11442          /* Since DU UE F1AP ID assigned by target DU to this UE in handover is
11443           * not known here, using CU UE F1AP ID to search for UE Cb in target DU
11444           * DB */
11445          for(ueIdx = 0; ueIdx < MAX_NUM_UE; ueIdx++)
11446          {
11447             if(tgtDuDb->ueCb[ueIdx].gnbCuUeF1apId == cuUeF1apId)
11448             {
11449                ueCbInTgtDu = &tgtDuDb->ueCb[ueIdx];
11450                break;
11451             }
11452          }
11453
11454          /* If UE context is not found in Target DU DU, send UE context setup
11455           * request */
11456          if(ueCbInTgtDu == NULLP)
11457          {
11458             if((BuildAndSendUeContextSetupReq(ueCb->hoInfo.targetDuId, ueCb, 0, NULLP)) != ROK)
11459             {
11460                DU_LOG("\nERROR  ->  F1AP : Failed at BuildAndSendUeContextSetupReq");
11461                return RFAILED;
11462             }
11463          }
11464       }
11465    }
11466
11467    return ROK;
11468 }
11469
11470 /*******************************************************************
11471 *
11472 * @brief processing of F1 setup request
11473 *
11474 * @details
11475 *
11476 *    Function : procF1SetupReq
11477 *
11478 *    Functionality:
11479 *         - processing of  F1 setup request
11480 *
11481 * @params[in] F1AP_PDU_t *f1apMsg
11482 * @return ROK     - success
11483 *         RFAILED - failure
11484 *
11485 * ****************************************************************/
11486 void procF1SetupReq(uint32_t *destDuId, F1AP_PDU_t *f1apMsg)
11487 {
11488    uint8_t ieIdx = 0, plmnidx=0, duIdx = 0, ret=ROK, cellIdx = 0;
11489    uint32_t duId = 0, nrCellId = 0;
11490    DuDb     *duDb = NULLP;
11491    CuCellCb *cellCb = NULLP;
11492    BIT_STRING_t nrcellIdentity;
11493    F1SetupRequest_t *f1SetupReq = NULLP;
11494    GNB_DU_Served_Cells_Item_t *srvCellItem = NULLP;
11495    GNB_DU_Served_Cells_List_t *duServedCell = NULLP;
11496
11497    f1SetupReq = &f1apMsg->choice.initiatingMessage->value.choice.F1SetupRequest;
11498    for(ieIdx=0; ieIdx < f1SetupReq->protocolIEs.list.count; ieIdx++)
11499    {
11500       switch(f1SetupReq->protocolIEs.list.array[ieIdx]->id)
11501       {
11502          case ProtocolIE_ID_id_gNB_DU_ID:
11503            {
11504               duId = f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf[0];
11505               SEARCH_DU_DB(duIdx, duId, duDb);
11506               if(duDb == NULLP)
11507               {
11508                  duDb = &cuCb.duInfo[cuCb.numDu];
11509                  memset(duDb, 0, sizeof(DuDb));
11510                  duDb->duId = duId;
11511                  cuCb.numDu++;
11512                  *destDuId = duId;
11513               }
11514               else
11515                  return;
11516               break;
11517            }
11518          case ProtocolIE_ID_id_gNB_DU_Name:
11519            {
11520               strcpy((char *)duDb->duName, (char*)f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_Name.buf);
11521               break;
11522            }
11523          case ProtocolIE_ID_id_gNB_DU_Served_Cells_List:
11524            {
11525                duServedCell = &f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_Served_Cells_List;
11526                if(duServedCell->list.array)
11527                {
11528                   for(plmnidx=0; plmnidx<duServedCell->list.count; plmnidx++)
11529                   {
11530                      if(duServedCell->list.array[plmnidx])
11531                      {
11532                         switch(duServedCell->list.array[plmnidx]->id)
11533                         {
11534                            case ProtocolIE_ID_id_GNB_DU_Served_Cells_Item:
11535                            {
11536                               srvCellItem =  &duServedCell->list.array[plmnidx]->value.choice.GNB_DU_Served_Cells_Item;
11537                               ret = procServedCellPlmnList(&srvCellItem->served_Cell_Information.servedPLMNs);
11538                               memcpy(&nrcellIdentity, &srvCellItem->served_Cell_Information.nRCGI.nRCellIdentity, sizeof(BIT_STRING_t));
11539
11540                               nrCellId = nrcellIdentity.buf[4] >> nrcellIdentity.bits_unused;
11541                               SEARCH_CELL_DB(cellIdx, duDb, nrCellId, cellCb);
11542                               if(cellCb == NULLP)
11543                               {
11544                                  cellCb = &duDb->cellCb[duDb->numCells];
11545                                  memset(cellCb, 0, sizeof(CuCellCb));
11546                                  cellCb->nrCellId = nrCellId;
11547                                  cellCb->cellStatus = CELL_ACTIVE;
11548                                  duDb->numCells++;
11549                               }
11550                            }
11551                         }
11552                      }
11553                   }
11554                }
11555            }
11556       }
11557    }
11558    if(ret == ROK)
11559    {
11560       BuildAndSendF1SetupRsp(duId, &nrcellIdentity);
11561    }
11562    else
11563    {
11564        DU_LOG("\nERROR  --> CU_STUB: procF1SetupReq(): Failed to process F1 setup request");
11565    }
11566 }
11567
11568 /****************************************************************
11569 *
11570 * @brief processing of UE Context Release Complete
11571 *
11572 * @details
11573 *
11574 *    Function : procUeContextReleaseComplete
11575 *
11576 *    Functionality:
11577 *         - processing of UE Context Release Complete
11578 *
11579 * @params[in] F1AP_PDU_t *f1apMsg
11580 * @return ROK     - success
11581 *         RFAILED - failure
11582 *
11583 * ****************************************************************/
11584 void procUeContextReleaseComplete(uint32_t duId, F1AP_PDU_t *f1apMsg)
11585 {
11586    uint8_t duIdx = 0, ieIdx = 0, ueIdx = 0;
11587    uint8_t gnbDuUeF1apId = 0, gnbCuUeF1apId = 0;
11588    DuDb *duDb = NULLP;
11589    CuUeCb *ueCb = NULLP;
11590    UEContextReleaseComplete_t *ueReleaseComplete = NULLP;
11591
11592    SEARCH_DU_DB(duIdx, duId, duDb);
11593    if(!duDb)
11594    {
11595       DU_LOG("\nERROR  -->  F1AP : No entry found for DU ID [%d]", duId);
11596       return;
11597    }
11598
11599    ueReleaseComplete = &f1apMsg->choice.successfulOutcome->value.choice.UEContextReleaseComplete;
11600    for(ieIdx=0; ieIdx < ueReleaseComplete->protocolIEs.list.count; ieIdx++)
11601    {
11602       switch(ueReleaseComplete->protocolIEs.list.array[ieIdx]->id)
11603       {
11604          case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
11605             {
11606                gnbCuUeF1apId = ueReleaseComplete->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID;
11607                break;
11608             }
11609          case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
11610             {
11611                gnbDuUeF1apId = ueReleaseComplete->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID;
11612                ueCb = &duDb->ueCb[gnbDuUeF1apId-1];
11613                for(ueIdx = 0; ueIdx <MAX_NUM_UE; ueIdx++)
11614                {
11615                   if(ueCb->cellCb && ueCb->cellCb->ueCb[ueIdx])
11616                   {
11617                      if((ueCb->cellCb->ueCb[ueIdx]->gnbCuUeF1apId == gnbCuUeF1apId) &&
11618                            (ueCb->cellCb->ueCb[ueIdx]->gnbDuUeF1apId == gnbDuUeF1apId))
11619                      {
11620                         ueCb->cellCb->ueCb[ueIdx] = NULLP;
11621                         ueCb->cellCb->numUe--;
11622                         if((ueCb->cellCb->numUe == 0) && (ueCb->cellCb->cellStatus = CELL_DELETION_IN_PROGRESS))
11623                         {
11624                            memset(ueCb->cellCb, 0, sizeof(CuCellCb));
11625                            duDb->numCells--;
11626                         }
11627                         break;
11628                      }
11629                   }
11630                }
11631                memset(ueCb, 0, sizeof(CuUeCb));
11632                duDb->numUe--;
11633                break;
11634             }
11635       }
11636    }
11637 }
11638
11639 /*******************************************************************
11640  *
11641  * @brief Builds the Paging cell list
11642  *
11643  * @details
11644  *
11645  *    Function : BuildPagingCellList
11646  *
11647  *    Functionality: Build the paging cell list
11648  *
11649  * @params[in] PagingCell_list_t  *pagingCelllist,
11650  *
11651  * @return ROK     - success
11652  *         RFAILED - failure
11653  *
11654  * ****************************************************************/
11655 uint8_t BuildPagingCellList(PagingCell_list_t *pagingCelllist, uint8_t numCells, CuCellCb *cellCb)
11656 {
11657    uint8_t cellIdx =0;
11658    PagingCell_ItemIEs_t *pagingCellItemIes;
11659    PagingCell_Item_t *pagingCellItem;
11660
11661    pagingCelllist->list.count = numCells;
11662    pagingCelllist->list.size = pagingCelllist->list.count * (sizeof(PagingCell_ItemIEs_t*));
11663    CU_ALLOC(pagingCelllist->list.array, pagingCelllist->list.size);
11664    if(pagingCelllist->list.array == NULLP)
11665    {
11666       DU_LOG("\nERROR  -->  F1AP : BuildPagingCellList(): Memory allocation failed ");
11667       return RFAILED;
11668    }
11669
11670    for(cellIdx = 0; cellIdx < pagingCelllist->list.count; cellIdx++)
11671    {
11672       CU_ALLOC(pagingCelllist->list.array[cellIdx], sizeof(PagingCell_ItemIEs_t));
11673       if(pagingCelllist->list.array[cellIdx] == NULLP)
11674       {
11675          DU_LOG("\nERROR  -->  F1AP : BuildPagingCellList(): Memory allocation failed ");
11676          return RFAILED;
11677       }
11678    }
11679
11680    for(cellIdx = 0; cellIdx < pagingCelllist->list.count; cellIdx++)
11681    {
11682       pagingCellItemIes = (PagingCell_ItemIEs_t *)pagingCelllist->list.array[cellIdx];
11683       pagingCellItemIes->id =  ProtocolIE_ID_id_PagingCell_Item;
11684       pagingCellItemIes->criticality = Criticality_ignore;
11685       pagingCellItemIes->value.present = PagingCell_ItemIEs__value_PR_PagingCell_Item;
11686       pagingCellItem = &pagingCellItemIes->value.choice.PagingCell_Item;
11687
11688       /* Fill NrCgi Information */
11689       BuildNrcgi(&pagingCellItem->nRCGI, cellCb[cellIdx].nrCellId);
11690    }
11691
11692    return ROK;
11693 }
11694
11695 /*******************************************************************
11696  *
11697  * @brief Deallocation of memory allocated in paging msg
11698  *
11699  * @details
11700  *
11701  *    Function :FreePagingMsg
11702  *
11703  *    Functionality: Deallocation of memory allocated in paging msg
11704  *
11705  * @params[in] F1AP_PDU_t *f1apMsg
11706  *
11707  * @return void
11708  *
11709  * ****************************************************************/
11710 void FreePagingMsg(F1AP_PDU_t *f1apMsg)
11711 {
11712    uint8_t ieIdx, cellIdx;
11713    Paging_t   *paging;
11714    PagingCell_ItemIEs_t *pagingCellItemIes;
11715    PagingCell_Item_t *pagingCellItem;
11716    PagingCell_list_t  *pagingCelllist;
11717
11718    if(f1apMsg)
11719    {
11720       if(f1apMsg->choice.initiatingMessage)
11721       {
11722          paging = &f1apMsg->choice.initiatingMessage->value.choice.Paging;
11723          if(paging->protocolIEs.list.array)
11724          {
11725             for(ieIdx=0 ; ieIdx<paging->protocolIEs.list.count; ieIdx++)
11726             {
11727                if(paging->protocolIEs.list.array[ieIdx])
11728                {
11729                   switch(paging->protocolIEs.list.array[ieIdx]->id)
11730                   {
11731                      case ProtocolIE_ID_id_UEIdentityIndexValue:
11732                      {
11733                         CU_FREE(paging->protocolIEs.list.array[ieIdx]->value.choice.UEIdentityIndexValue.choice.indexLength10.buf,\
11734                         paging->protocolIEs.list.array[ieIdx]->value.choice.UEIdentityIndexValue.choice.indexLength10.size);
11735                         break;
11736                      }
11737
11738                      case ProtocolIE_ID_id_PagingIdentity:
11739                      {
11740                         if(paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.present == PagingIdentity_PR_cNUEPagingIdentity)
11741                         {
11742                            if(paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity)
11743                            {
11744                               if(paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity->present == CNUEPagingIdentity_PR_fiveG_S_TMSI)
11745                               {
11746                                  CU_FREE(paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity->choice.fiveG_S_TMSI.buf,\
11747                                  paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity->choice.fiveG_S_TMSI.size);
11748                               }
11749                                 CU_FREE(paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity,\
11750                                 sizeof(struct CNUEPagingIdentity));
11751                            }
11752                         }
11753                         break;
11754                      }
11755
11756                      case ProtocolIE_ID_id_PagingCell_List:
11757                      {
11758                         pagingCelllist = &paging->protocolIEs.list.array[ieIdx]->value.choice.PagingCell_list;
11759                         if(pagingCelllist->list.array)
11760                         {
11761                            for(cellIdx = 0; cellIdx < pagingCelllist->list.count; cellIdx++)
11762                            {
11763                               if(pagingCelllist->list.array[cellIdx])
11764                               {
11765                                   pagingCellItemIes = (PagingCell_ItemIEs_t *)pagingCelllist->list.array[cellIdx];
11766                                   if(pagingCellItemIes->id == ProtocolIE_ID_id_PagingCell_Item)
11767                                   {
11768                                      pagingCellItem = &pagingCellItemIes->value.choice.PagingCell_Item;
11769                                      CU_FREE(pagingCellItem->nRCGI.pLMN_Identity.buf, pagingCellItem->nRCGI.pLMN_Identity.size);
11770                                      CU_FREE(pagingCellItem->nRCGI.nRCellIdentity.buf, pagingCellItem->nRCGI.nRCellIdentity.size);
11771                                   }
11772                                   CU_FREE(pagingCelllist->list.array[cellIdx], sizeof(PagingCell_ItemIEs_t));
11773                               }
11774                            }
11775                            CU_FREE(pagingCelllist->list.array, pagingCelllist->list.size);
11776                         }
11777                         break;
11778                      }
11779                   }
11780                   CU_FREE(paging->protocolIEs.list.array[ieIdx], sizeof(Paging_t));
11781                }
11782             }
11783             CU_FREE(paging->protocolIEs.list.array, paging->protocolIEs.list.size);
11784          }
11785          CU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
11786       }
11787       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
11788    }
11789 }
11790 /*******************************************************************
11791  *
11792  * @brief Builds and sends the paging message if UE is in idle mode
11793  *
11794  * @details
11795  *
11796  *    Function : BuildAndSendPagingMsg
11797  *
11798  *    Functionality: Builds and sends the paging message
11799  *
11800  * @params[in] uint32_t duId, uint8_t gsTmsi
11801  *
11802  * @return ROK     - success
11803  *         RFAILED - failure
11804  *
11805  * ****************************************************************/
11806 uint8_t BuildAndSendPagingMsg(uint64_t gsTmsi, uint8_t duId)
11807 {
11808    bool       memAllocFailed = false;
11809    uint8_t    ieIdx = 0, elementCnt = 0, ret = RFAILED;
11810    uint16_t   ueId = 0, duIdx = 0;
11811
11812    /*As per 38.473 Sec 9.3.1.39, UE Identity Index Value (10bits) > 2 Bytes + 6 Unused Bits
11813     *5G-S-TMSI :48 Bits  >> 6 Bytes and 0 UnusedBits */
11814    uint8_t    totalByteInUeId = 2, totalByteInTmsi = 6;
11815    uint8_t    unusedBitsInUeId = 6, unusedBitsInTmsi = 0;
11816
11817    F1AP_PDU_t *f1apMsg = NULLP;
11818    Paging_t   *paging = NULLP;
11819    DuDb       *duDb;
11820    asn_enc_rval_t         encRetVal;
11821
11822    DU_LOG("\nINFO  -->  F1AP : Building PAGING Message command\n");
11823
11824    SEARCH_DU_DB(duIdx, duId, duDb);
11825    if(duDb == NULLP)
11826    {
11827       DU_LOG("\nERROR  -->  F1AP : BuildAndSendPagingMsg(): DuDb is empty");
11828       return ret;
11829    }
11830
11831    while(true)
11832    {
11833       CU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
11834       if(f1apMsg == NULLP)
11835       {
11836          DU_LOG("\nERROR  -->  F1AP : BuildAndSendPagingMsg(): Memory allocation for F1AP-PDU");
11837          break;
11838       }
11839
11840       f1apMsg->present =  F1AP_PDU_PR_initiatingMessage;
11841
11842       CU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
11843       if(f1apMsg->choice.initiatingMessage == NULLP)
11844       {
11845          DU_LOG("\nERROR  -->  F1AP : BuildAndSendPagingMsg(): Memory allocation for F1AP-PDU failed ");
11846          break;
11847       }
11848       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_Paging;
11849       f1apMsg->choice.initiatingMessage->criticality = Criticality_reject;
11850       f1apMsg->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_Paging;
11851
11852       paging = &f1apMsg->choice.initiatingMessage->value.choice.Paging;
11853
11854       elementCnt = 5;
11855       paging->protocolIEs.list.count = elementCnt;
11856       paging->protocolIEs.list.size = elementCnt * sizeof(Paging_t*);
11857
11858       /* Initialize the Paging Message members */
11859       CU_ALLOC(paging->protocolIEs.list.array, paging->protocolIEs.list.size);
11860       if(paging->protocolIEs.list.array == NULLP)
11861       {
11862          DU_LOG("\nERROR  -->  F1AP : BuildAndSendPagingMsg():Memory allocation failed");
11863          break;
11864       }
11865
11866       for(ieIdx=0 ; ieIdx<elementCnt; ieIdx++)
11867       {
11868          CU_ALLOC(paging->protocolIEs.list.array[ieIdx], sizeof(Paging_t));
11869          if(paging->protocolIEs.list.array[ieIdx] == NULLP)
11870          {
11871             DU_LOG("\nERROR  -->  F1AP : BuildAndSendPagingMsg(): Memory allocation failed ");
11872             memAllocFailed = true;
11873             break;
11874          }
11875       }
11876
11877       if(memAllocFailed == true)
11878       {
11879          break;
11880       }
11881
11882       /* UE Identity Index Value */
11883       ieIdx=0;
11884       paging->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_UEIdentityIndexValue;
11885       paging->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
11886       paging->protocolIEs.list.array[ieIdx]->value.present = PagingIEs__value_PR_UEIdentityIndexValue;
11887       paging->protocolIEs.list.array[ieIdx]->value.choice.UEIdentityIndexValue.present = UEIdentityIndexValue_PR_indexLength10;
11888       paging->protocolIEs.list.array[ieIdx]->value.choice.UEIdentityIndexValue.choice.indexLength10.size = totalByteInUeId*sizeof(uint8_t);
11889       CU_ALLOC(paging->protocolIEs.list.array[ieIdx]->value.choice.UEIdentityIndexValue.choice.indexLength10.buf,\
11890             paging->protocolIEs.list.array[ieIdx]->value.choice.UEIdentityIndexValue.choice.indexLength10.size);
11891       if(paging->protocolIEs.list.array[ieIdx]->value.choice.UEIdentityIndexValue.choice.indexLength10.buf == NULLP)
11892       {
11893          DU_LOG("\nERROR  -->  F1AP : BuildAndSendPagingMsg(): Memory allocation failed ");
11894          break;
11895       }
11896
11897       /*As per 3gpp Spec 38.304 Sec 7.1: UE_ID: 5G-S-TMSI mod 1024*/
11898       ueId = gsTmsi % 1024;
11899       fillBitString(&paging->protocolIEs.list.array[ieIdx]->value.choice.UEIdentityIndexValue.choice.indexLength10, unusedBitsInUeId, totalByteInUeId, ueId);
11900
11901       /* Paging Identity */
11902       ieIdx++;
11903       paging->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_PagingIdentity;
11904       paging->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
11905       paging->protocolIEs.list.array[ieIdx]->value.present = PagingIEs__value_PR_PagingIdentity;
11906       paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.present = \
11907                                                                                    PagingIdentity_PR_cNUEPagingIdentity;
11908       CU_ALLOC(paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity, \
11909             sizeof(struct CNUEPagingIdentity));
11910       if(!paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity)
11911       {
11912          DU_LOG("\nERROR  -->  F1AP : BuildAndSendPagingMsg(): Memory allocation failed ");
11913          break;
11914       }
11915
11916       paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity->present = \
11917                                                                                                               CNUEPagingIdentity_PR_fiveG_S_TMSI;
11918
11919       paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity->choice.fiveG_S_TMSI.size = totalByteInTmsi*sizeof(uint8_t);
11920       CU_ALLOC(paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity->choice.fiveG_S_TMSI.buf,\
11921             paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity->choice.fiveG_S_TMSI.size);
11922       if(!paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity->choice.fiveG_S_TMSI.buf)
11923       {
11924          DU_LOG("\nERROR  -->  F1AP : BuildAndSendPagingMsg(): Memory allocation failed ");
11925          break;
11926       }
11927
11928       fillBitString(&paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity->choice.fiveG_S_TMSI,\
11929             unusedBitsInTmsi, totalByteInTmsi, gsTmsi);
11930
11931       /* Paging Drx */
11932       ieIdx++;
11933       paging->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_PagingDRX;
11934       paging->protocolIEs.list.array[ieIdx]->criticality = Criticality_ignore;
11935       paging->protocolIEs.list.array[ieIdx]->value.present = PagingIEs__value_PR_PagingDRX;
11936       paging->protocolIEs.list.array[ieIdx]->value.choice.PagingDRX = PagingDRX_v32;
11937
11938       /* Paging Priority */
11939       ieIdx++;
11940       paging->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_PagingPriority;
11941       paging->protocolIEs.list.array[ieIdx]->criticality = Criticality_ignore;
11942       paging->protocolIEs.list.array[ieIdx]->value.present = PagingIEs__value_PR_PagingPriority;
11943       paging->protocolIEs.list.array[ieIdx]->value.choice.PagingPriority = PagingPriority_priolevel2;
11944
11945       /* Paging Cell List */
11946       ieIdx++;
11947       paging->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_PagingCell_List;
11948       paging->protocolIEs.list.array[ieIdx]->criticality = Criticality_ignore;
11949       paging->protocolIEs.list.array[ieIdx]->value.present = PagingIEs__value_PR_PagingCell_list;
11950       if(BuildPagingCellList(&paging->protocolIEs.list.array[ieIdx]->value.choice.PagingCell_list, duDb->numCells, duDb->cellCb) != ROK)
11951       {
11952          DU_LOG("\nERROR  -->  F1AP : BuildAndSendPagingMsg(): Failed to build Paging cell list ");
11953          break;
11954       }
11955
11956       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
11957
11958       /* Encode the UE Context Release Command type as APER */
11959       memset(encBuf, 0, ENC_BUF_MAX_LEN);
11960       encBufSize = 0;
11961       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
11962             encBuf);
11963
11964       /* Encode results */
11965       if(encRetVal.encoded == ENCODE_FAIL)
11966       {
11967          DU_LOG("\nERROR  -->  F1AP : Could not encode Release Command structure (at %s)\n",\
11968                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
11969          break;
11970       }
11971       else
11972       {
11973          DU_LOG("\nDEBUG  -->  F1AP : Created APER encoded buffer for Paging\n");
11974          for(ieIdx=0; ieIdx< encBufSize; ieIdx++)
11975          {
11976             DU_LOG("%x",encBuf[ieIdx]);
11977          }
11978       }
11979
11980       if(SendF1APMsg(CU_APP_MEM_REG, CU_POOL, duId) != ROK)
11981       {
11982          DU_LOG("\nERROR  -->  F1AP : Sending Ue context Release Command failed");
11983          break;
11984       }
11985
11986       ret = ROK;
11987       break;
11988
11989    }
11990
11991    FreePagingMsg(f1apMsg);
11992    return ret;
11993 }
11994
11995 /*******************************************************************
11996  *
11997  * @brief Handles received F1AP message and sends back response
11998  *
11999  * @details
12000  *
12001  *    Function : F1APMsgHdlr
12002  *
12003  *    Functionality:
12004  *         - Decodes received F1AP control message
12005  *         - Prepares response message, encodes and sends to SCTP
12006  *
12007  * @params[in]
12008  * @return ROK     - success
12009  *         RFAILED - failure
12010  *
12011  * ****************************************************************/
12012 void F1APMsgHdlr(uint32_t *duId, Buffer *mBuf)
12013 {
12014    int i;
12015    char *recvBuf;
12016    MsgLen copyCnt;
12017    MsgLen recvBufLen;
12018    F1AP_PDU_t *f1apMsg = NULLP;
12019    asn_dec_rval_t rval; /* Decoder return value */
12020    F1AP_PDU_t f1apasnmsg ;
12021
12022    DU_LOG("\nINFO  -->  F1AP : Received F1AP message buffer");
12023    ODU_PRINT_MSG(mBuf, 0,0);
12024
12025    /* Copy mBuf into char array to decode it */
12026    ODU_GET_MSG_LEN(mBuf, &recvBufLen);
12027    CU_ALLOC(recvBuf, (Size)recvBufLen);
12028
12029    if(recvBuf == NULLP)
12030    {
12031       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed");
12032       return;
12033    }
12034    if(ODU_COPY_MSG_TO_FIX_BUF(mBuf, 0, recvBufLen, (Data *)recvBuf, &copyCnt) != ROK)
12035    {
12036       DU_LOG("\nERROR  -->  F1AP : Failed while copying %d", copyCnt);
12037       return;
12038    }
12039
12040    DU_LOG("\nDEBUG  -->  F1AP : Received flat buffer to be decoded : ");
12041    for(i=0; i< recvBufLen; i++)
12042    {
12043       DU_LOG("%x",recvBuf[i]);
12044    }
12045
12046    /* Decoding flat buffer into F1AP messsage */
12047    f1apMsg = &f1apasnmsg;
12048    memset(f1apMsg, 0, sizeof(F1AP_PDU_t));
12049
12050    rval = aper_decode(0, &asn_DEF_F1AP_PDU, (void **)&f1apMsg, recvBuf, recvBufLen, 0, 0);
12051    CU_FREE(recvBuf, (Size)recvBufLen);
12052
12053    if(rval.code == RC_FAIL || rval.code == RC_WMORE)
12054    {
12055       DU_LOG("\nERROR  -->  F1AP : ASN decode failed");
12056       return;
12057    }
12058    DU_LOG("\n");
12059    xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
12060
12061    switch(f1apMsg->present)
12062    {
12063       case F1AP_PDU_PR_initiatingMessage:
12064          {
12065             switch(f1apMsg->choice.initiatingMessage->value.present)
12066             {
12067                case InitiatingMessage__value_PR_Reset:
12068                   {
12069                      DU_LOG("\nINFO  -->  F1AP : F1 reset request received ");
12070                      BuildAndSendF1ResetAck();
12071                      break;
12072                   }
12073
12074                case InitiatingMessage__value_PR_F1SetupRequest:
12075                   {
12076                      DU_LOG("\nINFO  -->  F1AP : F1 setup request received");
12077                      procF1SetupReq(duId, f1apMsg);
12078                      break;
12079                   }
12080
12081                case InitiatingMessage__value_PR_GNBDUConfigurationUpdate:
12082                   {
12083                      DU_LOG("\nINFO  -->  F1AP : GNB-DU config update received");
12084                      procGnbDuUpdate(*duId, f1apMsg);
12085                      break;
12086                   }
12087                case InitiatingMessage__value_PR_InitialULRRCMessageTransfer:
12088                   {
12089                      DU_LOG("\nINFO  -->  F1AP : Received InitialULRRCMessageTransfer");
12090                      procInitULRRCMsg(*duId, f1apMsg);
12091                      break;
12092                   }
12093                case InitiatingMessage__value_PR_ULRRCMessageTransfer:
12094                   {
12095                      DU_LOG("\nINFO  -->  F1AP : Received ULRRCMessageTransfer");
12096                      procUlRrcMsg(*duId, f1apMsg);
12097                      break;
12098                   }
12099
12100                case InitiatingMessage__value_PR_RRCDeliveryReport:
12101                   {
12102                      DU_LOG("\nINFO  -->  F1AP : Received RRC delivery report");
12103                      break;
12104                   }
12105                case InitiatingMessage__value_PR_UEContextReleaseRequest:
12106                   {
12107                      DU_LOG("\nINFO  -->  F1AP : Received UE Context Release Request");
12108                      procUeContextReleaseReq(*duId, f1apMsg);
12109                      break;
12110                   }
12111                default:
12112                   {
12113                      DU_LOG("\nERROR  -->  F1AP : Invalid type of intiating message [%d]",\
12114                            f1apMsg->choice.initiatingMessage->value.present);
12115                      return;
12116                   }
12117             }/* End of switch(initiatingMessage) */
12118             break;
12119          }
12120
12121       case F1AP_PDU_PR_successfulOutcome:
12122          {
12123             switch(f1apMsg->choice.successfulOutcome->value.present)
12124             {
12125                case SuccessfulOutcome__value_PR_ResetAcknowledge:
12126                   {
12127                      DU_LOG("\nINFO  -->  F1Reset Acknowledgement is received successfully ");
12128                      break;
12129                   }
12130                case SuccessfulOutcome__value_PR_UEContextSetupResponse:
12131                   {
12132                      DU_LOG("\nINFO  -->  F1AP : UE ContextSetupResponse received");
12133                      procUeContextSetupResponse(*duId, f1apMsg);
12134                      break;
12135                   }
12136                case SuccessfulOutcome__value_PR_UEContextModificationResponse:
12137                   {
12138                      DU_LOG("\nINFO  -->  F1AP : UE Context Modification Response received");
12139                      procUeContextModificationResponse(*duId, f1apMsg);
12140                      break;
12141                   }
12142                case SuccessfulOutcome__value_PR_UEContextReleaseComplete:
12143                   {
12144                       DU_LOG("\nINFO  -->  F1AP : UE Context release complete received");
12145                       procUeContextReleaseComplete(*duId, f1apMsg);
12146                       break;
12147                   }
12148                default:
12149                   {
12150                      DU_LOG("\nERROR  -->  F1AP : Invalid type of successful outcome message [%d]",\
12151                            f1apMsg->choice.successfulOutcome->value.present);
12152                      return;
12153                   }
12154             }/* End of switch(successfulOutcome) */
12155             break;
12156          }
12157       default:
12158          {
12159             DU_LOG("\nERROR  -->  F1AP : Invalid type of f1apMsg->present [%d]",f1apMsg->present);
12160             return;
12161          }
12162    }/* End of switch(f1apMsg->present) */
12163
12164 } /* End of F1APMsgHdlr */
12165
12166 /**********************************************************************
12167   End of file
12168  **********************************************************************/